Field notes, essays, and methodology from building software with AI daily. The practical application of making complexity visible in software systems.
AI-assisted engineering is not a trend or a shortcut. It is a fundamental change in how software gets made, and if you are building software right now, you are already in the middle of it whether you have chosen to be or not.
I started writing about this in earnest in mid-2025 after spending six weeks working almost exclusively in agent mode. What I found surprised me. The productivity gains were real, but they were secondary. The bigger story was cognitive: working alongside AI changes how you think about problems, how you scope work, how you evaluate what is worth doing yourself and what is worth delegating. These are not minor adjustments. They are architectural changes to the development process.
The essays collected here are field notes from that ongoing experiment. They cover the workflows that actually work, the failure modes no one warned me about, the cognitive side effects of working at machine speed, and what it looks like when you apply these patterns to real infrastructure, real content pipelines, and real business software, not demos and toy projects.
One consistent theme: AI-assisted development requires more engineering judgment, not less. The models can write code. They cannot decide what to build, catch the architectural mistake that compounds into a rewrite six months later, or know when good enough is actually good enough. That judgment remains human work. The goal is to free up time and cognitive load for it.
Start with the complete series overview if you want the full arc. Or pick any single essay if you have a specific question. They are written to stand alone as well as build on each other.
The full series in one place, from the first shock of working alongside AI to building autonomous agents, infrastructure, content pipelines, and business apps. If you read one thing, start here.
A clear-eyed look at what separates deliberate AI-assisted development from prompting-and-hoping. The distinction matters more as models get more capable, not less.
What happens to your thinking when you work alongside AI for six weeks straight. The cognitive changes are real, unexpected, and worth examining.
The moment everything changed, from using AI as a fancy autocomplete to treating it as a collaborator with its own strengths and failure modes.
The workflow patterns that actually stick. How to structure prompts, manage context, and build a feedback loop that makes AI collaboration sustainable.
AI doesn't just write application code. When you apply the same patterns to infrastructure, Dockerfiles, CDK stacks, CI pipelines, the leverage multiplies.
How AI changes the economics of content creation: OCR pipelines, automation scripts, publishing workflows, and keeping the human voice central.
From trading dashboards to membership platforms, applying AI-assisted development patterns to real business software with production requirements.
Where this is heading. The economic and professional implications of AI-assisted development at scale, for individual developers, teams, and the craft itself.
The techniques that emerge after months of practice: multi-agent orchestration, context management at scale, architectural decision-making with AI.
The current work, tightly themed: what agent mode and autonomous mode actually are, the workflow that holds up, and how the same patterns reshape DevOps and architecture.
Three weeks after Hello, I pulled the thread and the warm front door turned out to be the outermost loop, the one that asks whether the whole system can still become useful. On cybernetics, nested watchers that each live outside the failure boundary of the thing they watch, and the rule I hold hardest: the model proposes but never gets its own hands.
I typed my thirty-two loops, drew them as a graph, and thought the loop was the top of the system. It is the roof of a stack eight floors deep, and the floor holding all the weight is the smallest one: the edge. The doctrine under the legibility series, from a single relationship up to the rule the whole thing exists to protect: world, belief, and action never collapse into each other.
Thirty-two automated jobs, every one written by me, and I could not hold the system in my head. The problem was never memory. It was a word: "loop" was one word doing the work of seven, and a word that vague cannot carry rules. Typing the loops, and why naming the latent grammar of a system you built is cartography aimed inward.
The best thing anyone told me about my own system this year was that I had not invented it. The scripts I grew by hand are a data pipeline, the shape is a DAG, and the discipline is solved. What Airflow, Dagster, and dbt actually sell, and the difference between wanting an engine and wanting a map.
I gave every job a receipt, a health check, and a green light, and the system still would not fit in my head. A dashboard shows the state of the parts; every question that mattered was about the shape of the whole. Same data, different projection: the dependency graph that turned thirty-two jobs into a short critical chain.
Most pipeline rules ride along free with a loop's type. The one that does not, every file gets exactly one job that writes it, is the one my system was breaking, and the reason its middle felt like soup. On contracts, deliberate violations versus drift, and systems that govern the code you have not written yet.
Making complexity visible is the method; orientation is the objective function. The first field report on the research program: an installable runtime, private laboratories that keep their data, a candidate legibility measure, and the first pre-registered experiment, running on my own life.
The smallest possible program, written again in a world where the machine can write it for you. What the first line of code is for when the typing is no longer the work, and what it means to build the loop you think inside.
The foundation under the method: how meaning moves through a system, and what shape it takes when it does. Meaning velocity is the rate at which useful meaning becomes visible, transformable, and actionable. Cognitive form is the idea held on its own, apart from any single way of saying it.
Day one. The rough operating method I built today, out of need, on no bandwidth: you talk into a file, one Chief of Staff agent sorts what you said and hands the rest to a few specialist roles, and you review only the exceptions. Gated so nothing irreversible happens unattended. The method is public, your data stays private. The evening my work crossed from AI assisted to agent director.
The fight over whether AI is good or bad is the wrong fight. AI is a friction-removal engine, and there are two kinds of friction: the kind that is building you, and the kind that is only taxing you. Telling them apart, in the moment, is the whole skill. The synthesis of a two-part argument I ran against myself.
Piece I of the dialectic. The strongest version of the argument for the tools, argued in good faith and without the sales pitch, because an argument you have not steelmanned is one you have not actually won.
Piece II of the dialectic. The strongest version of the argument against, run against myself: what you lose when the friction goes, and why the loss is quiet enough that you will not notice it happening.
The invoice for AI is the cheap part: a seat and some tokens. The real bill arrives in four ledgers, financial, attention, coordination, and development. Why AI makes the individual feel fast while the organization barely moves, and where the money actually goes.
AI is brilliant in one place and confidently wrong half a step over, and from the inside the two feel identical. The real skill is not prompting. It is knowing when to delegate, when to steer, when to verify, and when to close the tool and think alone.
The subscription is the small line. The real meter is the time spent feeding context, checking output, catching the confident mistake, and cleaning up work that looked finished. The hidden attention and coordination tax behind the AI productivity paradox.
The same tool that folds a beginner's learning curve shorter can also erase it. AI compresses apprenticeship when it transfers expertise and destroys it when it lets people skip the repetitions that were quietly teaching them. On deskilling and which friction to protect.
My head runs in branches, not lines. Then I started building with an agent that does the long flat middle I cannot sit still for, and amplifies the part I already do too much. On working with AI when your attention has its own ideas, and the fence you have to build first.
AWS is sold as two hundred services. Underneath it is a handful of primitives, and every service is a frozen answer to a distributed-systems trade-off. The map I built studying for the SAA-C03, the patterns above it, and the two questions that decode any new AWS service.
A strict Content-Security-Policy on a static site allowlists inline scripts by hash. Change one script, forget to update the hash, and every page renders blank. The incident that taught me, and the deploy guard that ends it.
The mechanical AI tells you can catch with a script, the ones you cannot, and why detecting AI writing finally comes down to a voice you have to supply yourself.
Why I precompile every post on this Astro site into one committed TypeScript file instead of reading markdown at build time, what it buys, and the one cost you pay to keep it in sync.
Traditional OCR cannot read cursive; a vision model can. The pipeline I built to transcribe years of handwritten journals, the human review it still requires, and the loop that makes it better every batch.
A static site has no server to check a password. How I gated staging with a CloudFront Function instead of Lambda@Edge, kept the credential out of git, and the day the wrong file 503'd the whole thing.
Multi-repo agent work is not a scale problem, it is a context-routing problem. How I scope an agent to one project at a time across thirty-three independent repositories, and why the instruction files do the real work.
I built a graph of every internal link on this site to see its real structure, not the one I imagined. What the map showed about hubs, orphans, and where authority actually flows.
A field report on rebuilding this blog with an agent driving, from the Astro content cache to the AWS deploy. What the work actually took, the failure modes, and what stayed human.
The right metaphor for agent mode is not autopilot, it is the suit. You are still the pilot; the suit makes you faster and stronger. Why that framing changes how you work.
Applying the operational discipline of software, observability, feedback loops, incident review, to the way I run a day. What transfers, and what does not.
Agent mode and autonomous mode get used as synonyms; they are not. In agent mode you close the loop after every task. In autonomous mode the system does, on a schedule or a trigger. A working engineer's disambiguation, and when to use each.
Not a tools list. The tools changed three times this year; what changed underneath is where the hours go: specs in the morning, batch review in the afternoon, and the judgment work that never left.
The code got cheap; the review did not. The workflow I actually use on agent-written diffs: three passes, an adversarial second agent that hunts for bugs, gates that earned their place, and the discipline of reading what ships.
A field report from inside sustained agent-mode work. Not the tools or the benchmarks: the heat behind the eyes, the way speed bends your sense of time, what it costs the body, and the practice that keeps speed from becoming drift.
A plain-spoken manual in the old Linux HOWTO style: workspace setup, the specify-delegate-verify-record loop, hard-won tips, and how to fix the common failure modes. The entry point if you want to actually do this.
AI did not replace software engineers. It moved the bottleneck. The cost of writing code fell to near zero; the cost of deciding what to build did not.
The AI Development Revolution series became a book: a beginner's companion to the AI frontier, written using the very tools it describes. Start reading free here, or read it properly on Kindle and in paperback.
Agentic development is not chatting with a model about your code. It is giving an agent real access to your repository and directing it, with a working method for the loop.
Agent mode is when you stop typing code and start directing an AI that reads your codebase, writes the change, runs the tests, and reports back.
Autonomous mode is when the agent runs the whole loop without you in it: plan, act, check, repeat, until the task is done or it gets stuck.
A practical, repeatable workflow for building software with an AI agent: specify, delegate, verify, record. The loop I run every day.
Agent mode is not a faster way to type. It moves the unit of thought up from syntax to intent and turns you into a conductor of parallel work.
DevOps was always a feedback loop. The version worth building now runs the system back on itself, so every failure becomes information the system uses to harden.
AI took the typing, and the cost of software engineering did not disappear. It moved from the hands to the head and got heavier.
I used GitHub Copilot for a long time, always with Claude underneath, then moved most of my work to Claude Code. A firsthand comparison for DevOps work.
What DevOps means in 2026: the tool stack changed almost completely, and the actual work changed almost not at all.
Microservices used to be a tax a solo builder could not afford. AI agents change that math. Why I am drawn to the architecture for what I build next.
A Beginner's Companion to the AI Frontier
If you want these ideas in a single readable volume, AgentSpek is the book version. It covers the full arc, from first contact with AI tools to working in full agent mode, with personal stories, practical prompts, and a structure designed for developers who want to actually use this stuff, not just read about it.
Disclosure: As an Amazon Associate I earn from qualifying purchases.