The Altitude method

Agents write more code than you can read. Not a little more — multiples more, every day, across branches you didn't open. The honest version of “I review everything” is a growing queue of merge requests you skim, approve, and quietly stop understanding.

That isn't control. It's a ritual that used to be control, performed at a scale where it no longer does anything.

The other extreme is giving up: describe the goal, let the agent go, trust the tests. It feels great for a week. A month later the codebase is something nobody can explain — not you, and not the next agent, which now reads three generations of leftover structure and invents a fourth.

People cope by interrogating the agent (“what did you change?”), by asking it to keep docs current, or by accepting that they no longer understand their own system. All three are the same admission: the knowledge lives in the agent's transcript, not in anything you can stand on.

There is a level between reading lines and reading nothing: structure. The parts of the system, what each one is for, and how they connect. That level fits in a person's head — it's the whiteboard drawing you'd make to explain your system to a colleague.

Altitude makes that drawing the working surface. You describe the structure as scopes — real units of the codebase — joined by connections. And the granularity is yours: draw one big scope and everything inside it is delegated; split it into five when a part starts to matter. How you draw the board is, literally, how much you see and control. That choice of level is the altitude the name is about.

Every architecture diagram you've ever seen was wrong within a month, because nothing forced it to stay right. A picture that drifts from reality is worse than no picture — it teaches you false confidence.

This board is checked against the code. When a part is built, the files behind it are fingerprinted; when the code later moves, the board shows exactly which parts no longer match, in amber. A change that only exists as a plan is green. Work in progress glows. What you see is a statement of fact, not a statement of intent.

The board isn't a report the agent generates for you, and it isn't a spec you throw over the wall. It's one shared surface with doors for both of you: you work on the board, agents reach the same truth through their own interfaces (MCP and CLI). The agent proposes on it, reports on it, and reads it back to orient itself — the same way you do.

That's the whole design: work is offloaded, understanding and control are not. The agent writes the code. The two of you keep the map.