A conversation is a path

A conversation with an AI is a path. Every prompt is a step, and the steps compound. The agent reads where you have already been to decide where to go next, which means the shape of the path is the work. Get the shape right and the agent stays useful for hours. Get it wrong and it drifts, and you spend more time fighting the drift than building anything.

Most people treat a bad turn as something to route around. I treat it as something to undo.

Retrace, do not pave over

When the path goes somewhere wrong, get back fast, and get back by retracing your steps. Roll the conversation back to before the wrong turn. Do not build a new path forward on top of the mistake.

Here is the reasoning. If I leave the wrong turn in the history and just add a correction after it, the agent still sees the wrong turn as a step we took and accepted. That quietly teaches it the turn was fine. It will take that turn again, because nothing in the path says we do not go there. So I roll back, and I name it: "that was wrong, we do not do that." Naming the mistake and removing it from the path does more than any amount of forward patching. Do this and the bad turns happen less.

Steer, do not start over

Most of the time the right move is to steer, not to start a fresh context. Starting over throws away everything the agent has loaded about the problem, and that context is expensive to rebuild.

I kill a context in four cases. It is actually done. It has gone so far off the rails, with nothing worth saving, that it is unrecoverable. I realize it is never going to resolve the thing I originally asked for. Or the task is finished and I want the context back. Outside of those, I keep steering. A drifting session is almost always recoverable with a rollback and a clear correction, and recovering it is cheaper than a cold start.

When I do move on, I do not cold start the next agent. I have the current one dump everything it knows into a prompt for the next: what we are doing, what we tried, what is left. A clean handoff, ping-pong instead of a blank slate. Agents can also coordinate the way we do, through GitHub issues and PRs. One opens an issue or a PR, another reviews it, and the coordination lives in artifacts that stick around after the context is gone.

Context first, scale second

Scaling is tempting early and wrong early. A fresh session has no shared context, so fanning out just multiplies confusion across several agents at once.

So I ramp up first. I interview the agent to load context. I make some issues, or a loose plan. I start the work. Only once the context is rich do I fan out, and the rich context is what every sub-agent inherits.

The shape of the fan-out depends on the work. Sometimes I run parallel sub-agents on independent slices and converge them at the end. Sometimes a head agent orchestrates helpers and holds the plan. This is a toolkit, not one true way. The path got me the context. The context is what lets me scale.

You still own the code. Owning it means owning the path you took to get there.