Engineer the frame.
Not the code.

1. Hand over every cookbook

Give a new cook every book you own and ask for soup. The right page is in there, but so is everything else. They get distracted, and the soup suffers. More pages, worse soup.

2. Write one recipe card

The dish. The five ingredients, set out on the counter. What must stay as it is: the other pans on the stove, and no nuts. The cook already knows how to cook. That card is the frame.

Models are lossy readers

A language model's accuracy falls as its input grows. Irrelevant material is not free: it competes with what matters.

Measured on real code

On a real Go repository, some body-only changes were caught only by tests outside the changed package. Locality has to be shown, not assumed.

The context frame

frame: CAT-02 empty state
change (Δ):
  products.json is []
  → show "No products found."
depends on (D):
  #product-list   ul
  #empty-state    p, hidden
  products.json   array of
    {id, name, description,
     url, image|null}
holds (I):
  IDs and classes unchanged
  populated render unchanged
  no inline CSS or JS
oracle:
  []       → message visible
  [1 item] → message hidden
  existing tests still pass
output: scripts/catalogue.js

Left out, on purpose

• The rest of the repository.
• The stylesheet and HTML beyond two hooks.
• Other features and their tests.
• Tickets, history and design debate.
• Instructions on how to write the code.

Each omission removes material the model would otherwise have to read past.

Review moves upstream

Engineers review twenty-line frames instead of hundred-line diffs. The frame is where intent lives.

Code becomes a build output

Version the frames and the accepted releases. Treat generated code like a compiled binary: reproducible in the behaviour the oracle checks, not byte for byte.

Debugging becomes frame repair

A failure points at a missing dependency or invariant: a fact to add, not a line to patch.

Work runs in parallel

Each frame names its own inputs and output. Frames that do not share an output can be generated at the same time.

Models become swappable

A frame and its oracle do not depend on a vendor. Sufficiency is measured per model, so re-check frames after a switch, but the acceptance bar stays the same.

Tickets become frames

Prose requirements give way to Δ, D, I and an oracle. A change that cannot be framed is not ready to build.

Engineers specify, systems generate

Senior time goes into dependencies and invariants, where judgement matters, not into typing the implementation.

Tests come first, from people

Engineers write the oracle before generation. The model never writes the checks that judge it.

The repository changes shape

Frames, interfaces and oracles are the source of truth. Code is regenerated from them, and accepted releases are kept.

Architecture serves the frame

Narrow interfaces and local observability make frames small. Good modular design becomes a direct cost lever.

Fewer tokens per attempt

Input scales with the frame, not the repository. A model that does not explore does not pay to read what it ignores.

Fewer attempts

If irrelevant context degrades a model, removing it should raise the first-pass rate and cut retries.

Less review time

Engineer time is usually the largest cost. Reviewing a twenty-line frame should be faster than reviewing the diff it produces.

Smaller models

A precise frame may let a cheaper model succeed where a larger one was needed to cope with noise. A hypothesis to test.

Cheap regeneration

When a model changes, rerunning accepted frames costs tokens and oracle time, not a rewrite.

Fits well

Bounded changes behind clear interfaces: UI states, data transforms, API handlers, validators, adapters and migrations with fixtures.

Fits poorly

Exploratory work, unclear requirements, cross-cutting refactors, and anything without a checkable oracle, such as visual taste or untested performance.

Existing codebases

Start where tests already exist. Choose the oracle by where a change can be observed, including other packages.