---
title: "Annotate, Don't Regenerate: The Token Cost of Validating a Plan"
description: "Letting an AI agent build a real page just to check the layout is the expensive way to iterate. Validating its plan with annotations first can cost ~2x fewer tokens. Here's the model."
date: 2026-06-08
updated: 2026-06-08
canonical: https://screentack.com/blog/annotate-dont-regenerate-token-cost
---

# Annotate, Don't Regenerate: The Token Cost of Validating a Plan

When you want an AI coding agent to get a layout right, the obvious move is to let it build the thing and look at the result. Build, eyeball, correct, rebuild. It feels productive. It is also the **expensive** way to iterate — because you are regenerating a full artifact every round to settle a disagreement that is really about the *plan.*

There is a cheaper path: have the agent show you its plan, **annotate** what's wrong, and let it generate the real thing only once. Here is the difference, with the math.

## Where the tokens go

Agentic tools re-read and re-send a large context — your files, the conversation, tool output — on **every turn**, and that context is re-billed each turn. So total cost scales with two things: the **number of turns** a task takes, and the **size of what gets generated** on each of those turns. (For the longer version of this, see [why AI coding agents burn tokens on visual bugs](/blog/why-ai-coding-agents-burn-tokens-on-visual-bugs).)

Visual and layout work is brutal on both counts: it takes many turns to converge, and "build it so I can see it" regenerates a full artifact every single turn.

## Two ways to validate a layout

**Generate-to-validate** (the default): the agent writes the real page, you render it, it's not quite right, you describe the fix, it regenerates. Repeat until the layout lands — typically several full builds.

**Annotate-to-validate**: the agent sketches its plan as a few labeled regions on the screen ("nav here, hero full-width, primary CTA, 3-up grid"). You correct the marks directly — which costs the agent nothing — it reads your feedback, and *then* builds the real thing once, correctly.

## The model

Illustrative assumptions, stated plainly: a re-sent context of ~20,000 input tokens per turn; one full section generation at ~1,500 output tokens; a layout that takes ~4 build rounds to get right by eyeballing; a plan sketch at ~250 output tokens and a feedback read at ~500. Your numbers will differ — see the honest note below.

| | Generate-to-validate | Annotate-to-validate |
|---|---|---|
| How you check the plan | Build the real thing, look, correct | Agent sketches it, you correct the marks |
| Full code generations | ~4 | ~1 |
| Agent turns (context re-sent each) | ~7 | ~3 |
| Input tokens (context, re-billed per turn) | ~140k | ~60k |
| Output tokens | ~6k | ~2.3k |
| **Total (illustrative)** | **~146k** | **~62k** |

That is roughly **2.3x fewer tokens** — and roughly half the turns, so it is faster too.

## Why the gap is real

The savings are not a trick of the numbers. In generate-to-validate, the *only* way to see the plan is to build it, so you pay to regenerate a full artifact every round. In annotate-to-validate, you separate the cheap question (is the plan right?) from the expensive action (build it), and you only pay for the expensive part once.

And it **compounds with size.** Model a single section and the artifact is ~1,500 tokens. Model a whole page or a component tree and each regeneration is 5,000-10,000 output tokens — so generate-to-validate's repeated builds blow up while the plan sketch stays tiny. The bigger the thing you're iterating on, the more lopsided the comparison gets.

## An honest note

This is a **model, not a benchmark.** Real context sizes, artifact sizes, and iteration counts vary widely, and a disciplined prompt can cut generate-to-validate's rounds. The point isn't the exact 2.3x — it's the *direction*: validating a lightweight plan before generating a heavy artifact removes your most expensive round-trips, and the advantage grows with artifact size and iteration count.

## How to actually do it

You need a way for the agent to show its plan and for you to correct it visually. That is the [bidirectional visual feedback loop Screentack is built for](/blog/bidirectional-visual-feedback-for-ai-coding-agents): over MCP, the agent draws its plan on your screen, you annotate feedback, and it reads your corrections before it writes code. The agent generates the real artifact once — the time it's actually right.

> Stop paying to rebuild the wrong layout. [Download Screentack](/#waitlist) — a free 7-day trial, then $29 once.