Article9 min readJul 1, 2026

Making Your Codebase AI-Ready

AGENTS.md and CLAUDE.md done right — plus the missing layer every guide skips: the business context that stops coding agents from producing 'almost right' code.

TL;DR

  • 90% of developers now use AI at work — but AI adoption still correlates with worse delivery stability. The difference is context.
  • AGENTS.md / CLAUDE.md files give agents code context: commands, conventions, architecture. Necessary, not sufficient.
  • The layer every guide skips is business context — domain rules and decision rationale — which is why agents produce 'almost right' code.
  • Context files rot like docs do. Treat them as living artifacts tied to your change stream, not one-time setup.

What “AI-Ready” Actually Means

Per the 2025 DORA report, 90% of developers use AI at work and more than 80% say it boosts their productivity — yet the same research finds AI adoption “continues to have a negative relationship with software delivery stability.” Both things are true at once because most codebases give agents speed without understanding. The honest benchmark comes from a METR randomized trial: experienced open-source developers were 19% slower with AI tools on their own mature repos — while predicting a 24% speedup. On unfamiliar ground, AI shines; on codebases dense with unwritten rules, it guesses.

An AI-ready codebase closes that gap: it makes the unwritten rules readable — for agents and, as it happens, for every new engineer who has to understand your codebase from scratch.

The Context File Landscape: AGENTS.md, CLAUDE.md, Cursor Rules

The convention layer has largely standardized. AGENTS.md — now used by more than 60,000 open-source projects — is the tool-agnostic entry point; CLAUDE.md, .cursor/rules, and .github/copilot-instructions.md are the tool-specific equivalents. Keep one source of truth and point the others at it. Practitioner guidance converges on keeping the root file short — every line costs context-window budget on every task.

# AGENTS.md (root — keep it lean)
## Commands
- build: pnpm build   ·  test: pnpm test  ·  lint: pnpm lint
## Conventions
- Server components by default; API access via lib/api/* only
## Where deeper context lives
- Architecture decisions: docs/decisions/
- Domain rules: .nboard/ (business context, per-module)

What goes in these files is where most teams stop short. A study of 2,303 agent context files across 1,925 repositories found 62.3% document build commands and 67.7% cover architecture — all code context. Business context isn’t even a measured category.

Code Context vs Business Context: The Missing Layer

Here’s the causal chain no checklist makes explicit. In the 2025 Stack Overflow survey, 66% of developers named “AI solutions that are almost right, but not quite” as their top frustration, and 46% distrust AI accuracy outright. “Almost right” is the signature of missing business context: the agent wrote idiomatic code that violates a domain rule it had no way to know — the rounding the regulator requires, the retry that must be idempotent because of a 2024 outage, the field that’s owned by another team.

Code context tells the agent how to work in your repo. Business context tells it what must stay true. The second category — decision rationale, domain invariants, ownership — is tribal knowledge unless you write it down, and tribal knowledge blocks agents even harder than it blocks new hires, because agents can’t tap a shoulder to ask.

This is nBoard’s core thesis: business context — decisions, domain rules, the why — belongs in the repo, machine-readable, next to the code it governs, where every developer and every agent reads it.

Context Rot: The Failure Mode Nobody Plans For

The same arXiv study found agent context files “evolve like configuration code” — frequent small patches, no verification loop. A context file that was true in March and wrong in July is worse than none: the agent follows it confidently. Meanwhile GitClear’s analysis of 211 million changed lines shows copy-pasted code rising (8.3% → 12.3% since 2020) while refactoring collapses — AI amplifies whatever patterns your repo already exhibits. Stale context plus pattern amplification compounds.

  • Update context files in the same PR that changes the behavior they describe.
  • Review them like code — they are code, for a very literal reader.
  • Prefer generated/derived context (from PRs, decisions, ownership data) over hand-maintained prose.

The AI-Ready Checklist

  • Root AGENTS.md (or CLAUDE.md) under ~200 lines: commands, conventions, pointers.
  • One-command environment setup with a smoke test — agents need a runnable repo as much as humans do (automate the environment setup).
  • Tests that actually gate: agents iterate against feedback, so fast reliable tests are agent infrastructure.
  • Business context captured per module: domain rules, decision rationale, ownership.
  • A freshness loop: context updated as part of the change, not as a chore after it.

nBoard

Give Your Agents the Why, Not Just the What

nBoard keeps architecture decisions, domain rules, and business context machine-readable in your repo — so Cursor, Claude Code, or any agent ships like a senior engineer. Get early access or book a founder call.

Frequently asked questions

What is an AGENTS.md file and what should it contain?

AGENTS.md is an open convention — used by more than 60,000 open-source projects — for a repo-level file that tells AI coding agents how to work in your codebase: build and test commands, conventions, architecture notes, and boundaries. The highest-leverage content is the context agents can't infer from code: domain rules and decision rationale.

What's the difference between CLAUDE.md, AGENTS.md, and .cursorrules?

Same idea, different consumers. CLAUDE.md is read by Claude Code, .cursor/rules by Cursor, .github/copilot-instructions.md by Copilot, and AGENTS.md is the tool-agnostic standard many agents now read. Teams typically keep one source of truth and reference or symlink it from the tool-specific files.

How long should a CLAUDE.md or AGENTS.md be?

Short — every line spends context-window budget on every task. Practitioner guidance clusters around keeping the root file under ~200 lines: commands, conventions, and pointers to deeper context that agents can load when relevant, rather than encyclopedias they must always carry.

Why does AI-generated code miss my project's conventions?

Because the agent only sees what's in its context. If conventions, domain rules, and the reasons behind past decisions aren't written down in machine-readable form, the model fills gaps with training-data averages — which is exactly why 66% of developers report AI answers that are 'almost right, but not quite.'

Does llms.txt actually do anything?

It's a proposal for websites to offer LLM-friendly content indexes, and adoption by AI providers is limited — it mostly matters for documentation sites, not application repos. For making a codebase agent-ready, repo-level context files like AGENTS.md have far more practical effect today.

More from nBoard