Golden Examples for AI Coding Agents: Curate, Don't Average

Most of the serious complaints about AI coding tools are no longer about the tools. The models are good, the harnesses are good, and if you are reading this you have probably stopped evaluating them and started using one. And yet, in survey after survey, most large organisations report modest gains — a bit faster here, a slightly shorter review cycle there — while a minority report something categorically different.
Speaking at AI Engineer, McKinsey's Martin Harrysson put the split at roughly a quarter of the few hundred large enterprises his team surveyed: not 10 or 20 percent faster coding, but what he described as 2x end-to-end improvements. The question worth answering is what that quarter is doing, because it is demonstrably not buying different tools.
TL;DR — Generation got cheap, so curation became the bottleneck. The teams pulling ahead feed their agents golden examples — a small, deliberately chosen set of artifacts that define what good looks like — instead of letting agents infer the house style from the average of a codebase that contains every compromise ever shipped. Standardised PRDs and specs, curated patterns, and encoded policy are now the asset. MDflow is where that curated set can live as markdown an agent can actually retrieve.
This post is built on the AI Engineer talk "What the Top Companies Do Differently With AI Coding" by Martin Harrysson and Prakhar Dixit of McKinsey (published 8 November 2026), plus published research on AI-assisted delivery. The survey figures are McKinsey's own, described on stage; they are attributed as such throughout.
What golden examples are, and why the average of your codebase is not one
A golden example is an artifact you have deliberately selected to represent what good looks like, and that you hand to an agent as the pattern to follow.
The important word is selected. McKinsey's framing of the policy is blunt: the examples you feed your agents should not be the average of your code base. You want curated golden examples that you can specify as this is what good looks like.
That sounds obvious until you notice that the default behaviour of every coding agent is the opposite. Point an agent at a repository and ask it to add a feature in the house style, and it will infer that style from what it finds. But a repository is a historical record, not a style guide. It contains:
- the module you deprecated but never deleted
- the pattern you abandoned after it burned you
- the three competing approaches to the same problem that a merge left behind
- whatever a tired engineer shipped at 2am before a release
A human reading that code applies a filter you never wrote down — that part is debt, this part is exemplary, ignore that directory entirely. That filter is implicit knowledge, and it is invisible to a model, which sees only tokens and frequency. The most-repeated pattern wins. In most codebases the most-repeated pattern is not the one you would choose if asked.
Few-shot prompting has been the single most reliable way to steer model output since well before agents existed; Anthropic's own guidance is that three to five diverse, relevant examples materially improve accuracy and consistency. What changes in the agentic setting is the stakes and the scale. The examples are no longer decorating a single prompt — they are the standing definition of correct for every task your agents run, every night, across every pod.
Generation got cheap, so the bottleneck moved
Here is the structural reason curation suddenly matters: the expensive step stopped being expensive.
Build and test are the two stages where agent adoption landed first and hardest, and they compressed. What McKinsey reports seeing across clients is that the constraint then moved somewhere else — in three directions at once:
- Upstream, into requirements. If an agent can implement a well-specified change in an hour, the limiting factor is how fast and how precisely you can say what you want. Writing the spec is now the long pole.
- Downstream, into release. Code that is merged and not shipped is inventory. Enterprise release requirements that were tolerable at a two-week cadence become the binding constraint at a two-day one.
- Sideways, into every parallel team. This is the one most teams do not plan for. Risk, compliance, design, accessibility, security — each holds requirements that used to be transmitted by a human walking over and asking. McKinsey's example is a customer-facing banking application with rules about colour schemes and whether a colour-blind user can distinguish two buttons. Traditionally someone goes and sits with that team. At agent speed, nobody has time to, and the requirement simply does not make it into the work.
All three are the same problem wearing different clothes: knowledge that exists somewhere in the organisation but not in a form an agent can read. The sideways bottleneck is just the most vivid, because the knowledge is not even in your department.
This is why "which tool should we buy" is the wrong question now. Tooling, in the panel's assessment, is roughly solved — the tools on the market work. The edge is the semantic layer around them: your IP, your context, your knowledge. For large organisations, much of that still sits in the heads of the people who have been there twenty years. That was already a bottleneck for human onboarding. The difference is that an agent needs it re-supplied on every single task, which turns a tolerable inefficiency into a hard ceiling.
Curation is the scarce resource, not availability
The supply side of context has inverted, and it happened fast enough that most processes have not caught up.
The McKinsey team describe a client who wanted a skill for writing a product requirements document — one task, one artifact. They searched, and found on the order of 1,700 downloadable skills for it. The reported result was not acceleration. It was decision paralysis.
This is what the end of scarcity looks like from the inside. When examples, skills and templates were rare, finding one was the work. Now hundreds of thousands are a search away, nearly all of them written for somebody else's constraints, and the work is deciding which handful are right for your context. Skills are the new SDKs — but a package registry with no curation layer is a liability, not a library.
Curation is a specific and somewhat unglamorous job:
- Choose few. Of 1,700 candidates, a team might genuinely need three. The value is in the 1,697 you rule out, and ruling out requires someone with judgement to actually do it.
- Make it canonical. One authoritative copy. The failure mode is the
CLAUDE.mdthat exists in eleven slightly different versions across eleven laptops, each silently teaching a different definition of correct. - Keep it current. A golden example that encodes last year's pattern is worse than no example, because it is confidently wrong at scale.
- Make it retrievable. A standard an agent cannot fetch is not a standard. It is a document.
Faster generation does not come with free quality
The uncomfortable half of this story is that acceleration and quality have been moving in opposite directions, and not only because volume is up.
McKinsey's read of the data is that defect and incident rates are rising even when normalised — per developer, per pull request. You would expect more incidents from more commits; what they describe is worse than that, a decline in the quality of each unit of output.
The published evidence points the same way. Google's 2025 DORA report found that AI adoption now correlates with higher delivery throughput — a reversal from the previous year — while the negative relationship between AI adoption and delivery stability persisted. DORA's framing is that AI acts as a mirror and an amplifier: it does not create organisational weaknesses, it exposes the ones you had. And METR's randomised trial of experienced open-source developers found they took 19% longer on tasks in repositories they knew well when allowed to use AI tools — while believing they had been roughly 20% faster. Perceived speed and actual speed had come apart.
The implication for curation is direct. If you only coach your engineers on generating faster, you get more output of unexamined quality and a team that cannot tell. The review skill — reading generated work and judging whether it is good — has to be trained with equal emphasis. And the cheapest way to make review tractable is to decide what good looks like before generation, encode it at every checkpoint from PRD to merge, and stop discovering at the end of the pipeline that something failed a gate nobody told the agent about. That is the Swiss cheese model of quality gates applied upstream rather than at the door.
The operating model that curation implies
Curation is not only an artifact problem; it changes how the work is organised. Three shifts McKinsey reports seeing across clients:
- Sprints give way to loops. The two-week sprint does not survive contact with an agentic pipeline. Several clients have moved to Kanban-style one- or two-day cycles, with agents running the night shift and humans validating output and re-running the loop. As confidence in a given loop grows, the human review step is pulled back and the loop runs further on its own. That only works if the artifacts feeding the loop are standardised — which is the curation requirement stated as an operational precondition.
- Teams get smaller and more numerous. Pods of two to four rather than classic scrum teams — not fewer people, but more teams of fewer people. Harrysson describes halving pod size and doubling team count as a near-term cheat code for acceleration, while being clear it is a crude one.
- Roles collapse. Product-type roles converge toward a definer; dev and QA roles converge toward a builder. The industry has not settled the names, but the direction is consistent — and it is worth noticing that "definer" is largely a curation role. Someone has to own what good looks like.
Which applications benefit most
Curated golden examples pay off most where the cost of an agent guessing wrong is high and the right answer is non-obvious from the code alone:
- Large legacy codebases, where the average of the repository is decades of accumulated compromise and the exemplary modules are a small minority.
- Regulated industries — banking, healthcare, insurance — where the "sideways" requirements from risk and compliance are mandatory, numerous, and historically transmitted in meetings.
- Platform and design-system teams, whose entire output is a definition of what good looks like for everyone else.
- Multi-repo organisations, where a pattern must hold across boundaries no single repository's context window spans.
- Fast-growing teams, where new engineers and new agents arrive faster than tacit knowledge can be transmitted by osmosis.
- Accessibility, security and localisation work, where correctness is defined by external standards that are rarely in the codebase at all.
How MDflow fits
Curation needs a home. The requirement is narrow but strict: one canonical copy, readable by humans, retrievable by agents, and versioned so you can see when the definition of good changed.
What lines up today. MDflow stores plain markdown — the format agents read natively and the one your golden examples are probably already written in. Three things make it a curation substrate rather than just storage:
- Folder descriptions are the retrieval signal. Each folder carries a description of the context its documents belong to, and
mdflow_get_contextranks those descriptions above folder names and document titles. A folder described as "approved patterns for our payment services — treat these as the reference implementation" is curation metadata that directly steers what an agent retrieves. The judgement call becomes machine-readable instead of staying in someone's head. - The same set reaches every tool. The MCP server and the HTTP API expose the same documents to Claude Code, Cursor, VS Code, ChatGPT and n8n, authenticated with a personal access token or OAuth. Your curated set is not stranded in one vendor's context format — which matters, because the tools churn faster than the knowledge does.
- Version history and comments make curation reviewable. A golden example is a standard, and standards need an audit trail: who changed what good looks like, when, and whether anyone objected. Workspaces and team sharing give the definer role one canonical copy to maintain rather than eleven drifting ones. Documents can also be published as raw
.mdtwins, so an agent can fetch the canonical text directly.
In practice that means a workspace where PRD and spec templates, the three skills you actually chose, and the reference implementations you want copied all live in described folders — and both your engineers and your agents read the same ones. This is the storage half of spec-driven development; the discipline half is yours.
Where we are headed. The direction — not a dated commitment — is to make the curation signal richer: better team-level context so a pod's standards and an organisation's standards compose cleanly, and retrieval that reflects how authoritative a document is, not only how well it matches a query. The principle underneath stays fixed: markdown you own, portable, with no lock-in on the way out.
The bottom line
The gap between the teams getting 2x and the teams getting 15% is not a tooling gap. Generation is cheap and roughly equally available to everyone; what does not transfer is your definition of correct. The teams pulling ahead have made that definition explicit — curating a small set of golden examples, standardising the artifacts that feed their loops, and encoding the policies that used to live in a conversation with the compliance team.
Your codebase is a record of what you did. Your golden examples are a statement of what you meant. Agents can only read the first one unless you write down the second.
Start free · Connect an AI agent · Read the API docs
Frequently asked questions
What is a golden example for an AI coding agent?
A golden example is a deliberately selected artifact — a module, a test, a pull request, a PRD — that you have decided represents what good looks like in your codebase, and that you feed to an agent as the pattern to follow. It is chosen, not sampled. The distinction that matters is against the alternative: letting the agent infer the house style from whatever the repository happens to contain, which produces the average of your codebase rather than the best of it.
Why is the average of my codebase a bad pattern for an agent?
Because a repository is a historical record, not a style guide. It contains the deprecated module nobody removed, the pattern you abandoned two years ago, and the fix someone shipped under deadline. A human reads that code with context about which parts are exemplary and which are debt. An agent reading the same code sees only frequency, so the most-repeated pattern wins — and in most codebases the most-repeated pattern is not the one you would choose.
Where should golden examples live?
Somewhere both humans and agents can read, with one canonical copy. In practice that means markdown documents in a shared, versioned workspace that exposes a retrieval interface — not a wiki page an agent cannot reach, and not a CLAUDE.md copied onto each engineer's laptop where the copies drift apart. The test is whether you can answer two questions: which version is authoritative, and when did what good looks like last change.
Does AI coding actually make software quality worse?
The evidence says throughput and stability move in opposite directions. Google's 2025 DORA report found that higher AI adoption now correlates with higher delivery throughput, reversing the previous year's finding, while the negative relationship between AI adoption and delivery stability persisted. Faster generation does not degrade quality by itself; it removes the slack that used to absorb review, which is why the review and curation skills matter more as generation gets cheaper.
If tooling is solved, what is the remaining advantage?
Context that only you have. Coding agents are broadly available and converging in capability, so the model and the harness are decreasingly a differentiator. What does not transfer is your domain knowledge, your constraints, your definition of a correct implementation, and the policies your risk, compliance and design teams enforce. Curating that into artifacts an agent can read is work no vendor can do for you.
Further reading
- What the Top Companies Do Differently With AI Coding — Martin Harrysson and Prakhar Dixit, McKinsey, AI Engineer (8 November 2026). The primary source for this post.
- Announcing the 2025 DORA Report — Google Cloud, on AI adoption, throughput and delivery stability.
- Balancing AI's tensions — DORA, on AI as a mirror and amplifier of existing organisational capability.
- Measuring the impact of early-2025 AI on experienced developers — METR's randomised controlled trial, and the gap between perceived and actual speedup.
- Use examples (multishot prompting) — Anthropic, on why curated examples steer output.
- Implicit Knowledge Is Invisible to AI Agents — why the filter you apply unconsciously never reaches the model.
- Spec-Driven Development: Where Your Markdown Specs Should Live — the storage question for the artifacts that feed your loops.
- Quality Gates for AI Agents: The Swiss Cheese Model — encoding what good looks like at every checkpoint.
- Skills Are the New SDKs — why teachability beats lock-in, and why curation follows.
- MDflow for AI · MCP setup · FAQ