Why AI debugs better than it generates

The verification gap, in one sentence

Generation has no error message. There is no signal the model can read that says “the function you just wrote is wrong.” At best it has the user’s prompt, its own training, and an opinion about whether the output looks plausible. Plausible is not a target. So generation is fundamentally a forward search against a fuzzy criterion, and the model has to imagine its way into a working state from zero.

Debugging is the opposite shape. There is a working state minus one observable failure: a thrown exception, a failed assertion, a missing element in the rendered DOM, a console.error in the previous run’s log buffer. The criterion is concrete. The search space collapses from “all possible programs that match this prompt” to “the smallest edit that makes this one error stop happening.” That is a different problem and the model is much better at it.

This is why the same model can ship a buggy first draft and then fix the bug confidently on the next turn. It is also why the gap widens with the model’s size. Bigger models do not just generate better; they make better use of an error message when one is available. So the production lever is not always “use a bigger model.” It is “put more error messages in front of the model you already have.”

How mk0r encodes the asymmetry, in five rules

Every session in mk0r runs Claude Code inside an E2B sandbox. The agent gets a project-level CLAUDE.md at /root/.claude/CLAUDE.md, compiled from src/core/vm-claude-md.ts. Lines 278 to 283 of that file inject five sentences directly into the agent’s instructions, under a heading called ## Browser Testing. Here they are, lifted verbatim:

The fifth sentence is the one that changes behavior. Without it, the agent’s exit condition is “I edited a file.” Edited is not done. With it, the exit condition becomes “the browser shows the expected result.” That promotes the verification step from optional to load-bearing. The first four rules tell the agent how to perform the verification. The fifth tells it that skipping the verification means the turn is not over.

Five sentences, fewer than 60 words. They turn one-shot generation into a closed loop because they tell the model where to find the target it does not have at the start of the turn.

The error channels the agent reads

The five rules only work if there is something for browser_console_messages to return. Two pieces of source make sure there is.

At src/core/vm-scripts.ts line 254 the VM declares a rolling logBuffer capped by LOG_BUF_MAX. Line 268 then reassigns console.error to a function that pushes every error string into the buffer before forwarding to the original handler. So every error the previewed app prints, from any source, is still in the buffer when the agent looks at it on the next turn.

At lines 1577 to 1580 in the same file, the iframe bridge listens for Vite’s vite:error event and posts a hmr:error message up to the parent page via window.parent.postMessage. That gives the parent UI an immediate signal about HMR failures, separately from anything the user sees on screen.

Both channels exist before the agent ever runs a verification step. They are not built when needed; they are sitting there waiting. The five rules in CLAUDE.md just tell the agent the channels are there and which one to read when.

The blank-page rule, on its own line, on purpose

One of the five rules looks like a footnote and is doing the most work: If the page is blank, verify the component is imported in App.tsx. It exists because blank is the silent failure mode and Vite does not throw for it. The most common shape of a broken vibe-coded app is: the agent created a new component file in src/components/, wrote the JSX, exported it, and forgot to add the import to App.tsx. The bundler is happy. The console is quiet. The page is an empty div.

Without the rule, the agent reads an empty snapshot, looks at the console (clean), and burns a turn searching for a runtime error that does not exist. With the rule, “empty snapshot plus clean console” collapses immediately to “edit App.tsx imports.” HMR fires, the snapshot returns content, the turn ends.

The rule is short on purpose. Models follow short, declarative, imperative-mood instructions placed near the role description more reliably than they follow paragraph-level guidance later in the prompt. So the rule is one sentence, in active voice, with one trigger and one action.

The counter-case: when the asymmetry breaks

The asymmetry only holds when debugging has a target. There is one important class of failure where it does not: code that runs cleanly and does the wrong thing. A sort that returns the wrong order. A form that submits to the wrong endpoint. A calculation that is off by one. None of those throw. The snapshot looks reasonable. The console is quiet. The agent reports completion correctly under the five rules and the bug ships.

That is a real limit and worth being honest about. The snapshot rule catches a chunk of it (a button labelled “Continue” instead of “Submit” shows up in the snapshot text), but a logic bug below the visual surface does not. The remediation in our experience is two-layered. Layer one: the rules above keep the agent honest about what it can already verify cheaply. Layer two: the per-turn commit graph (every prompt is its own commit, sliced on fork at src/core/e2b.ts line 1676) makes a logic bug that ships in turn N undoable in turn N+1 with byte-exact precision. Verification handles the loud failures. Undo handles the quiet ones.

The framing “AI debugs better than it generates” is not a claim that AI debugs perfectly. It is a claim about which side of the loop has a target. Where there is a target, the loop works. Where there is not, the tool needs a different affordance, like a clean undo, to handle the residual.

The minimum-viable version for any agent harness

You do not need a sandboxed VM and a browser bridge to capture the asymmetry. The shape transfers. Three pieces, in order.

1. Capture stderr. Redirect the runtime error stream into a buffer the agent can read between turns. Any agent framework supports this. Without it, the model has no target on turn two either, and the asymmetry collapses.
2. Block exit on edit-only. Treat “I wrote the diff” as not-done. Require the agent to run something (the build, the test suite, an endpoint request, a smoke check) before reporting completion. The blocking step is what forces the verification step to happen.
3. Write the rule in plain English. Embed the verification step as a literal sentence in the agent’s instructions, in imperative mood, near the top of the prompt. “Do not report completion until the test passes” works better than three paragraphs of guidance three layers deep. This sounds soft and it is the lever that actually changes behavior.

That is the whole asymmetry, productized. Generation gets one shot. Debugging gets a loop. The tool’s job is to put the loop in the right place.