Back

Essay

If You Read Every Diff, You're Only Running One Agent

September 14, 20266 min read

Short answer: if you know exactly what your AI is coding, you are only running one agent — maybe two. That is not a sign of rigor, it's a ceiling. The people getting the most out of this are running dozens of agents at once, and they are not reading every diff. The rigor doesn't disappear; it moves earlier, into better skills, better docs, and loops that verify the work before you ever look at it.

Here is the claim, and I will defend it: if you know what your AI is coding, you are a bad vibe coder — and therefore a bad coder.

That is not an argument for being careless. It is an argument about throughput, and about what the job actually is now.

Nobody writes code by hand any more

Start with the part that is not controversial for much longer.

Writing code by hand has become close to useless. Not wrong — useless. You are slow, you will not keep up, and you cannot work at the pace the people around you are now working at. The people building the models build with the models: Anthropic use Claude to build Claude, OpenAI use Codex to improve OpenAI. AI is doing the development.

Which means that to be a developer now, you have to be a vibe coder. There is no way around that part. Sit and write it manually and you will be left in the dust — not because typing is immoral, but because the person next to you shipped four things while you were reviewing one.

So why is following along a problem?

Because of what following along costs.

To keep track of what your AI is doing while it codes, you have to stay in the conversation. You have to read it. You have to look at what it produced and hold the shape of it in your head.

You can do that for one agent. Maybe two.

The people getting the most out of this are running dozens at once. There is not a chance in hell they are following what every one of those agents is doing, and they are not trying to. The ability to follow along is not a sign of rigor. It is a symptom of running one agent.

If you are actually reading it all, you are simply not using this to anything like its potential.

Then how do you avoid a weekend of mystery regressions?

This is the real objection, and it deserves a real answer, because "just trust it" is not one.

You do not solve it by reading more. You solve it by being a better vibe coder — and that work happens before the agent starts, not after:

  • Better skills. The reusable capability files the agent loads: what good looks like in this repo, which patterns to use, which to never use.
  • Better docs. The markdown context that tells the agent how this codebase actually works — the conventions, the traps, the things that have already gone wrong once.
  • Better schedules and loops. Automated cycles: build, check, correct. Verification the agent runs against itself, so failures surface without you reading a diff to find them.

Do that and you can vibe code your way out of the vibe coding mystery.

Will you know exactly what was built? No. That is the trade and I am not pretending otherwise.

But the mystery regressions go. The bugs go. The sloppy code goes. What you lose is line-by-line familiarity. What you keep is control — a different kind of control, exercised through the setup rather than the review.

The CTO at Google does not read every line either

The analogy that makes this obvious: the CTO at Google has no idea what every programmer in the building is doing. He is not following every line of code, and he is not tracking every developer.

Nobody thinks he is bad at his job. He steers the ship. He looks at it from a macro perspective and makes changes from there.

That is your job now as a vibe coder. Not reviewer — director. Same shift, one level down.

What it looks like at eleven at night

The end of the stream this came from is the argument performed rather than stated, and it is a better example than anything I could construct.

I pushed a redesign of our landing page, looked at the result, and found a section that looked wrong — a tab strip for picking industry and scenario type that was cramped and badly laid out.

I did not open the file. I said out loud that I was going to be lazy, tried to screenshot it, fumbled that, and dictated it as a backlog item instead: the tab section picking the industry or type of scenario collaboration on the index page looks bad, it should not be one big block.

Then I stopped. In my own words: by the time I wake up tomorrow it is in the backlog for the AI to do, so I do not have to do it now myself.

That is the whole thesis in ninety seconds. The fix costs me one sentence and no context switch, and I will never read the code that makes it.

What to do on Monday

  1. Count your agents. If the answer is one, that is your bottleneck, and it is not a hardware problem.
  2. Take one hour off reviewing and spend it on context. Write the markdown file your repo does not have — the conventions, the three things that always go wrong, the commands that verify a change.
  3. Add one loop. Anything that lets the agent catch its own failure without you: a test command it must run, a lint gate, a build check. One is enough to change how much you have to read.
  4. Then start a second agent on something you would previously have queued, and deliberately do not read the diff. Judge the output, not the process.
  5. File the small stuff instead of fixing it. The next time you spot a cosmetic bug at eleven at night, dictate it into the backlog and go to bed. That is the muscle.

Prove me wrong.

This isn't abstract for us. Every guide and rule this article follows is written down as markdown context precisely so a coding agent can pick up a task cold, ship it, and verify itself against a lint and build gate before anyone reads the diff — the setup carries the weight the review used to.

This is exactly the shift Ordana is built around for the teams and agencies on the platform: structuring the work — and the revenue share around it — so that shipping faster with AI doesn't mean reading more, it means trusting a better setup.

Related reading: