Whitepapers
The Outer Loop Engineering Library
Free PDFs. Leave your email once and every paper here unlocks.
Take the AI Maturity assessmentOuter loop whitepaper
The AI Workforce for Outer Loop Automation
AI made coding faster. The steps after it did not. This paper is what the next stage looks like: why AI at the keyboard plateaus, where company velocity actually comes from, and what it takes to automate everything after the code.
- Why the outer loop is where the effort goes once agents write the code
- The stages of the outer loop, and how each one is automated
- The agents that run it, and how one completes a task end to end
- Separating knowledge from intelligence, so a model swap costs nothing
- Security, governance and the deployment options an enterprise needs
Future of software whitepaper
We Will Write 100× More Software in the Future
The wider bet behind agent-written software: once generating it costs little, the limit stops being engineering capacity and becomes which problems are worth solving at all.
- Why the problems worth solving outnumber the software that has ever been built
- Where the cost falls: creation, iteration, expertise, verification and maintenance
- Software written by domain experts rather than by the software industry
- Disposable applications, continuous experimentation, and grading the work
- Physical AI, and why most of the next 100× never ships as a product
Agent governance whitepaper
Who Checks the Agents?
A delivery process built to catch human mistakes does not catch the ones agents make. This paper is the CTO guide to gating agent-written code: the eight failure modes to design against, and the seven gates that sit between an agent and production.
- Why one model writing the spec, the code, the tests and the review lines up its blind spots
- Eight agent failure modes, and the specific gate that catches each one
- The seven gates P0 to P6, and the two a person should still own
- Locked checks, mutation testing, adversarial review and seeded defects
- Where the effort moves once writing code is the cheap step
Agentic SDLC whitepaper
The Guide to the Agentic SDLC
Coding agents made individual engineers faster, and most organizations still do not feel faster. This guide is how teams move from individual coding agents to one coordinated system of humans and agents across the whole lifecycle.
- Why individual productivity is not team productivity, and where the plateau comes from
- The four levels of AI transformation, and what Level 4 actually asks of a team
- The six stages of the agentic SDLC, and what humans decide at each one
- Agentic loops: PR to merge, ticket to PR, alert to resolution, feedback to features
- The platform stack, security and governance, and how to get started
AI-native levels whitepaper
How AI-Native Is Your Engineering Org?
Every CTO knows AI matters, and few have a clear path to scale it. This paper is the staircase: four levels from individual thought partner to autonomous, system-wide execution, and what it takes to move up each one.
- The four levels, from AI as a thought partner to an AI-native operational system
- The operating profile at each level: interface, context, execution and governance
- Why the Level 2 to Level 3 jump is agency, and where delivery speed plateaus without it
- Six principles for moving up, including why levels build rather than replace
- A three-phase plan to assess, plan and climb
Company Brain whitepaper
Why Product and Engineering Teams Need a Company Brain to Become AI-Native
Agents are only as good as the context they work from. Most teams stall at Level 2 because each tool sees only its own slice, and an agent cannot own a workflow it does not understand. This paper is the shared, permission-aware layer that moves them up.
- The four levels, and why every level above the first depends on shared context
- What a Company Brain is: permission-aware by default, an index you own, models swappable
- How a question becomes a cited answer, and what graph, vector, lexical and temporal signals add
- Case studies: SRE triage, Guided PR Review and its AST code graph, and the Data Analyst
- The Analytics Harness, and why a query can run perfectly and still be wrong
Software verification whitepaper
AI Writes the Code. Verification Is Now 10x More Important.
A green build can still ship the wrong product. When one agent writes the code and the tests, both encode the same reading of the ticket, and CI confirms that reading rather than the requirement. This paper is how verification moves outside the agent loop.
- The blind spot: why one agent writing both code and tests leaves no independent check
- The testing pyramid as an economic bet, and what changes when agents absorb the upkeep
- Code verification against product verification, and why the source of expectations decides
- Three governance rules that keep expected outcomes out of the coding agent’s reach
- The ACC capability model, a case study of 12,000 green tests, and the playbook
Verification engineering whitepaper
Verification Engineering
Writing code got cheap. Knowing it works did not. Where the earlier verification paper argues why an independent check is needed, this one is the system that produces it: the five parts of a verification loop, and the autonomy levels a team climbs to run it.
- Why a green build proves little when one model writes the code, the tests and the review
- The five parts: map journeys, check every change, verify in production, attach evidence, loop to the fix
- Verification engineering against hand-written end-to-end testing, and where unit tests still win
- The four verification autonomy levels, and why the slowest layer sets the pace
- Who owns what: the mechanics agents may change, and the expectations people must approve
Engineering benchmarks whitepaper
Lessons from the Best AI Engineering Teams
Top teams run the same models you do and still ship cheaper, with more autonomy and less rework. Across 103 teams, the gap tracked three things a CTO controls, none of them the model, and all three readable inside a session rather than on the bill.
- Three numbers to watch: cost per merged AI line, lines per human turn, review rounds
- Intent clarity: what a vague ticket costs, and the five parts of one that is not
- Environment readiness, and why a flaky suite proved worse than no suite at all
- Stewardship: the four habits that move work out of review and into the session
- A 90-day sequence, cheapest lever first, and what to report to the CTO
Code review summary
Code Verification When Agents Write All the Code
Anthropic’s Claude Code team more than doubled merged pull requests and cut the share reverted, without giving up review. This summary is how they did it: layers of automated checks, risk-based human approval, and a review loop built to converge.
- The seven layers a change passes through, and the fixer loop that failures return to
- Why two green PRs can still break main, and what the merge queue retests
- Risk tiers for approval, and why an agent approval never counts as a human one
- The trap of agents reviewing agents, and the four rules that made review converge
- Scoring the reviewer against every past incident, and the four things people still own
Knowledge as code whitepaper
Your Knowledge Base Is Now Production Code
Agents read company knowledge far more often than people do, so a page that is months out of date no longer misleads one reader, it misleads every agent that reads it. This paper is the case for running knowledge the way engineering runs code: versioned, reviewed, and kept current by the agents that depend on it.
- The decay cycle: why a page written once is wrong by month six, and why checking it belongs to nobody
- What changes when the reader is an agent, which cannot cross-check a stale page the way a person does
- Why better search finds the page faster without making it true
- Knowledge as plain files you own: history, review, diffs, revert, and contradiction checks
- Agents drafting the upkeep while people own what is true, and five questions to ask your team
Context layer whitepaper
Let Everyone Build. Keep One Brain.
Coding agents let a product manager or an ops lead ship a working app in an afternoon. Building fast is solved; building safely is not. This paper draws the line between what anyone can build and what engineers still own, and what has to sit underneath before a CTO can say yes to everyone building.
- Why forty years of “software without programmers” only arrived with coding agents
- Where to draw the line between what anyone builds and what engineers keep
- What a context layer is, and why retrieval on its own is not knowledge
- Four apps built in under an hour each, and why their value compounds
- The guardrails every hosted app inherits, and four questions to ask before saying yes
