The Five Levels of AI SDLC Maturity

Almost every engineering team now uses AI. Far fewer have changed how they build software because of it. The 2025 DORA report found 90% of respondents use AI at work. Its headline finding is that AI “doesn’t fix a team; it amplifies what’s already there” (Google Cloud, September 23, 2025).

So “do you use AI?” is the wrong question. The useful question is what you hand the agent, and what holds the work together when you’re not watching. We use a five-level model for that. Each level is defined by a new artifact, and each one moves leverage from the prompt to the system.

Key Takeaways

• Level 1, chat and terminal: you prompt, the model answers, and all context lives in your head. Fast, but nothing compounds.
• Level 2, skills: reusable instructions packaged as files, like SKILL.md and AGENTS.md. The team’s knowledge starts to accumulate.
• Level 3, workflows and spec-driven development: a repeatable loop with human checkpoints. Spec Kit, OpenSpec, and Kiro live here.
• Level 4, a team of agents: several agents run in parallel in herdr, Claude Squad, or worktrees. You become the bottleneck, so review and isolation must be in place first.
• Level 5, managing agent teams: agents coordinate other agents and you manage the system. Anthropic’s multi-agent research system used about 15x the tokens of chat, so this level needs evals, observability, and a cost model.
• Don’t skip Level 3. Parallelism multiplies whatever process you already have, good or bad.

What are the five levels of AI SDLC maturity?

The five levels are chat, skills, workflows, parallel agents, and managed agent teams. Each level adds one durable artifact on top of the last. The table summarizes what changes.

Level	What you hand the agent	Durable artifact	Your role	Typical failure
1. Chat and terminal	A prompt	None, or a pasted snippet	Author who types	Context lost every session
2. Skills	A prompt plus packaged know-how	SKILL.md, AGENTS.md, CLAUDE.md	Author with a playbook	Skills rot; nobody owns them
3. Workflows and SDD	A spec and a loop	Proposal, spec, tasks, archive	Reviewer at checkpoints	Process theater, markdown overload
4. Team of agents	Several tasks at once	Worktrees, sessions, a task board	Dispatcher and reviewer	Review queue explodes
5. Managing agent teams	A goal	Orchestrator, roles, evals, telemetry	Manager of a system	Token burn, silent drift

Two things are worth noting. The levels are cumulative: Level 4 without Level 3 is just more chats at once. And a team can sit at different levels for different work, which is fine.

Level 1: Using an LLM in chat or the terminal

At Level 1, a developer opens ChatGPT, Claude, or a terminal agent like Claude Code or Codex CLI, and asks for something. Nothing persists between sessions except what the developer remembers to paste in.

This is where most usage lives. In the Stack Overflow 2025 Developer Survey, 84% of respondents use or plan to use AI tools. 51% of professional developers use them daily. Only about 31% use AI agents at work.

Level 1 is useful. It’s also where the “almost right” problem is most painful. 66% of the same respondents name “AI solutions that are almost right, but not quite” as their top frustration. Each session starts cold. The model doesn’t know your conventions, so you correct the same mistakes every day.

Unstructured use also produces confusing productivity data. METR’s 2025 randomized trial found experienced open-source developers took 19% longer with AI tools. They believed they’d been 20% faster. METR’s February 2026 update points toward speedups with newer tools. METR also calls that signal unreliable because of selection effects. Our read: unstructured use makes gains hard to see and hard to repeat.

You’re ready for Level 2 when you notice yourself pasting the same instructions into new sessions.

Level 2: Using skills to package what the team knows

At Level 2, recurring instructions become files the agent loads on its own. The main formats are now open standards.

• Agent Skills. Anthropic introduced Agent Skills on October 16, 2025. “A skill is a directory containing a SKILL.md file,” plus optional scripts and references. It became an open standard in December 2025. Clients now include Claude Code, Codex, GitHub Copilot, Cursor, Gemini CLI, and Kiro.
• AGENTS.md. AGENTS.md is a plain format for repo-level agent guidance. The site says over 60,000 open-source projects use it. CLAUDE.md is Claude Code’s own equivalent.

The key design idea is progressive disclosure. Only a skill’s name and description load at startup. The full instructions load when a task matches, and bundled scripts load only when needed. You can keep dozens of skills without filling the context window.

What changes for the team: knowledge stops living in one senior engineer’s prompts. A deploy checklist, a migration recipe, or a code-review rubric becomes a versioned file. In our experience, the best skills come from recurring review comments. Here’s an illustrative skill of that kind, distilled from a recurring migration comment:

---
name: db-migrations
description: "A five-level model for AI in the software lifecycle, from chat and skills to spec-driven workflows, parallel agents, and agent teams, and what each requires."
---
1. Never edit a migration that has shipped. Add a new one.
2. Every migration needs a down step, or a comment saying why it can't have one.
3. Backfills over 100k rows run as a separate job, not inside the migration.
4. Run `make migrate-check` and paste its output in the PR.

Short, specific, and testable. The description line is what the agent sees at startup, so it says exactly when to load the skill. We described that feedback loop in building agent context from what shipped.

The failure mode is rot. Skills get written in a burst of enthusiasm and never updated. Treat them like code: an owner, a review, and a test task that shows the skill still works.

You’re ready for Level 3 when individual tasks go well but multi-day features still drift from what anyone intended.

Level 3: Workflows and spec-driven development

At Level 3, the unit of work is a loop, not a prompt. The agent follows a defined sequence: agree on intent, plan, implement, verify, and record what changed. Humans review at fixed checkpoints.

Spec-driven development (SDD) is the most visible form of this level:

• GitHub Spec Kit (announced September 2, 2025) runs specify, plan, tasks, then implement. GitHub’s framing: “Specs become the shared source of truth.”
• OpenSpec runs propose, apply, archive. Each change is a small folder, and archive merges it back into the living spec. It’s built for existing codebases.
• Kiro generates requirements, design, and tasks files for each spec inside its IDE.

We think the workflow matters more than the spec format. Our OpenSpec analysis makes the case: spec documents tend to go stale, while spec workflows survive.

SDD has real costs. Birgitta Böckeler’s review of Kiro, Spec Kit, and Tessl (October 15, 2025) is the best critique so far. Kiro turned one small bug into four user stories with 16 acceptance criteria. She called it “like using a sledgehammer to crack a nut.” She’d also “rather review code than all these markdown files.” And agents still ignored or over-applied the specs.

The fix is to size the process to the change. Use the full loop for features and risky changes. Let a typo fix skip it. Without that rule, Level 3 turns into process theater, and engineers quietly drop back to Level 1.

You’re ready for Level 4 when your loop reliably produces reviewable, tested changes, and you spend more time waiting for agents than fixing their output.

Level 4: Running a team of agents in herdr or similar

At Level 4, one engineer runs several agents in parallel, each on its own task. The new problem is supervision: knowing which agent is working, which is blocked, and which needs review.

A new category of tools handles this:

• herdr calls itself “the agent runtime.” It’s a terminal multiplexer that knows about coding agents. A persistent server keeps sessions alive through detaches and dropped SSH connections. Each pane shows whether its agent is working, blocked, or idle. Its CLI and socket API let agents split panes, prompt each other, and wait on each other. It’s a single Rust binary that supports over 20 agent CLIs.
• Claude Squad pairs tmux with git worktrees, so each agent works on its own branch.
• Conductor is a Mac app that runs Claude Code, Codex, and Cursor agents in isolated workspaces, then helps you review and merge.
• Plain git worktrees work too, if you’re disciplined about naming and cleanup.

Isolation is the non-negotiable part. Agents that share a working tree overwrite each other. One branch or worktree per agent is the minimum. Our post on building the harness before the long agent run covers the rest of the setup.

The catch is that review doesn’t parallelize. Five agents produce five diffs, and you’re still one reviewer. Without Level 3’s checkpoints and automated verification, Level 4 just moves the queue. We’ve written about reviewing AI-written code by risk because this is where line-by-line review breaks.

Also, not all coding work splits cleanly. Anthropic’s multi-agent research write-up notes that “most coding tasks involve fewer truly parallelizable tasks than research” (Anthropic, June 13, 2025). Parallelize independent tasks, not one tangled feature cut into pieces.

You’re ready for Level 5 when you spend your day routing work between agents, and that routing follows rules you could write down.

Level 5: Managing teams of agents

At Level 5, agents coordinate other agents. A lead agent breaks down a goal, assigns work to specialist agents, and merges results. Your job is to design and manage that system, not to dispatch each task.

Examples are appearing quickly:

• Claude Code agent teams (experimental) run a lead session and teammates. Each teammate has its own context window and mailbox, and the team shares a task list. Teammates talk to each other, not only to the lead.
• Steve Yegge’s Gas Town is a multi-agent orchestrator with named roles. A Mayor coordinates, Polecats do the work, a Refinery runs the merge queue, and a Witness monitors.
• Anthropic’s research system used an Opus 4 lead with Sonnet 4 subagents. It beat a single Opus 4 agent by 90.2% on Anthropic’s internal research eval.

The cost is steep. In the same write-up, agents used about 4x the tokens of chat interactions, and multi-agent systems about 15x.

Claude Code’s documentation is similarly direct. Agent teams “use significantly more tokens than a single session.” It recommends starting with three to five teammates.

That makes Level 5 an economics and reliability problem, not a tooling one. You need three things before you scale it:

1. Evals for the system’s output. You can’t read everything, so you need automated checks that tell you when quality drops. Start with how to design evals for AI agents.
2. Observability across agents. Traces that show which agent did what, with which context, at what cost. When something drifts, you need to replay the trace, not guess.
3. A cost model. Know what a merged change costs in tokens, and which model each role really needs. See right-sizing AI spend.

At this level, engineering management skills matter more than prompting skills. Scoping work, defining done, choosing who does what, and noticing quiet failure are the same skills you use with a human team.

How does this compare to other AI coding maturity models?

Two public models overlap with this one, and both are worth reading.

• Steve Yegge’s eight levels, summarized by The Pragmatic Engineer (February 10, 2026), run from no AI to building your own orchestrator. Our Level 4 roughly matches his levels 6 and 7. Our Level 5 matches his level 8.
• Dan Shapiro’s five levels (January 23, 2026) borrow from self-driving cars. They’re numbered 0 to 5, from “spicy autocomplete” at Level 0 to a “dark software factory” at Level 5.

Both measure how much the human trusts the agent and steps back. Ours measures the artifacts that carry work between sessions: prompt, skill, spec, workspace, orchestrator. We find that more practical for leaders. You can’t mandate trust, but you can decide to write the skill, adopt the spec loop, or set up worktrees.

How to find your level and move up

Most teams are on several levels at once. Look at your last ten merged AI-assisted changes and ask four questions:

1. Did the agent load team conventions from a file, or did someone paste them? Pasted means Level 1.
2. Was there an agreed spec or plan before code, reviewed by a human? If not, you’re below Level 3.
3. Did any agents run in parallel in isolated branches? That’s Level 4 behavior.
4. Can you show the token cost and an eval result for that work? If not, you’re not ready for Level 5.

Then move one level at a time. In our experience, going from Level 1 straight to Level 4 is the most common mistake. It feels productive for a week, then the review queue and merge conflicts eat the gains. DORA’s amplifier finding applies here: parallel agents amplify a weak process too.

Frequently asked questions

What does AI SDLC maturity mean? It describes how deeply AI is built into how a team plans, writes, reviews, and ships software. It’s about structure, not just tool usage. A team where everyone chats with an LLM is still at Level 1.

Is spec-driven development required for Level 3? No. Level 3 needs a repeatable workflow with human checkpoints. SDD tools are one way to get it. A disciplined plan, implement, verify loop in your own skills works too.

What is herdr? herdr is an open-source terminal multiplexer for coding agents, licensed Apache-2.0. It runs many agents across local and SSH machines, shows each agent’s status, and lets agents coordinate through a CLI and socket API.

The bottom line

The five levels are chat, skills, workflows, parallel agents, and managed agent teams. Each adds a durable artifact, and each depends on the one below it. Skills make knowledge reusable. Workflows make quality repeatable. Parallel agents multiply throughput only when those two are in place. Agent teams pay off only with evals, observability, and a cost model.

One thing to do this week: find the instruction your team pastes into AI sessions most often. Turn it into a SKILL.md or an AGENTS.md section, give it an owner, and check it in. That’s Level 2. It’s also the foundation for every level above it.

Running agents in parallel but drowning in review, drift, or token bills? That’s the work we do with engineering teams adopting agents.

Sources

• Google Cloud, Announcing the 2025 DORA report, September 23, 2025.
• Stack Overflow, 2025 Developer Survey: AI, retrieved October 19, 2026.
• METR, Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity, July 10, 2025, and uplift update, February 24, 2026.
• Anthropic, Equipping agents for the real world with Agent Skills, October 16, 2025.
• Anthropic, How we built our multi-agent research system, June 13, 2025.
• Den Delimarsky, Spec-driven development with AI, GitHub Blog, September 2, 2025.
• Birgitta Böckeler, Understanding Spec-Driven-Development: Kiro, spec-kit, and Tessl, martinfowler.com, October 15, 2025.
• herdr, Claude Squad, Conductor, Claude Code agent teams, Gas Town, retrieved October 19, 2026.
• Gergely Orosz, Steve Yegge on AI agents and the future of software engineering, The Pragmatic Engineer, February 10, 2026.
• Dan Shapiro, The Five Levels: from Spicy Autocomplete to the Software Factory, January 23, 2026.