Skip to content
AI Developer Toolkit

Learning Paths

Learning paths for Cursor, Claude Code, and Codex map onto the autonomy ladder in three stages: a Level 1-2 path over Week 1-2 that ends in a first shipped feature, a Level 3 path over Week 3-4 where agents write and you review the diffs, and a Level 4-5 path from Month 2 onward for specs, stop conditions and unattended runs.

You could learn agentic engineering by trial and error, picking things up as you go. Or you could follow a structured path that takes you from “installed the tool” to “the agent wrote it, I checked whether the tests passed” in a few weeks. These paths are organized by rung on the autonomy ladder and by tool, so you can pick exactly the journey that fits.

Read the AI-native SDLC in week 1: capture intent.md, default to plan mode, give the session a feedback loop, and keep a human on merge. Intermediate work adds hooks and evals. Expert work closes the loop from production.

What Each Learning Path Gives You

Section titled “What Each Learning Path Gives You”
  • A clear week-by-week plan for your chosen tool and the rung you are climbing to
  • Concrete milestones to measure your progress
  • Practical exercises that use real-world patterns, not toy examples
  • A checklist you can track to confirm you have actually learned each skill

Choose Your Path

Section titled “Choose Your Path”

Level 1-2: Assisted and Paired

New to agentic coding. You can code but have never used Cursor, Claude Code, or Codex seriously, and you read every line the agent writes.

Duration: Week 1-2 Goal: Ship your first agent-written feature with confidence

Level 3: You Review the Diffs

You have used one of the tools for basic tasks. Now agents write most of the code — parallel sessions, worktrees, background runs — and your day is reading diffs.

Duration: Week 3-4 Goal: Build a review-first workflow that handles any daily coding task

Level 4-5: Specs and the Factory

You are productive with the tools. Now you write the specification and the stop condition, and the agent runs against tests you designed instead of waiting on you.

Duration: Month 2+ Goal: Lead the move to spec-driven, unattended runs for a team or organization

These are the ladder’s learning paths. Each one ends on a rung of the autonomy ladder, Dan Shapiro’s Level 0-5 scale (January 2026) for how much of a codebase agents write and how much of it a human still reads.

Level 1-2: Assisted and Paired Coding Where the Week 1-2 path lands: the agent writes, you read every line
Level 3: You Review the Diffs Where the Week 3-4 path lands: review bandwidth becomes the ceiling
Level 4: You Write the Specs Where the Month 2+ path starts: a specification, a stop condition, a test run you check
Level 5: You Run the Factory The far end of the Month 2+ path: unattended runs behind verification

Level 1-2 Path: Assisted and Paired Coding (Week 1-2)

Section titled “Level 1-2 Path: Assisted and Paired Coding (Week 1-2)”

The goal is simple: go from zero to shipping a real feature the agent wrote while you read every line. That is Level 2, where Dan Shapiro (January 2026) places about 90% of “AI-native” developers. Every day has a specific focus and a hands-on exercise.

Week 1: Foundation

Section titled “Week 1: Foundation”

Day 1-2: Setup and First Interaction

  • Install Cursor and import your VS Code settings
  • Learn the three modes: Ask (read-only), Agent (autonomous), and Inline Edit (Cmd/Ctrl+K)
  • Practice: Open an existing project and ask “Explain the architecture of this project” in Ask mode

Day 3-4: Context and Navigation

  • Master @ symbols: @file, @folder, @codebase, @web
  • Learn Tab autocomplete: accept with Tab, partial accept with Cmd/Ctrl+Right
  • Practice: Use @codebase to find a function, then use Agent mode to add error handling to it

Day 5-7: First Feature

  • Use the PRD-to-Plan-to-Todo methodology: write a brief spec, ask Agent to plan, then execute
  • Practice: Build a REST API endpoint with input validation, error handling, and a test — entirely through Agent mode

Week 2: Core Workflows

Section titled “Week 2: Core Workflows”

Day 8-9: Testing and Debugging

  • Ask Agent to write tests for existing code. Review what it generates.
  • Debug a failing test by pasting the error into chat

Day 10-11: Git Integration

  • Use Agent to create branches, write commit messages, and resolve merge conflicts
  • Practice: Make a feature branch, implement a change, and create a PR description

Day 12-14: Configuration

  • Create your first .cursor/rules/ file with project-specific guidelines
  • Set up one MCP server (start with Context7 for documentation)
  • Practice: Build a complete small feature using everything you have learned

Level 1-2 Milestone Checklist

Section titled “Level 1-2 Milestone Checklist”
  • ☐ Completed tool installation and initial configuration
  • ☐ Used the AI to explore and understand an existing codebase
  • ☐ Built at least one feature entirely with AI assistance
  • ☐ Written AI-assisted tests
  • ☐ Managed Git operations through the AI
  • ☐ Created project-specific configuration (rules, CLAUDE.md, or AGENTS.md)
  • ☐ Installed and used one MCP server

Level 3 Path: You Review the Diffs (Week 3-4)

Section titled “Level 3 Path: You Review the Diffs (Week 3-4)”

You can use the tool for basic tasks. Now you learn the Level 3 workflows: agents write most of the code, in parallel, and your day becomes reading diffs. Shapiro calls this the rung almost everyone tops out at, because review bandwidth sets the ceiling.

Week 3: Advanced Features

Section titled “Week 3: Advanced Features”

Day 15-16: Deep Agent Mastery

  • Use Max mode for complex multi-file refactors
  • Master checkpoints: revert bad changes, try alternative approaches
  • Practice: Refactor a module from callback-based to async/await across multiple files

Day 17-18: Custom Configuration

  • Create glob-based rules in .cursor/rules/ (auto-attached by file type)
  • Set up subagents for specialized tasks (testing, documentation)
  • Practice: Create a “test writer” subagent and a “documentation” subagent

Day 19-21: MCP and Skills Mastery

  • Install 3-5 MCP servers: Context7, GitHub, Postgres/database, Puppeteer
  • Install 2-3 Agent Skills from Skills.sh
  • Practice: Build a feature that uses database queries via MCP and browser testing via Puppeteer

Week 4: Professional Workflows

Section titled “Week 4: Professional Workflows”

Day 22-23: Code Review and Collaboration

  • Set up BugBot for automated PR reviews
  • Use Background Agent for long-running tasks
  • Practice: Set up a complete code review pipeline

Day 24-25: Cost Optimization

  • Monitor usage with Settings > Subscription > Usage
  • Learn model routing: Fable 5 for the hardest refactors and cross-module architecture, Opus 5 for complex tasks, Composer 2.5 for speed, Sonnet 5 for budget
  • Practice: Complete a full day of work while tracking cost per task

Day 26-28: Capstone

  • Build a full-stack feature using every technique learned
  • Use multiple models for different phases
  • Document your workflow for team adoption

Level 3 Milestone Checklist

Section titled “Level 3 Milestone Checklist”
  • ☐ Used extended reasoning modes effectively
  • ☐ Created custom commands or subagents
  • ☐ Configured hooks or automation pipelines
  • ☐ Installed and used 3+ MCP servers
  • ☐ Installed Agent Skills from Skills.sh
  • ☐ Optimized model selection for cost/performance
  • ☐ Completed a multi-file refactor or feature with full test coverage
  • ☐ Integrated AI into code review workflow

Level 4-5 Path: Specs and the Factory (Month 2+)

Section titled “Level 4-5 Path: Specs and the Factory (Month 2+)”

You are productive. Now you learn the Level 4 move — you write the specification and the stop condition, the agent runs for hours, and you check whether the tests passed — plus the Level 5 patterns for runs nobody watches.

Week 5-6: Enterprise Patterns

Section titled “Week 5-6: Enterprise Patterns”
  • Large codebase management: Strategies for 100K+ line projects. Scoped indexing, targeted @ references, .cursorignore optimization
  • Multi-agent coordination: Run 8 parallel agents. Use subagent composition for complex feature branches
  • Custom MCP development: Build an MCP server for your internal tools
  • Practice: Refactor a legacy module in a large codebase without breaking anything

Week 7-8: Team Leadership

Section titled “Week 7-8: Team Leadership”
  • Team configuration: Standardized .cursor/rules/ templates for your team
  • BugBot and review pipelines: Organization-wide automated code review
  • Training program: Create an onboarding guide for your team
  • ROI measurement: Track productivity metrics and cost per developer
  • Practice: Design and implement a team AI workflow from scratch

Level 4-5 Milestone Checklist

Section titled “Level 4-5 Milestone Checklist”
  • ☐ Managed a 100K+ line project with AI assistance
  • ☐ Built or contributed to a custom MCP server
  • ☐ Integrated AI tools into CI/CD pipelines
  • ☐ Created team-wide configuration standards
  • ☐ Trained 3+ developers on AI-assisted workflows
  • ☐ Measured and achieved positive ROI on AI tooling
  • ☐ Designed an automation strategy for a team or organization

Specialized Paths

Section titled “Specialized Paths”

Frontend Developer Path (2 weeks)

Section titled “Frontend Developer Path (2 weeks)”

Focus: UI/UX development with AI

  1. Component generation from design specs and wireframes
  2. Design system integration and consistency enforcement
  3. Responsive layout implementation across breakpoints
  4. Accessibility compliance (WCAG) with AI-assisted auditing
  5. Performance optimization (Core Web Vitals, bundle size)

Backend Developer Path (2 weeks)

Section titled “Backend Developer Path (2 weeks)”

Focus: Server-side and infrastructure

  1. API design from OpenAPI specs with AI generation
  2. Database schema design and migration planning
  3. Microservices patterns and inter-service communication
  4. Security best practices (auth, input validation, rate limiting)
  5. Performance profiling and optimization

DevOps Engineer Path (2 weeks)

Section titled “DevOps Engineer Path (2 weeks)”

Focus: Infrastructure and automation

  1. Infrastructure as Code with AI assistance (Terraform, Pulumi)
  2. CI/CD pipeline design and optimization
  3. Container orchestration and Kubernetes manifests
  4. Monitoring and alerting setup
  5. Incident response runbooks and automation

Tracking Your Progress

Section titled “Tracking Your Progress”

Self-Assessment

Section titled “Self-Assessment”

Use these questions to place yourself on the ladder:

Level 1-2, assisted and paired — Can you answer “yes” to all of these?

  • I can install and configure the tool
  • I can use the agent to explain code and answer questions
  • I can build a feature with the agent from start to finish
  • I read every line before it lands

Level 3, you review the diffs — Can you answer “yes” to all of these?

  • I run agents in parallel, in worktrees or background sessions
  • I have custom commands, rules, or configuration that save me time daily
  • I use MCP servers for at least one workflow
  • Most of my time with the agent goes on reading diffs, not writing code

Level 4-5, specs and the factory — Can you answer “yes” to all of these?

  • I write a specification and a stop condition instead of prompting turn by turn
  • I have hooks, tests or CI that can prove a run is finished without me reading it
  • I have built or customized MCP servers for my team’s needs
  • I can leave a run unattended because something deterministic checks it

When This Path Stalls

Section titled “When This Path Stalls”

Every level has a few predictable blockers. Here is the fast recovery for each:

  • The tool will not index your repo (Level 1-2 and Level 3). Large or messy repos choke indexing. Add a .cursorignore / .gitignore-style exclude for node_modules/, dist/, and build output, then reindex (Cursor: Settings > Features > Codebase Indexing). For Claude Code and Codex, scope your prompts with @ file references instead of asking about the whole tree.
  • An MCP server will not authenticate (Level 3). The server is almost always missing an env var. Run it standalone first (npx -y @modelcontextprotocol/server-github --help), confirm the token (GITHUB_TOKEN, DATABASE_URL, etc.) is exported, then restart the agent. Claude Code’s claude --debug prints the exact MCP connection failure.
  • Model picker confusion (Level 3). If results suddenly drop in quality, you are probably on a cheaper tier. Confirm the active model (Cursor model picker, Claude Code /model, Codex /model) and bump back to Opus 5 for the hard step — or Fable 5 (/model fable) when the task is a complex refactor or you are building from scratch and budget matters less than quality.
  • Automations or CI runs hang (Level 4-5). Headless runs fail silently without explicit permissions. Pre-approve tools in .claude/settings.json (or use --dangerously-skip-permissions inside a sandbox), and for Codex set the right --ask-for-approval level so the job does not block on a prompt.

For the full catalog of error messages and fixes, see the Troubleshooting Guide.

Where to Go After Finishing Your Path

Section titled “Where to Go After Finishing Your Path”

After completing your path:

  1. Share your experience — Write about what worked and what did not
  2. Contribute back — Create custom commands, MCP servers, or Agent Skills
  3. Stay current — The tools evolve weekly. Check the Updates page
  4. Help others — Mentor developers starting their own learning journey
  5. Experiment — Try the other tools. Many developers high on the ladder use all three
The Autonomy Ladder The six-level map these paths climb, with a checklist for placing your own workflow on it
The Human's Job in Agentic Engineering What stays yours as the agents take over the writing: taste, architecture, the stop condition

Frequently asked questions

How long does each learning path take?

The Level 1-2 path runs Week 1-2 and ends with shipping a first agent-written feature. The Level 3 path runs Week 3-4 and builds the review-first workflow that handles any daily coding task. The Level 4-5 path starts at Month 2+ and moves the work to specifications, stop conditions and unattended runs. The specialized frontend, backend, and DevOps paths take 2 weeks each.

What does the Level 1-2 milestone checklist cover?

Tool installation and initial configuration; using the agent to explore and understand an existing codebase; building at least one feature entirely with agent assistance; writing agent-assisted tests; managing Git operations through the agent; creating project-specific configuration (rules, CLAUDE.md, or AGENTS.md); and installing and using one MCP server.

How do I tell which level of the autonomy ladder I am on?

Level 1-2 means installing and configuring the tool, using the agent to explain code, building a feature end to end, and reading every line before it lands. Level 3 means agents write most of the code in parallel sessions and the day is spent reviewing diffs. Level 4-5 means writing the specification and the stop condition, then checking whether the tests passed rather than reading the diff.

What should I do when a learning path stalls?

Four blockers repeat. Indexing failures: add .cursorignore / .gitignore-style excludes and reindex, or scope prompts with @ file references. MCP authentication failures: a missing env var, so run the server standalone and confirm the token is exported. A sudden quality drop: usually a cheaper model tier, so confirm the active model. Automations or CI runs that hang: headless runs need pre-approved tools and an explicit approval level.

What comes after finishing a learning path?

Share your experience by writing about what worked and what did not, contribute back with custom commands, MCP servers, or Agent Skills, stay current because the tools evolve weekly, mentor developers starting their own learning journey, and experiment with the other tools -- many developers high on the ladder use all three.

Written by

See what's new on the platform.

Privacy Policy Terms of Service Cookie settings