What Pete's AI Coding Workflow Taught Me: It Is Not About More Agents

The leverage is not prompt length or agent count. It is designing tasks, context, verification, and commits as one delivery system that keeps converging.

AI coding is often framed as faster typing: write a detailed prompt, let the model finish, and add more agents when the backlog grows. Pete’s workflow points somewhere more useful. The real advantage is not making a model do more at once; it is turning development into a system that can be observed, interrupted, and verified.

The first move is to turn a request into a testable hypothesis. “Improve onboarding” is vague. A useful task says which user behavior should change, which surfaces can move, which data is off limits, and what evidence will count as done. This is not bureaucracy. It is a way to prevent an agent from being highly productive in the wrong direction.

I now estimate a task’s blast radius before deciding how to run it. A small, local, reversible change can go straight to one agent. A change that touches several states, user paths, or unknown dependencies starts with read-only exploration and options. Parallelism is valuable when it advances independent bets, not when it multiplies uncertainty.

A comparison between small local changes and large cross-module changes — The clearer the blast radius, the easier it is to choose a safe execution mode.

This also makes multi-agent work less mysterious. The thing to manage is not agent count but write conflicts. One agent can improve tests while another documents a module; two agents rewriting the same data flow merely outsource merge and review cost back to you. Split work by module, files, and user paths before you parallelize.

The second move is to treat context as an interface, not a chat transcript. A durable repository records its constraints, decisions, run commands, and acceptance checks where the next task can find them. When the project has this shape, prompts can be shorter because they only need to describe what is unique about this change.

Documentation, source code, and verification acting as an interface for an agent — Project documentation is a reusable context interface, not an afterthought.

The third move is to verify after generation instead of trusting confidence during generation. Build output, type checks, tests, and a real UI screenshot are stronger evidence than a fluent explanation. The loop is straightforward: state the task, inspect the diff, run the smallest meaningful check, read the failure, and ask the agent to correct it.

Atomic commits make this speed controllable. Each commit should represent one intention and only the files that served it. That makes experiments safer, reviews clearer, and rollbacks cheap. AI increases write speed; version control is what limits the blast radius.

A delivery loop of task, change, verification, commit, and human intervention — Automation is not absence of control; it is timely human control.

The durable lesson is not a particular CLI or a terminal layout. It is to design AI coding as a production system: tasks and context are inputs, bounded parallelism is the process, runtime evidence is the output, and version control preserves the right to change your mind. Models will improve. This discipline will still decide whether improvement becomes reliable delivery.