---
framework: Agentic Engineering Maturity — Factory Edition
version: 2026.06.0
released: 2026-06-17
kind: overview
---

# Agentic Engineering Maturity — Factory Edition

**Version `2026.06.0` · June 2026**

A two-part maturity assessment for engineering in the agentic era: one checklist for **you** (Personal) and one for your **team and repositories** (Team/Project). It is built around the shift that happened in 2026 — writing code got cheap, and the scarce work moved to *specifying intent*, *designing the system that writes the code*, and *verifying what comes back*.

This edition is deliberately opinionated. Where older AI-readiness checklists asked "are you using the tools?", this one asks "have you built the factory, and can you trust what it ships?"

---

## What's in the kit

| File | Use it to |
|------|-----------|
| `README.md` | Understand the model, stages, and scoring (this file). |
| `concepts-2026.md` | Get up to speed on the 2026 ideas the checklists assume — a short field glossary with sources. |
| `personal-checklist.md` | Score one engineer's habits and judgment. |
| `team-checklist.md` | Score a team / repository / org's standards and infrastructure. |
| `personal-guide.md` | Companion guide — every personal item explained, with how to check it. |
| `team-guide.md` | Companion guide — every team item explained, with evidence to look for. |

Read `concepts-2026.md` first if the words *harness*, *loop*, *blast radius*, *intent debt*, or *the ratchet* are new. The checklists lean on them.

---

## The core idea: you are building a factory, not typing code

The mental model for 2026 is the **factory**: you are no longer mainly an author of code, you are the designer of the system that produces it — fleets of agents with tasks, tools, context, and feedback loops, with you doing quality control on the output. A factory has inputs that must be specified precisely or the output comes out wrong, it has quality control, and it stalls when the environment is unreliable. Every one of those properties maps onto agentic development.

Three consequences run through the entire assessment:

1. **Your spec is the leverage.** When one ambiguous instruction fans out across many agents, vague thinking multiplies. The quality of what you specify now matters more than the quality of what you type.
2. **Verification, not generation, is the bottleneck.** Agents produce far more than any human can read. Maturity is mostly about building a verification system you can actually trust — not generating more.
3. **The human moves up a level — but never out.** From writing every line, to reviewing every line, to *owning the loop*: sampling, gating the risky paths, and keeping a mental model of what the factory is shipping.

---

## The 9 dimensions

Both checklists share the same nine dimensions, so a person's score and their team's score line up side by side. Each dimension shows up as personal *habits* and as team *infrastructure*.

| # | Dimension | The question it answers |
|---|-----------|--------------------------|
| 1 | **Intent & Specification** | Is the *why* written down before the agent runs — goals, constraints, definition of done? |
| 2 | **Context, Memory & Harness** | Does the agent get the right context, durable memory, and scaffolding to succeed — and not rot as the window fills? |
| 3 | **Loops, Autonomy & Orchestration** | Are you designing systems that prompt agents (and yourself) — or still hand-prompting one turn at a time? |
| 4 | **Verification & Review** | Is review tiered by blast radius, adversarial, evidence-gated, and owned by a human at merge? |
| 5 | **Tests & Deterministic Gates** | Do real tests and immovable CI gates carry the weight that human reading no longer can? |
| 6 | **Safety, Security & Guardrails** | Are dangerous actions blocked by construction — sandboxes, hooks, scoped permissions, injection defenses? |
| 7 | **Comprehension & Judgment** | Do you still understand what ships — or are you quietly surrendering the thinking to the model? |
| 8 | **Reusable Capability & the Ratchet** | Does every mistake become a permanent rule, skill, or hook — so the system compounds instead of repeating? |
| 9 | **Measurement, Cost & Compounding** | Can you measure, trace, and budget the factory — and prove it's getting better, not just faster? |

---

## The maturity ladder: Stages 0–4

Rather than a generic "ad-hoc → disciplined" scale, the stages track the **posture shift** of the agentic era — from typing, to delegating, to orchestrating a system that compounds.

| Stage | Name | What it looks like |
|-------|------|--------------------|
| **0** | **Improvised** | AI used ad hoc and privately. Copy-paste from a chat window, no shared setup, no spec, no repeatable practice. Output trusted because it "looks right." |
| **1** | **Assisted** | Autocomplete and chat are part of the day. Individual speed-ups, but you drive every step and hold everything in your head. Little structure beyond your own habits. |
| **2** | **Delegated** | You scope agent-sized tasks against a written spec, curate context deliberately, and verify each result. Tests ride along with the change. Agents are workers you supervise one at a time. |
| **3** | **Orchestrated** | You design *loops and harnesses*, not one-off prompts. A maker agent writes, a different checker verifies, work runs in isolated worktrees, and merges are evidence-gated. You are *on* the loop, not *in* every turn. |
| **4** | **Autonomous Agents** | Agents run long-running, autonomous loops under guardrails; the factory improves itself. Every failure becomes a rule, skill, or hook (the ratchet). Evals guard prompts and skills like tests guard code. Intent and comprehension debt are actively paid down. Leverage compounds across the org without quality decay. |

Each checklist item is tagged with the stage it belongs to. **You are at Stage N when you consistently satisfy the items at Stage N and below** — "consistently" meaning across your last several pieces of work, not once on a good day.

---

## How to score

1. **Pick the lens.** Use `personal-checklist.md` for an individual; `team-checklist.md` for a team, repo, or org.
2. **Tick honestly.** An item counts only if it's true *consistently* and you can point to evidence (a PR, a config file, a dashboard, a recent example). The companion guide gives a concrete "how to check" for each.
3. **Find your stage per dimension.** Within each of the nine dimensions, your stage is the highest level at which you've met (almost) all items at that level and below. Note dimensions that lag — uneven profiles are normal and the most useful output.
4. **Find your overall stage.** Take the *lowest* stage that holds across the dimensions you consider load-bearing. A team that is Stage 4 on tooling but Stage 1 on verification is a Stage 1 risk — the weakest gate is the one that fails.
5. **Pick the next rung, not the summit.** Choose one or two lagging items one stage above where you are, and make them routine before adding more. Maturity here compounds; it is not collected.

> **A note on blast radius.** Not every team should aim for Stage 4 everywhere. A solo developer on a no-users prototype is rational to run light verification; a team shipping payments is not. Read each item through *what happens when it breaks*. The guides flag where the right answer depends on your blast radius.

---

## How this set is meant to be used

- **As a self-audit** — score yourself or your team, then re-score quarterly and watch the profile move.
- **As a coaching map** — the stage tags turn the checklist into a sequenced path, not a wall of equally-weighted boxes.
- **As a design brief** — the team items double as a punch list for the platform/DevEx work that makes the factory safe to run.

It is intentionally tool-agnostic. Where a concrete artifact helps (`AGENTS.md`, an `.mcp.json`, a worktree, a hook), it's named as an *example*, not a requirement — map it to whatever stack you run.

---

*Built from the 2026 literature on agentic engineering. See `concepts-2026.md` for the ideas and primary sources behind each dimension.*