The AI Builder Roadmap

❝

What it is: A 9-level progression framework for AI-assisted development — from prompting ChatGPT to running multi-agent autonomous systems.
Based on: Verified Claude Code documentation, official Anthropic docs, and community-confirmed workflows.
Cost to start: Free (Claude.ai account) → Paid required for Claude Code (Claude Pro at $20/month minimum).
Official docs: https://code.claude.com/docs/en/overview

1. 🔍 Why This Framework Exists

Most people who say they "code with AI" are doing one thing: typing a request into ChatGPT, copying the output, and hoping it works.

That is Level 1. And almost everyone stays there.

The problem is not the tools. The tools keep improving. The problem is nobody shows you what exists beyond Level 3. There are 9 distinct levels of AI-assisted development. Each one unlocks a different category of leverage. The jump from Level 3 to Level 4 alone eliminates 80% of the wasted back-and-forth most developers experience.

This guide breaks every level down: the real tools, the actual techniques, and how to advance.

❝

⚠️ Source note: The "90% of AI builders" stat in the original carousel is not sourced. It's a hook, not a verified figure. Don't repeat it as fact.

2. ⚡ The 9 Levels at a Glance

Level	Title	Core Unlock
1	Hype Coder	Prompts ChatGPT. Copies output. Nothing ships.
2	Outsider	Uses purpose-built coding tools. Still GUI only.
3	Vibe Coder	Runs Claude Code in a terminal. Deploys real apps.
4	"That Guy"	Engineers the AI's context and behavior.
5	Degenerate	Runs parallel instances. Builds subagent pipelines.
6	Irredeemable	Event-driven automation. Hooks. Skills. Background agents.
7	Fallen	Unsupervised overnight runs. Headless mode. Agent teams.
8	Ascended	Self-correcting eval loops. Agents fix their own tests. CI/CD by agents.
9	Light	Agents managing agents. Multi-repo orchestration. Agent-built tooling.

3. 🎯 Assess Your Current Level

Answer honestly:

Level 1: You use ChatGPT or similar to write code. You copy and paste the output into files manually. You do not use version control.

Level 2: You use Cursor, Replit, or Claude.ai directly. You have not run Claude Code in your own terminal yet.

Level 3: You have shipped at least one real project using Claude Code or Windsurf. It has a live URL.

Level 4: You have a CLAUDE.md file in your project and at least one MCP server connected.

Level 5: You have run 3 or more Claude Code instances in parallel on the same repo using git worktrees.

Level 6: You have hooks configured in .claude/settings.json that trigger automatically on events.

Level 7: You have woken up to code Claude Code wrote overnight without supervision.

Level 8: Your agents read their own test failures and attempt to fix them in a loop.

Level 9: You have an orchestrator agent dispatching work to other agents across multiple repos.

4. 🧱 Level-by-Level Breakdown

🟢 Level 1 — Hype Coder

Tools: ChatGPT, Bolt, Lovable, Gemini

What you do: Type "make me an app." Copy the code. Paste it somewhere. Refresh. Maybe it works.

The trap: You think you're building. You're generating text.

What you're missing: A real development environment. Version control. The ability to iterate on a codebase rather than starting fresh every time.

🟡 Level 2 — Outsider

Tools: Replit, Cursor, Claude.ai, Devin, landing page builders

What you do: Use tools that were designed specifically for coding with AI. You have a real editor. You're starting to connect GitHub. You understand what an IDE is.

The upgrade: You have an environment. You don't fully control it yet.

What you're missing: Running the AI directly in your terminal, with full access to your file system, git history, and shell.

🟠 Level 3 — Vibe Coder

Tools: Claude Code, Windsurf, GitHub, Vercel, terminal

What you do: Run Claude Code in an actual terminal inside a real project. Connect to GitHub. Deploy to Vercel. Iterate at speed.

The upgrade: You ship things. Real URLs. Real users.

What you're missing: The AI doesn't know anything specific about your project unless you tell it every session. You're still starting from scratch with context each time.

🔴 Level 4 — "That Guy"

Tools: CLAUDE.md, MCP servers, cursor rules, custom system prompts

What you do: Engineer the AI's behavior instead of fighting its defaults. Write a CLAUDE.md file so Claude understands your project architecture, conventions, and rules before a single prompt. Connect MCP servers to extend what Claude can touch.

The upgrade: You stop prompting. You start programming the AI's behavior.

❝

⚠️ Critical correction: The carousel shows "agents.md" — the actual Claude Code file is CLAUDE.md. Claude Code reads this file automatically at startup from your project root. Getting this wrong means the AI never loads your context.

What CLAUDE.md actually does:

# Example CLAUDE.md

## Project: Customer Dashboard API
## Stack: Node.js, PostgreSQL, Express, TypeScript

## Architecture
- Routes → Controller → Service → Repository pattern
- Never put business logic in routes
- All DB queries live in /src/repositories/

## Code Standards
- TypeScript strict mode always on
- Every endpoint needs input validation via Zod
- Tests required for every new service method

## Do not
- Use any, cast to unknown first
- Commit without running npm run lint
- Create new npm scripts without documenting them here

❝

⚠️ Context budget: Research suggests Claude Code's own system prompt uses roughly 50 instruction slots before your CLAUDE.md is read. Keep your CLAUDE.md focused on rules that actually matter for the current project. Bloated files degrade Claude's attention to your critical rules.

🔴 Level 5 — Degenerate

Tools: Git worktrees, subagents, custom MCP builds, slash commands, multiple Claude Code windows

What you do: Run multiple Claude Code instances on the same repo simultaneously using git worktrees. Delegate subtasks to subagents. Build your own MCP servers. Trigger complex pipelines with slash commands.

The upgrade: Parallel development. One session builds the API while another writes tests while a third handles documentation.

Git worktrees setup for parallel Claude Code:

# Create a new worktree for parallel work
git worktree add ../project-feature feature-branch

# Open Claude Code in the new worktree
cd ../project-feature && claude

# List all active worktrees
git worktree list

# Remove a worktree when finished
git worktree remove ../project-feature

Slash commands setup:

<!-- .claude/commands/review.md -->
---
description: Full code review for a file
arguments:
  - name: file
    description: File to review
---

Review {{file}} for:
1. Security vulnerabilities
2. Missing error handling
3. Test coverage gaps
4. Documentation completeness

Output a structured report with severity levels.

🔴 Level 6 — Irredeemable

Tools: Hooks, skills, background agents, parallel agents, self-improving loops

What you do: Set up event-driven hooks that fire automatically when Claude Code takes action. Build reusable skills that Claude invokes by name. Run background tasks and parallel agents without prompting them yourself.

The upgrade: The system acts without you asking it to.

Hooks setup (verified from official docs):

Claude Code supports 18+ lifecycle events. The most useful:

// .claude/settings.json
{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write ."
          }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "./scripts/check-secrets.sh"
          }
        ]
      }
    ]
  }
}

Skills setup:

# Personal skills (available across all projects)
mkdir -p ~/.claude/skills/code-review

# Project skills (available in this project only)
mkdir -p .claude/skills/api-conventions

<!-- ~/.claude/skills/code-review/SKILL.md -->
---
description: Security-focused code review
---

Review the most recently modified files for:
1. Injection vulnerabilities
2. Authentication gaps
3. Sensitive data exposure
4. Missing input validation

Output findings as a table with: File | Issue | Severity | Fix

❝

⚠️ Skill persistence: Claude Code reads skill files when you invoke them but does not re-read them on later turns in the same session. Write skills as standing instructions, not one-time steps.

⚫ Level 7 — Fallen

Tools: Headless mode (claude -p), overnight cron jobs, agent teams, routines, ultrathink

What you do: Run Claude Code in non-interactive mode on a schedule. Let agent teams divide work across subsystems. Use ultrathink in prompts for extended reasoning on complex problems. Go offline. Let the system make progress.

The upgrade: Your system ships code while you are not at your computer.

Headless mode (verified):

❝

⚠️ The carousel shows "headless Claude Code" — the current implementation uses the -p flag, not a separate --headless flag (that flag was replaced).

# Run a task non-interactively
claude -p "Review the diff in the last commit. Check for security issues and missing tests. Output a structured report."

# Combine with output format
claude -p "your task" --output-format json

# Redirect output to file
claude -p "your task" > output.md 2>&1

Overnight cron job (Mac/Linux):

# Open cron editor
crontab -e

# Run every morning at 7am
0 7 * * 1-5 /bin/bash -c 'cd /path/to/repo && claude -p "Run full test suite. Fix any failing tests on a new branch. Output summary." > ~/claude-reports/morning_$(date +%Y%m%d).md 2>&1'

❝

⚠️ Safety rule: Your first unsupervised run should always be on a feature branch, not main. Review the diff in the morning before merging.

ultrathink (verified):

ultrathink is a keyword you include anywhere in your prompt. It activates extended reasoning mode. You do not need a special flag or command.

ultrathink: Should we move to microservices or stay monolithic for this project? Consider our current traffic patterns, team size, and deployment complexity.

⚫ Level 8 — Ascended

Tools: Eval-driven loops, ultracode, CI/CD run by agents, agents fixing own tests, dynamic workflows

What you do: Build evaluation pipelines where agents measure their own output quality. Agents run the CI/CD pipeline — not just triggering it, but reading failures and attempting fixes. Dynamic workflows that adapt based on test results and eval scores.

The upgrade: The system has a quality feedback loop. It knows when it is wrong and corrects itself.

ultracode (verified):

ultracode is available via the /effort menu in Claude Code. It sends an xhigh effort level and has Claude orchestrate dynamic workflows. It is session-only (not a persisted setting).

/effort
# Select ultracode from the menu

❝

⚠️ ultracode is not the same as ultrathink. Ultrathink extends reasoning depth on a single task. Ultracode changes how Claude orchestrates its overall approach to a complex multi-step problem.

Self-correcting test loop pattern:

# Headless loop: run tests, fix failures, re-run
claude -p "Run npm test. Read every failing test. Fix the implementation (not the test) until all tests pass. Do not change test assertions. Commit when all tests pass."

🔆 Level 9 — Light

Tools: Agent-built tooling, agent loops, multi-repo orchestration, agents managing agents

What you do: Your agents do not just use tools — they build new tools when they need them. One orchestrator agent dispatches work to specialized agents across multiple repositories. The system expands its own capabilities.

The upgrade: You do not manage the system. The system manages itself.

Multi-agent orchestration pattern:

# Orchestrator prompt
claude -p "
You are orchestrating a release across 3 repositories: api-service, frontend, and docs.

1. Spawn a subagent in each repository
2. api-service: run tests, bump version, update changelog
3. frontend: run build, update API client types, run e2e tests
4. docs: pull latest API schema, regenerate reference docs
5. Report status from each repo. Do not proceed to the next step until the current step passes.
"

5. ✅ Before You Start

GitHub account with at least one real project
Node.js v18 or higher installed (node --version to check)
Paid Claude account: Claude Pro ($20/month), Max ($100–200/month), Teams, Enterprise, or API Console access
- Free Claude.ai does not include Claude Code access
Basic terminal comfort: cd, ls, git commands
A real project you want to build — not a tutorial project

6. 💻 Installation

Mac / Linux (Recommended — Native Installer)

curl -fsSL https://claude.ai/install.sh | bash

No Node.js required. Auto-updates in the background. This is the method Anthropic recommends.

Windows

irm https://claude.ai/install.ps1 | iex

Run in PowerShell. Alternatively, use WSL2 for the Mac/Linux command above.

npm (Version Pinning)

npm install -g @anthropic-ai/claude-code

Requires Node.js 18+. Do NOT use sudo — fix npm permissions instead if you get EACCES errors.

Verify Installation

claude --version
claude doctor

claude doctor diagnoses PATH issues, auth problems, and outdated installs.

First Run

cd your-project-directory
claude

Claude Code will open a browser authentication flow on first run. Log in with your Anthropic account.

7. 📄 The Core File: CLAUDE.md

CLAUDE.md is the most important file you will create. Claude Code reads it automatically at startup.

Location: Project root (.claude/CLAUDE.md or /CLAUDE.md)

What to put in it:

markdown

# Project Overview
[One paragraph describing what this app does and who uses it]

## Tech Stack
[List every meaningful technology]

## Architecture
[Describe the folder structure and where logic lives]

## Code Standards
[Non-negotiable rules: naming, patterns, what to never do]

## Testing Requirements
[When tests are required, how to run them]

## Do Not
[Explicit list of things Claude should never do in this project]

❝

⚠️ Keep it under 150 meaningful rules. Anything you put in that doesn't apply to the current task degrades Claude's attention to the rules that do. Specificity beats length.

8. 📟 Key Commands Reference

Command	What It Does
claude	Start interactive Claude Code session
claude -p "task"	Run headless (non-interactive) task
claude --version	Check installed version
claude doctor	Diagnose installation issues
/help	Show all slash commands in session
/clear	Clear conversation context
/compact	Compact conversation to save context
/context	Show current context usage
/cost	Show token usage and cost breakdown
/effort	Change reasoning effort (includes ultracode)
/rewind	Revert to a previous checkpoint
/exit	Exit Claude Code
ultrathink	Keyword in prompt to activate deep reasoning
ultracode	Accessible via `/effort` menu for dynamic orchestration
git worktree add ../name branch	Create parallel working directory
git worktree list	Show all active worktrees
git worktree remove ../name	Remove a worktree when done

9. 📅 Daily Workflow by Level

Level 3 Daily Workflow

1. Navigate to project directory
2. Run: claude
3. Describe the feature you want in plain language
4. Review the changes Claude proposes
5. Accept or reject each change
6. Commit and push
7. Vercel (or similar) auto-deploys

Level 4 Daily Workflow

1. Make sure CLAUDE.md is up to date before starting
2. Run: claude
3. Claude reads CLAUDE.md automatically — no re-explaining your project
4. Run tasks using project-specific language from your CLAUDE.md
5. If output drifts from your conventions, update CLAUDE.md, not your prompt

Level 5 Daily Workflow

1. git worktree add ../feature-work feature-branch
2. Open Terminal 1: cd project && claude (main work)
3. Open Terminal 2: cd ../feature-work && claude (parallel feature)
4. Run tests in Terminal 3 while both agents work
5. Merge when both complete and tests pass

Level 7 Daily Workflow

Before bed:
1. Commit all current work
2. Write the task file for overnight run
3. Schedule: cron job or run claude -p directly

Morning:
1. Check git log — what did it commit?
2. Run the test suite — did anything break?
3. Review the diff before merging to main
4. Queue the next overnight run

10. 💡 Tips for Leveling Up

Level 1 → 2: Stop using ChatGPT for code. Install Cursor today. The environment matters as much as the model.

Level 2 → 3: Install Claude Code. Run it in your terminal on a real project. Type claude and give it a task. The CLI is where leverage begins.

Level 3 → 4: Your first CLAUDE.md should take 20 minutes to write. Every minute you spend on it saves 30 minutes of bad output. Do it before your next session.

Level 4 → 5: Learn one worktree command: git worktree add ../worktree-name branch-name. That is the unlock for parallelism.

Level 5 → 6: Add your first PostToolUse hook. Start with auto-formatting on file save. It runs without you thinking about it. Then build from there.

Level 6 → 7: Your first overnight run should be on a branch, not main. Give it a small, bounded task with a clear success condition. Review the diff in the morning.

Level 7 → 8: Build one eval before trying Level 8 work. Pick a task your agents repeat. Score the output on 3 criteria. Feed failures back in. That loop is Level 8.

Level 8 → 9: Your agent needs to be able to write and run new tools. Give it a task that requires a capability it doesn't have. Watch what it does. That gap is your Level 9 entry point.

11. ⚡ Quick Reference

# Install (native, recommended)
curl -fsSL https://claude.ai/install.sh | bash

# Install (npm)
npm install -g @anthropic-ai/claude-code

# Verify
claude --version && claude doctor

# Start interactive session
cd your-project && claude

# Headless task
claude -p "your task here"

# Headless with JSON output
claude -p "your task" --output-format json

# Headless overnight (save to file)
claude -p "run tests, fix failures on new branch, commit" > ~/reports/$(date +%Y%m%d).md 2>&1

# Deep reasoning (keyword in prompt)
# Just include "ultrathink" anywhere in your prompt text

# Parallel development setup
git worktree add ../worktree-feature feature-branch
cd ../worktree-feature && claude
git worktree list
git worktree remove ../worktree-feature

# Check context usage (inside session)
/context

# Change reasoning effort (inside session)
/effort

# Revert to checkpoint (inside session)
/rewind

# CLAUDE.md location
# Project root: /your-project/CLAUDE.md
# Nested projects: Claude also reads parent directories up to repo root

By The AI Leverage - Learn and master AI daily