Mateo's Tech Puzzles

Claude Code writes the plan, Gemini writes the code

5 min read
A four-step chain — me describing the task in a sentence or two, Claude writing the plan, Gemini writing the code, Claude reading the diff — over the score after two days: seven tasks, zero correction rounds.

Problem

I pay for two AI subscriptions and I was using them in the worst possible ratio.

Claude Pro I use until the meter runs out — routinely 100% of the weekly allowance, watched the way you watch a fuel gauge on a long drive.

Google AI Pro I barely touch, and I bought it entirely for the AI: I was on Google One Plus with 2 TB, nowhere near filling it, and moved up to 5 TB because I assumed the more expensive plan came with better toys attached. Paid a year upfront. Then I tried them, and Gemini was fine when the prompt was exact and confidently wrong when it was not, filling gaps in an underspecified request with invented specifics. In a repository full of generated data that is the expensive kind of wrong, so after a while with Opus 5 I stopped going back.

Solution

Claude Code stopped doing the small work itself and started subcontracting it.

  1. I describe the task in a sentence or two.
  2. Claude writes a plan — named files and functions, acceptance criteria as commands with expected output, and a list of prohibitions.
  3. That file goes to Gemini through the Antigravity CLI (agy) as the entire prompt. No conversation history.
  4. Gemini edits the working tree and reports.
  5. Claude reads the diff — not the report — re-runs the criteria itself and commits.

The repository is a private one for the house we are building: mostly a 3D model generated by scripts from an orthophoto, a cadastral register and the architect’s drawing. A good test case, because every number in it either comes from a measurement or from nowhere.

Technical details & puzzles

The plan is the product

agy -p "$(cat "$SCRATCH/plan-gemini.md")" --model gemini-3.1-pro-high \
    --dangerously-skip-permissions --output-format json --print-timeout 25m

--dangerously-skip-permissions is not optional: without it, -p mode never gets consent to touch files, so Gemini returns a beautifully written description of the change and an unmodified working tree. Nothing fails — you just get prose. The JSON is for the conversation_id, because -c resumes “the last conversation” and I run my own Antigravity sessions on the same machine.

The plan is the part that matters. Without acceptance criteria it is worthless, because Gemini will report success on the grounds that nothing exploded. So every plan ends with commands and expected results:

## Acceptance criteria (run these and show the output)
- `python3 -m zielen_orto --stats` → 412 trees, 188 shrubs
- `git status --porcelain` → exactly two files changed

Then prohibitions, to keep the blast radius small: no git commit, push or checkout — changes stay in the working tree and Claude commits after review — no full model build, no binaries, nothing outside the file list. And the most valuable line in the file: if something cannot be done as planned, say so and stop. Do not improvise a workaround.

Claude reviews the diff rather than the report and re-runs every criterion itself. Three rounds is the ceiling, after which it reverts what Gemini touched and does the task alone.

What never gets delegated: any number that comes from a measurement, plus new geometry and the export pipeline. Claude does the measuring; Gemini gets finished numbers to type in.

What Claude writes, what Gemini gets, what Claude checks — and the line between what is handed over and what never is.

The one where Gemini was right and Claude was not

Thickening tree cover along a stream: three thresholds, four criteria with exact expected counts. Gemini made the change, ran the criteria — and the counts did not match, because the criterion was wrong. Claude had worked out the expected numbers one way and told Gemini to verify them another, and the second path applies a rule the first one skips. The two could never have agreed.

Gemini reported the discrepancy, printed both numbers and stopped, instead of nudging the thresholds until the output matched the plan. Fifth task in a row with no correction round, and it caught a bug in the plan on the way.

It did not need to be clever for that. It needed a plan precise enough that a mismatch was visible.

Result

Two days, seven delegated tasks, from the journal the skill keeps: zero correction rounds, 63 to 135 seconds each, and everything Claude fixed on top was one comment reworded and one long line wrapped. The old way ran at three to five rounds per task.

The saving is not the one I expected. Not “Claude does not write the code”, but that Claude no longer reverse-engineers intent out of a diff it did not brief — which turns out to be most of the job. No token measurements, and I will not invent any.

What I do not know yet

This is two days old. Seven tasks is one repository, one kind of work, and tasks I picked partly because I thought they would work — and seven for seven is exactly the result you would get from a system that is genuinely good and from one that has not been tested yet. Nothing has broken, and the three-round budget has never been spent, so I do not know whether the give-up path triggers cleanly.

So the next step is handing it something it should struggle with. That post will be the interesting one.

Story

The first arrangement was the obvious one: Gemini worked in its own sessions, Claude reviewed the commits afterwards. That is the review-gemini skill. Three to five rounds per task, me relaying complaints between two chat windows, and Claude finding the real problems anyway.

If Claude reviews the work regardless, it should write the brief. That is the entire change.

So the model I had written off now works task after task without a correction, and not because it got better. It finally gets told what “done” means. I had never written it a specification.