How I Build with AI Agents 12 Apr 2026 5 min read
Where my workflow for building with AI agents came from: one long session that failed, the two lanes that replaced it, and three failures that review caught.
One long session AI coding agents built this website, under a process I arrived at by failing in one particular way. The process as I run it today is set out in How I work . This essay is about where it came from.
The failure was one long session. I asked a single conversation to be strategist, product manager, architect, implementer, reviewer and release manager at once. As the context grew, constraints I had set early on blurred, the scope widened, quality dropped, and assumptions made at the start were quietly reinterpreted. The model was capable enough. What failed was the process I had put around it.
Two lanes The fix was to separate orchestration from implementation. I split the work into two lanes, each in its own session, and moved the work between them by hand. The control lane decided what to build, in what order, and whether the result was good enough to accept. The execution lane received one tightly scoped specification, did that piece of work, and returned the result. The execution lane never chose what came next, and the control lane never wrote code.
Slice specifications Each piece of work, which I call a slice, started as a written specification. Before an execution session touched code, the spec stated what the slice would deliver, what it must not do, which files were in scope, what context was deliberately withheld to keep the session focused, the exact commands that would validate the work, and what counted as done. Writing the spec usually took longer than the execution. That was time well spent, because a well-scoped slice came back clean and a vague one came back as plausible code that missed the intent.
The first version of this site took roughly 15 slices. The first set up the project: Next.js 15, TypeScript, Tailwind and a CI pipeline. Each one after that built a single unit, such as the design tokens, the layout shell, the schema for project pages, the test infrastructure or the animations. No slice did two things, and each had to pass an explicit acceptance check before the next began.
What review caught After each slice I reviewed what came back, looking for problems before confirming success. Three results from the site build show why.
One execution session reported that linting had passed. It had run the linter before the build output existed. When I ran it again, hundreds of errors appeared, from compiled files that the ESLint configuration did not exclude. A second session built a Contact component and a Footer that carried different email addresses and different LinkedIn URLs, because it had no memory of what an earlier session had used. A third filled the copy with em dashes, a mark that readers increasingly associate with AI-generated text.
Each of these was caught from outside the session that did the work, and that is the case for keeping review separate: a session that has made a mistake checks its work with the same context that produced the mistake. The second failure also shows what the split costs. One long session would have remembered the email address. Separate sessions share only what has been written down.
Files as memory The most important rule in the workflow follows from that: durable state lives in files in the repository, and session history is disposable. Every session started from the same four documents: an operating model, a living build plan, a decision log and an architecture overview. The repository is private, so I can describe those files here but not link to them. When a control session grew heavy, I restarted it from the files. When an execution session was still failing after two corrections, I ended it and started a new one.
The workflow had costs. Execution sessions still made inconsistent choices from one slice to the next, because they shared no memory beyond those files. The overhead was real as well: writing a detailed spec, carrying it to another session, bringing the result back, reviewing it and logging the decision. For a ten-line fix that felt heavy, and I was often tempted to skip it. When I did, the fix was fine at the time and occasionally caused a consistency problem later.
What it changed What the process changed for me was how much I could build. The code was sometimes better than I would have written alone and sometimes worse. But the first version of this site went from an empty directory to a deployed, tested and documented site in a single working session. Implementation speed had stopped being the constraint, and the quality of the specifications and the rigor of the verification had taken its place.
I think that holds beyond one website. The scarce skills in building software with agents are knowing what to build, how to break it into pieces, and how to verify that what was built is correct. The first two are product and systems thinking. The third also takes engineering knowledge. Rerunning the linter showed the errors, but it took knowing how a build works to see why the first pass had meant nothing. The people who build the most with agents will be the ones who get very good at the control lane.
The workflow has grown since the site was built. A control agent now scopes each change, an implementation agent works in an isolated checkout and returns a pull request, and a separate agent reviews the code against the agreed behavior before I decide whether it ships. The rules underneath are the ones described here. If any of this is useful to you, take what works and make it yours.
Continue the argument Operating model How I work The standing workflow this essay grew into: control lanes, execution slices, and acceptance gates. Calibration essay When the Answer Sounds Finished A broader argument for evidence discipline, abstention, and resisting false closure.