← THE COURSEDAY 02 OF 07

DAY 02 · Curate

Curate — The Context Your AI Agents Consume

Two engineers, same model, same task. One ships by lunch; the other spends the day re-explaining the codebase. The difference is rarely talent — it's context discipline, and you can standardise it across the whole org.

Two engineers, same model, one ships

The first opens the tool and starts prompting. The AI doesn't know your naming conventions, your service-layer rules, which database schema owns what, or the three patterns your team has agreed never to use. So it guesses. The engineer corrects it. It guesses again. By end of day there's a pull request that compiles, violates two architectural rules, and will get sent back in review.

The second engineer opens the same tool. The AI already knows the conventions, the patterns, the schema ownership, the "never do this" list — because it's all in a file the AI loads automatically at the start of every session. The first prompt lands close to correct. The engineer refines, not re-explains. Ships by lunch.

Same model. Same task. Same licence fee. The gap between them is not talent. It is context discipline — and that is a property of the organisation, not the individual.

Context is engineered, not hoped for

Anthropic calls it context engineering: "curating and maintaining the optimal set of tokens during LLM inference." Curate is the org-wide version of that discipline — you treat the context your AI consumes as a first-class engineering asset, versioned and reviewed like code, not something each developer reassembles from memory every session.

AI-readable standards. The AGENTS.md file has become the universal, cross-vendor way to tell an AI agent how your codebase works — adopted across 60,000+ open-source repos and supported by Claude Code, Cursor, Copilot, Codex, Gemini and more. CLAUDE.md adds Anthropic-specific power. These are instructions written for the agent, checked into the repo, reviewed in the PR.

Layered context with nearest-wins precedence. Org-level rules, then repo, then service, then feature — the most specific file wins. A five-engineer team runs this at low resolution; a five-thousand-engineer org runs the same shape at high resolution. The structure doesn't change with size. The resolution does.

Indexing. Automated, semantic indexing of the codebase — dependency graphs, cross-service awareness — so the AI can find the right code instead of starting cold on every prompt.

The counter-intuitive part: context quality beats context volume. Stanford's "lost-in-the-middle" research shows model correctness drops off once you push past long contexts — dumping your whole wiki into the prompt makes the output worse, not better. Curate is about feeding the right tokens, not the most.

The five sub-practices of Curate

C1
Index Codebase Intelligence
Automated, semantic indexing so the AI navigates your code instead of re-reading it raw every session.
C2
Maintain AI-Readable Standards
AGENTS.md and CLAUDE.md as the substrate; layered, nearest-wins docs; ADRs in a form the agent can parse.
C3
Govern Context Quality
Ownership, review cycles, and an error-to-improvement loop — when the AI gets it wrong, the context gets fixed.
C4
Optimize Context Windows
Select, order, and scope what the AI sees; mitigate lost-in-the-middle; keep it portable across tools.
C5
Onboard & Integrate Tooling
Encode tribal knowledge into context files so new developers — and new agents — reach productive AI use in hours, not weeks, and nothing walks out the door when someone leaves.

Ad-Hoc vs Context-Native

The Ad-Hoc Org
Every AI session starts cold — the AI figures out the codebase from raw code
Knowledge lives in your best engineers' heads and personal prompt files
A 10x gap between best and worst AI user — a personality, not a practice
When an engineer leaves, their context walks out with them
New hires spend weeks re-explaining before AI is useful
A recurring AI mistake gets corrected again in every PR, forever
The Context-Native Org
The AI loads standards, patterns, and schema automatically
Knowledge lives in versioned, PR-reviewed AGENTS.md / CLAUDE.md files
Consistent output — the good team's edge is standardised
Zero loss — it's in the repo
Hours to productive AI use — context files orient them
Corrected once, written back into context, gone at the source

The uncomfortable truth

The gap between your best and worst AI users is not a hiring problem. It is a context problem, and you already own it.

The evidence is measurable. Time-to-10th-PR for new hires dropped from 91 days without AI to 49 days with daily AI use — a 46% reduction (DX 2025) — but that number belongs to orgs with the context discipline to make AI useful from day one. Without it, roughly 72% of organisations need a month or more just to get developers productively onboarded to AI (industry surveys). And Stanford's lost-in-the-middle finding means the naive fix — feed the AI everything — actively degrades output.

So the org that "adopted AI" but never curated context is paying full price for the tools and collecting a fraction of the value — while believing the shortfall is about which engineers it hired.

The Curate maturity ladder

The ladder runs: The Ad-Hoc Org → The Individual Champions → The Emerging Framework → The Structured Org → The AI-Native Org.

The Ad-Hoc Org starts every prompt cold. The Individual Champions has a few developers who've cracked it privately — and loses that knowledge the moment they leave. The Emerging Framework has some AGENTS.md files but no governance, so adoption is uneven. The Structured Org has standards documented and followed across teams, with output that's finally consistent. The AI-Native Org treats Curate as a first-class capability — measured, maintained, and retained when people move on.

The jump that matters is from "a few people figured it out" to "the org figured it out." That is what turns a 10x team from a personality into a practice.

If you answered A or B to any of those, you are somewhere in the first two rungs of the Curate maturity ladder — The Ad-Hoc Org or The Individual Champions. That is the honest, expected starting point. Most orgs taking the diagnostic today land exactly there.

Curate closes the gap by moving context out of your best engineers' heads and into versioned, reviewed files the AI loads automatically — turning a 10x team from a personality into a practice the whole org owns.

SELF-ASSESSMENT
01
The Cold-Start Test — When an engineer opens an AI tool on your codebase, what does the AI already know?
  • A - Nothing. Every session starts cold. The AI figures out conventions from raw code.
  • B - It depends on the engineer. A few have personal context files. Most don't.
  • C - It loads our standards, patterns, and architecture automatically — every engineer, every session.
02
The Knowledge-Retention Test — When your strongest AI user leaves, what happens to how they got 10x value?
  • A - It leaves with them. It was in their head and their personal prompt library.
  • B - Some of it is written down, unevenly, in a few repos.
  • C - It's in versioned, reviewed context files. The next person inherits it intact.
03
The Recurring-Mistake Test — When the AI makes the same wrong assumption twice, what happens?
  • A - We correct it again in review. Every time. Forever.
  • B - Someone might add a note somewhere, eventually.
  • C - We fix the context once, and the mistake stops happening at the source.

The Free Scorecard is the Curate practice — 25 questions covering C1 through C5, scored against the five archetypes. Five minutes, and you'll know your starting archetype before your next meeting ends. Score your Curate maturity free at craftmethod.co/scorecard/free. — Luis