Agent Readiness
The Agent Readiness Audit

Find out how ready your codebase is for AI agents.

Coding agents do not fail randomly. They fail in predictable places: files too big to hold in context, names they cannot search for, missing docs that force them to guess, no tests to check their own work. The audit scores one repository across six weighted pillars, then hands you the exact, prioritized list of what to fix first.

Call fee credited toward your first engagement.

I take one audit at a time

What you get

A number, the reasons behind it, and a plan.

Two-week turnaround from the day I get access. This is not a code-quality grade and it is not a security audit. The question is narrow and useful: how well can an AI agent work in this repo right now, and what is the fastest way to make it better.

01

A scored report

One composite score from 0 to 100, anchored to real calibration examples so a 70 means the same thing on every audit. No grading on a curve.

02

Per-pillar findings

Every pillar scored on its own rubric, with specific evidence: the files, the gaps, and exactly why each one slows an agent down.

03

A prioritized roadmap

Every fix ranked by leverage and tagged with pillar, impact, and effort. You get the short list that moves the number, not a transformation deck.

04

A 60-minute walkthrough

We go through the whole report together, live. You leave knowing what to do first, why it matters, and what it will change.

The six pillars

Weighted by what actually moves the needle.

Documentation and Agent-Specific Readiness carry half the score between them, because they are the two things that most determine whether an agent starts a task oriented or lost.

Documentation and Context

25%

README quality, architecture docs, and ADRs. Can an agent learn the project without reading every file? Quality over length: a lean top-level file that points to deeper docs beats one giant file that tries to hold everything.

Agent-Specific Readiness

25%

Whether guidance reaches the agent at all, whether the documented build, test, and lint commands actually work, and whether same-named modules declare an owner. Having a CLAUDE.md earns nothing by itself; our own testing found that file presence changed task outcomes by zero.

Guardrails and CI/CD

15%

Linting configured and enforced, a CI pipeline, pre-commit hooks, code review, and clean secret hygiene. Zero guardrails scores near the floor; layered enforcement scores high.

Testing and Verification

15%

Whether agents have a feedback loop to check their own work. Without tests, a human becomes the only reviewer, which kills the autonomy that makes agents worth using. We look at coverage and whether tests run in CI.

File Size and Complexity

10%

The share of your code that lives in files over 1,000 lines, with generated files and lockfiles excluded before anything is measured. Small is never a defect here. Lower-weighted deliberately: strong docs, tests, and guardrails compensate for inherited size.

Naming and Discoverability

10%

Whether code follows your language's conventions and can be found by natural-language search. Full terms beat abbreviations; descriptive filenames beat cryptic ones. Think code SEO for agents.

What the number means

The score describes cost, not capability.

No band says your agents cannot function, because our measurements did not find one. The eight repositories in our calibration set scored between 11 and 73, and six of the eight landed between 39 and 73. A mid-range score is the common case, not a failing grade: the foundations are there and the gaps are fixable, which is exactly what the roadmap is for.

0-20Severe FrictionEvery task pays a heavy navigation and verification tax. Finding the right place for a change, and confirming it works, falls almost entirely on a human.
21-40High FrictionAgents frequently land the right change in the wrong module and re-derive context every task. Review cycles are about placement, not logic.
41-60Moderate FrictionAgents work, but the guidance they load leaves the expensive questions unanswered, so each task rebuilds context that could have been stated once.
61-75Low FrictionDocumented commands resolve and most work lands in the right module first try. Remaining cost sits in a few ambiguous or under-tested areas.
76-90Minimal FrictionLoaded guidance is grounded in real paths, commands are enforced by gates rather than prose, and known ambiguous modules carry an explicit owner.
91-100Negligible FrictionLittle left to re-derive. Detected same-named modules declare a single owner and verification is self-service.
Sample report

One page from a real audit.

Client details are fictional; the structure and the specificity are exactly what you receive.

Northwind Payments · northwind/core-api · Ruby on Rails · ~1,900 files
49Moderate FrictionA fresh score typically lands 46-52.
Scored by claude-sonnet-5 against rubric fb60f30a59af, 2026-08-23

Agents do real work in this repo. What they do not do is start oriented. The code is well organized and consistently named, so navigation by structure is fine, but twelve pairs of same-named files leave an agent guessing which one owns a behavior, nothing states the build and test commands anywhere an agent reads, and no check runs on a pull request, so a person is the only enforced gate. The gap is not the code. It is that the repo assumes a human is always in the loop to answer questions the repo could answer itself.

PillarWeightScore
Documentation and Context25%61
Agent-Specific Readiness25%23
Guardrails and CI/CD15%44
Testing and Verification15%35
File Size and Complexity10%72
Naming and Discoverability10%88
Composite100%49, Moderate Friction

The full audit scores all six pillars in detail, lists every finding with evidence, and gives you the complete prioritized roadmap with effort tags. The one number we will quote in advance is arithmetic: declaring an owner for the twelve same-named pairs is worth exactly +9 points here, 49 to 58. The rest arrives when the work is done and the repo is re-scored.

Your code stays yours

Source code never leaves your infrastructure.

By architecture, not by policy, the scoring engine works from structure and configuration metadata plus bounded excerpts of named files, never your source code: file paths and counts, directory layout, capped previews of README, guidance, CI, and lint config, commit subjects, and which same-named files exist and whether one imports the other. The methodology document lists the exact inventory. I never delete tracked files, change permissions, or invent tooling. NDA-friendly, and the architecture is the reason rather than a promise.

Pricing

One repository, one price, no upsell.

Single-repository audit
$2,500fixed
  • All six pillars scored, with a composite from 0 to 100
  • Per-pillar findings with specific evidence
  • A prioritized remediation roadmap, tagged by impact and effort
  • A 60-minute live walkthrough of the report
  • Two-week turnaround, source code stays on your infrastructure

It starts with a $300 readiness call, credited in full toward the audit if we go ahead. I take one audit at a time, so slots are genuinely limited: booking the call is how you hold one.

Call fee credited toward your first engagement.

Larger organizations
By conversation

Multi-repo and team-level engagements are scoped one to one. Every organization’s surface area is different, so there is no list price. We talk through what you have, what you are trying to unlock, and what a right-sized engagement looks like.

Not sure yet? Take the 10-minute readiness quiz for a free directional read before you book.

Take the quiz
Book a call

Get a straight read on your repo.

Start with the readiness call: a hype-free conversation about where your codebase stands and whether the audit is worth it for you. If it is, the call fee comes off the price and we get to work.

Call fee credited toward your first engagement.

Tech Thaumaturge Weekly

Not ready to book? One useful letter a week on making codebases agent-ready. Practical, no hype.

Email only, one-click unsubscribe anytime. See our privacy page.