A Widely-Read Essay on Agentic Coding Gets the Failure Mode Right — Review Is the Missing Step
A respected technical essay documents real failure modes in agentic coding workflows — and the missing step that turns those failures into quiet production debt.
Dan Luu’s essay on agentic coding doesn’t chase hype. It documents the exact failure modes developers hit when they let an AI agent run loose in their codebase — silent regressions, mismatched expectations, and changes that compile but don’t do what the prompt asked for. A developer asks an agent to add a date picker, the agent generates the component, and the calendar opens on a random month because the locale string was swapped. The essay is right about where the friction lives. Most teams aren’t failing because the models are weak. They’re failing because they skip the step that actually catches the drift. Review isn’t a legacy habit. It’s the missing control surface in agentic workflows. When an agent touches your files, you need a concrete checkpoint before that change becomes the new baseline. Here’s how that breaks down in practice, and how to build it into your daily flow.
The agent writes code that compiles but silently breaks a workflow
Why it happens: The prompt asks for a feature addition, the agent generates the files, and the terminal shows zero errors. It’s easy to read that as success and move straight to the next task. The agent optimized for the prompt’s surface requirements, not the edge cases in your actual routing or state management.
The fix: Run the exact user journey you care about before committing. If you asked for a new dashboard filter, open the app, apply the filter, sort the table, and export the data. Don’t just check the component tree or trust a linting pass. A working build that skips a real interaction is invisible until a user hits it — and catching it early saves an afternoon of debugging. In meshcode, you can trigger a cross-model review pass that compares the agent’s output against a second model’s structural analysis before you merge, so you spot the mismatch before it becomes a ticket.
Connect the Claude or Codex you already pay for — the rest runs on workers that cost a fraction.
Download meshcode →The diff grows too large to verify by eye
Why it happens: Agents are encouraged to be thorough, so a single prompt often touches ten files at once. The terminal output lists every edit, but reading a thirty-line diff across multiple modules slows your mental context switch to a crawl. You skim, assume it’s fine, and push.
The fix: Force the agent to scope changes to a single responsibility per pass. Ask for the model layer first, verify it, then ask for the view layer. If you must accept a larger diff, break it into logical hunks and review each one against the original prompt. A focused diff is a reviewable diff. The review-before-merge workflow in meshcode forces that boundary by default — it holds the changes in a staging area, runs a cross-model consistency check, and only applies the merge when both models agree on the scope.
The agent changes a shared utility without updating callers
Why it happens: The agent sees a function signature that needs a new parameter, updates it in one file, and moves on. It doesn’t scan the rest of the codebase for the dozen places that call that function. The build fails downstream, or worse, it succeeds with a fallback default that silently changes behavior.
The fix: Treat shared utilities as public interfaces. When the agent modifies one, explicitly ask it to list every caller and update them in the same pass. If the codebase is large enough that tracking callers manually is painful, run a quick grep or rely on your IDE’s refactoring tool before the agent touches it. The cross-model review step catches this automatically — one model spots the signature change, the other flags the broken call sites, and you get a single unified diff showing exactly what needs to be adjusted before you accept it.
The pattern underneath all of these
The pattern Luu documents points straight at the workflow, not the model. Agents are fast at generating files, but speed without verification turns every prompt into a low-stakes bet. Review is the step that turns generation into delivery. You don’t need a committee or a slow process to do it right. You just need a concrete checkpoint that forces you to see what changed, why it changed, and whether it actually matches what you asked for. That’s it — it’s less about learning new verification skills and more about not skipping the ones you already use when working with any other person.
meshcode is a native desktop app built around exactly this workflow — it creates files, runs terminal commands, and builds real, working software from plain-language descriptions, with your code staying as ordinary files on your own machine. You can start for free with the built-in model before topping up anything, or bring your own Claude or Codex if you already pay for one, and it runs on one of the world's lowest coding token costs — top up prepaid balance from $1, no subscription, nothing auto-renews.
👉 Download meshcode — Mac, Windows.