The practice of proactively supplying a coding agent with durable project context — tooling rules, constraints, doc pointers — so it doesn't have to rediscover basics every session. The second layer of the AI-Native Developer Workflow, sitting above Specification-Driven Development.
A lean, markup-light file such as AGENTS.md is placed in the repo root, listing commands, constraints, and pointers to topic-specific docs. It is deliberately kept trimmed to only the rules every session actually needs, rather than growing into a catch-all reference — bloat defeats the purpose since the agent re-reads it constantly.
AGENTS.md is the cross-tool convention file holding durable project context — commands, constraints, doc pointers — that Codex reads automatically. "context engineering in case of coding agents is about creating this file called agents.md." Keep it markup-light: no headers or bold, since agents don't need visual structure and every token spent on markup is a token not spent on the task. List only the commands and rules every session actually needs, and prune hallucinated or redundant claims the agent adds over time — the file drifts if left unedited.
CLAUDE.md exists because Claude Code doesn't auto-read AGENTS.md the way Codex does. Rather than duplicating context across files, keep a single line in CLAUDE.md pointing Claude at AGENTS.md, so one context file serves every tool.
process.md is a separate, living document describing the team/agent working process itself — task source, roles, commit discipline — distinct from AGENTS.md's project facts. Start it minimal (e.g. "tasks live in GitHub issues, read acceptance criteria before starting, commit regularly") and let it grow as new roles are introduced, such as the personas in Agent Team Personas.
The same context has to be wired differently per tool: Codex auto-reads AGENTS.md, but Claude Code does not, so a one-line CLAUDE.md pointer file is kept purely to make the setup interchangeable between engines — "I want my setup to be tool agnostic." See AI Dev Tool Taxonomy for other engine-specific gaps this same habit works around.
AGENTS.md is deliberately kept free of markdown formatting (headers, bold, etc.) because that formatting consumes tokens without adding value for the agent reading it.
LLM knowledge cutoff is named as a recurring, concrete failure mode in tech-stack recommendations (e.g. suggesting an outdated model or dependency version as current), which motivates a habit of line-by-line verification of any AI-suggested dependency or version before accepting it into a spec.
Prototypes read as "AI slop" when builders hand the model only a thin prompt or mini-spec and then expect the fidelity of a full legacy design/build process. The fix isn't more prompting — it's shifting from Prompt Engineering (having a conversation with the model) to context engineering: deliberately assembling the functional, visual, and data context a model needs before asking it to build, so it isn't left inventing details a real spec, design, or dataset would otherwise supply. See Prototype Fidelity Matched to Decision for why the fidelity bar itself should be set by the decision the prototype needs to support.
A live demo builds the case incrementally, with each added context type fixing a specific gap the previous one left:
Claim: giving the model real underlying data, rather than a spec, let it correctly infer UX decisions (features, layout) on its own — data is a more powerful lever than manually specifying interface details.
Full-stack prompt: combine functional, visual, and data context into one markdown-structured prompt, with the data kept in a separate, swappable file. This keeps the underlying prototype structure coherent enough to survive iteration and content swaps, versus letting the model "figure out the details" itself, which risks incoherent structure. Quote: "you're only giving the prototyping tool the context that it absolutely needs rather than polluting the tool with a lot of context that are intermediary steps." See Model Context Protocol (MCP) for how external tools can supply parts of this context automatically.
The classic waterfall sequence — spec, wireframe, data model, build — isn't skipped by context engineering, it's compressed: the same decisions still get made, just in roughly ten minutes instead of two weeks. This reframes the practice as accelerating existing product process rather than replacing it.
A second-order effect: producing prototypes that are never meant to ship — pure exploration — used to be an expensive privilege only the largest, most successful companies could afford (they were 'comfortable doing a lot of wasted work'). Fast context engineering makes that same wasted-work luxury affordable to any team, not just the largest ones — see Unshipped-Prototype Taste Probe.
Linear's agent team (Jacob Shumway, Nan Yu) argues the applied-AI bottleneck isn't model capability but underuse: "The models are really smart, but we're just not using them enough." Their corollary is that heavy, scripted prompting actively hurts results — "If you overprompt these things, you're more likely than not going to make it worse" — so the fix is to minimize explicit instruction and instead equip the model with tools to load its own context: "Give it as little instruction as possible. Give it the tools to load context. Don't give it context." In practice this means telling the agent a goal ("Here's all the context. Just figure out what the right thing is. Write the issue and work on it.") and letting it pull in what it needs turn by turn rather than pre-loading a scripted prompt. See Loop Engineering for the mechanical loop this runs in and dynamic-skills-loading for how Linear scopes which context/tools are available at any moment.