Most people starting to use AI for building software use Claude Code the way they used Google ten years ago. Type a question, get an answer. It works, but only to some degree. This approach stops being enough once the project gets large enough to matter.

Between the basic, Google-like functionality and an agent team that ships work while you review decisions, we identified seven distinct levels. Level 7 is where everything comes together, so it will also collapse the moment you jump there without having built the levels underneath it reliably.

This model is built around Claude Code, and every path, command and example below refers to it. That said, it’s applicable to other agents like Copilot or Codex with small adaptations. Treat the levels as seven levers, not a checklist to rush.

The 7 levels at a glance

  1. Direct prompting: you get answers.
  2. CLAUDE.md: Claude gets context.
  3. MCPs: Claude gets eyes and hands.
  4. Skills: Claude gets resuable shortcuts.
  5. Agents: Claude gets focus.
  6. Hooks: Claude gets guardrails.
  7. Agent orchestration: Claude gets a team.

Each level solves a problem the previous one leaves open. That is why every section below points out a limitation. This limitation is the reason the next level exists.

Level 1: Direct prompting, where most people stop

Simply put, a prompt goes in, code goes out. You ask questions about your codebase, fix bugs, or write functions, with zero setup. For one-off questions and quick snippets, this is exactly the right tool. You can also use plan mode to improve the output considerably, simply by making Claude consider a bigger picture before it acts.

The limit shows up when you start a new conversation. Every conversation starts from zero. Claude knows nothing about your architecture. It’s blind to your team conventions or what you shipped last week, unless you explicitly paste it in again. You are the memory and the context. You carry all of it, every single time, and the cost of that grows with the size of the codebase and the size of the team.

Level 2: CLAUDE.md gives Claude persistent context

Run /init and Claude writes a project file that it reads at the start of every session. Keep it short and specific.

Example:

# Project Overview

A single-page HTML slide presentation.

No build system, just open index.html in a browser.

## Architecture

Vertical scroll-snap layout. Each <section class="slide">

is exactly one viewport tall. SlidePresentation JS

class handles keyboard/wheel nav + IntersectionObserver.

## Key Constraint

Every slide must fit in a single viewport (overflow: hidden).

Now, Claude remembers. You write it once and stop re-explaining yourself. Everyone on the team inherits the same starting point. The file is worth treating like code: review it and keep it current but resist the temptation to dump the whole architecture into it. Everything in this file is read into the context at the start of a conversation and takes up space. This can be mitigated a bit by splitting up the CLAUDE.md file into sub-topic specific files and only referencing them in CLAUDE.md. That way, they’re only loaded into the context window when they’re actually relevant.

The limit: Claude still can’t check, for example, whether your user interface (UI) renders correctly in the browser, and it can’t read the failure logs from your CI/CD pipeline. It only knows your project and nothing around it.

Level 3: MCPs give Claude eyes and hands

Model Context Protocol (MCP) connects Claude to systems outside your file tree. Without MCPs, the reach is Claude and your files. With MCPs, it can be Figma, Postgres, Chrome control, your internal APIs, and much more.

You aren’t just giving it more intelligence but connecting it to your world. Claude reads the database schema instead of guessing it. It opens the page instead of describing what it should look like. Finally, it calls the API instead of asking you to paste a sample response.

Then comes another limitation: you notice what you keep doing with all that reach. You type the same workflow repeatedly. Run the tests, lint the code, stage the files, commit with a message. Every time.

Level 4: Skills turn your best prompts into reusable shortcuts

A skill is a prompt you write once and never write again. Put it in .claude/skills/ and it becomes available as /write-tests.

Example:

# .claude/skills/write-tests/SKILL.md

Look at the file provided.

Write full test coverage using Vitest.

Follow patterns in __tests__/examples/.

Cover happy path, edge cases, error states.

> /write-tests src/payments/processor.ts

The slash command is the smaller half of this. The part that changes your day is that Claude reads the skill description and loads it on its own when a task matches, without anyone invoking it. Your conventions stop being something you enforce in review and become the place the agent starts from.

The limit: sometimes a task goes off the rails. You ask for a code review, and Claude starts writing tests instead.

Level 5: Agents give Claude focus

CLAUDE.md supplies context. Agents supply behavior. You define a role and Claude works inside it.

Example:

# Adversarial Reviewer

Try to break this PR. Find edge cases, race

conditions, and security holes. No praise, only problems.

 

# Technical Architect

Evaluate design for scalability and maintainability.

Flag coupling, missing abstractions, future bottlenecks.

 

# QA Engineer

Write tests: happy path, edge cases, failure modes.

If a test passes too easily, it's not testing enough.

Better instructions beat more autonomy. A focused agent outperforms a generalized one because most disappointing output comes from a scope that was never narrowed. Not every agent needs the strongest model either. Use a faster and cheaper one for simple jobs and save the expensive one for work that needs it. Three or four well-defined roles will carry most teams further than a long list of vaguely different ones.

The limit: your ship it skill seems okay locally, but then linting fails on CI/CD. Sometimes, Claude ignores an instruction outright.

Level 6: Hooks are the governance layer for autonomy

Claude Code exposes around 30 hook events. Four of them are where you start in practice: PreToolUse before a tool runs, PostToolUse after it completes, Stop when a task finishes, and Notification when Claude needs your attention.

Example:

# Block production config edits

PreToolUse: file == ".env.production" → deny

 

# Auto-lint after every file write

PostToolUse: on file_write → npm run lint

You’re no longer relying on Claude to do the right thing every time. Instead, you’re ensuring that doing the wrong thing becomes impossible. That is a different relationship with trust, and it’s the precondition for handing over more. Things you would normally check by hand after the fact belongs here because a rule that runs automatically is worth more than a rule you documented.

The limit: hooks govern one session. They do not remember what the last one learned.

Level 7: Agent orchestration, and the promise it only keeps sometimes

You describe what you need. A business analyst gathers requirements. A technical architect writes the plan. A builder implements it. A reviewer checks the output. A fixer resolves the issues. You aren’t the single player anymore; you’re conducting an orchestra.

This is the level that blows people’s minds, and it’s also the one that fails most visibly. A conductor who never played an instrument doesn’t know what’s possible. Point an orchestration setup at a repository with no CLAUDE.md, no MCP access, no skills and no hooks, and it will produce output quickly while leaving you no way to judge whether any of it is good. That is chaos with a faster clock speed.

The limit is the one from Level 1, scaled up. Every session still starts from zero.

Citadel: making levels 2 to 6 survive the session

Building level 7 by hand is real work, and the work evaporates when you close the laptop. Citadel is described as an operating system layer for Claude Code. It’s an infrastructure that lets AI agents work on large codebases autonomously and reliably.

It targets the limitation you first met at Level 1: context gets lost between sessions and the same mistakes get repeated. Splitting tasks between agents by hand doesn’t scale either. As a result, the coordination overhead lands back on you.

Citadel doesn’t replace the levels below it. It takes what you built through levels 2 to 6 and makes it persist across sessions. Pointed at a repository without context, skills or hooks, it has nothing to carry.

A Citadel consists of five interlocking systems:

  • Intelligent routing. A four-tier classification routes your intent through /do to the cheapest appropriate tool, saving time and tokens.
  • Campaign persistence. Multi-day project state survives closing the laptop. Resume with /do continue.
  • Fleet mode. Multiple agents run in isolated Git worktrees, sharing discoveries and merging results automatically.
  • Domain skills. Formalized protocols load into agent context. Invoke /review and the security rules apply automatically.
  • Safety and cost control. Mandatory lifecycle hooks prevent dangerous actions. Token counts and API costs are tracked for every step, so there are no billing surprises.

That’s an infrastructure layer that manages the agents rather than a smarter way to prompt them. Which is also the honest boundary of what a framework can do for you: it can carry your context between sessions, but it can’t invent context you never wrote down.

Every level shifts your own role

  • L1: you are the coder; Claude assists.
  • L2: you are the teacher; Claude learns your world.
  • L3: you are the integrator; Claude reaches your ecosystem.
  • L4: you are the toolmaker; Claude reuses your workflows.
  • L5: you are the reviewer; Claude does the work.
  • L6: you are the governor; Claude operates within your rules.
  • L7: you are the conductor; Claude runs the team.

Read down that list and you can see where you, in your current work setup, would start to feel uneasy. At every step, the hardest part is your own readiness to let go.

Five things worth knowing on the way up

Watch the context window.

Going past 50 percent invites context poisoning. When it gets crowded, start fresh.

Plan cleanup rounds.

Claude generates fast, but that comes with a risk of introducing entropy. Schedule refactoring and documentation passes before the codebase drifts somewhere only an agent can navigate.

Enable local verification.

Let Claude run linting, tests, and builds itself. Every round trip through a human costs time that is better spent on finding things that cannot be caught by simple automated checks.

Keep yourself sharp.

Review critically, not just approvingly. Claude will tell you a solution is correct even when it isn’t. Current AI agents have a strong tendency to be convincingly wrong.

Use Claude as a sparring partner.

Bring your own ideas, challenge its suggestions, and don’t hand over the thinking along with the typing. The best results come out of a dialogue, and the worst come out of pure delegation.

The shift worth making

Stop asking what Claude can write for you. Start asking what you can safely stop doing yourself.

The second question carries its own prerequisite. Safely means:

  • the context is written down.
  • the test exist.
  • the workflows are reusable.
  • the guardrails hold.

Build those and level 7 stops being a demo you watched someone give. Start at the level you are on now and go up one by one.