The early pattern for managing AI agents was simple: write one document, put everything in it, hand it to the agent. For a task completed in an afternoon, that works fine. For anything that runs across days or weeks — where understanding shifts as the work reveals its own gaps — a single file quietly becomes a liability.
The graveyard problem
OpenAI’s internal agents team ran an ambitious experiment: build a software project end to end using AI agents, with no human writing code. Over five months, a small team shipped roughly one million lines of code across fifteen hundred pull requests. The agents handled implementation; the humans handled steering.
The breakdown came not from capability but from coordination. Their central guidance file — AGENTS.md — started clean and grew into what the team later described as a graveyard of stale rules. New guidance accumulated on top of old guidance. When the two conflicted, agents had no way to tell which was current. The file had become an archaeological site rather than a working document.
The root cause is architectural. One large file mixes four types of information that change at fundamentally different speeds: rules that stay stable for months, the current state of active decisions, a map of what material exists and where, and a history of what changed and why. Pile them together and they rot together.
Steering is not the same as prompting
There is a useful distinction between prompting and steering. Prompting improves a single answer. Steering manages a project across days or weeks as understanding evolves — and understanding always evolves, because serious projects contain questions that cannot be answered until you see the first attempt.
A VP of sales, asked to specify the system he needed from scratch, could not produce a clear requirements document. Shown a wrong first version, he immediately identified the real rule: a deal becomes risky when legal has had the contract for ten days and no one has a named next step. The building was part of how he found the plan.
This is the articulation problem. People cannot fully specify what they want from a blank page. A rough first version surfaces implicit knowledge that a requirements document cannot. Starting before you can see the whole path is not a sign of poor planning — it is often the only way to plan at all.
An Anthropic study of roughly four hundred thousand Claude Code sessions found that users make around seventy percent of planning decisions and only twenty percent of execution decisions. Agents handle the bulk of execution; humans handle the bulk of judgment. The division of labor is cleaner than it first appears — but only when the agent has current, accurate context to work from.
Four layers, four speeds
The solution that teams are converging on is structural: separate context into layers that match how fast each type of information actually changes.
Stable instructions cover how the project runs — what always requires approval, what the agent may never do unilaterally. These change rarely, and because they change rarely, they belong in their own file rather than buried in a document that gets edited constantly.
Current state holds active decisions and open questions: what is being worked on now, what has shifted since yesterday. This file should be rewritten whenever direction changes, not amended with a note at the bottom.
The material map tells an agent what exists and where to find it. This is the layer teams most commonly skip, and skipping it has a predictable consequence: everything ends up pasted into one sprawling conversation because the agent has no way to navigate the project independently.
History is where changed assumptions go when they are replaced, not deleted. A decision that was wrong last week may explain why something was built a certain way. Deleting it loses that context; keeping it in the active state file creates noise. History is the right home.
OpenAI’s eventual fix for their own graveyard was to replace the encyclopedia with a short table of contents pointing to current plans, latest decisions, and relevant deep material. The information was still there — just organized by how current it was.
What this unlocks
When context is layered this way, projects that previously felt too complex to attempt become tractable. The constraint is no longer whether the whole plan fits in the first prompt. The constraint becomes whether the steering holds up as the work teaches you new things.
That is a more manageable problem — and a more interesting one. The skill worth developing is not writing a perfect initial brief. It is knowing when that brief has aged, and how to update it without losing what came before.
Text summarized and optimized using Anthropic’s models and reviewed by a human.