How to Use This Guide

You have three AI coding tools to learn, hundreds of pages of documentation to navigate, and a sprint deadline next Thursday. You do not have time to read everything front-to-back. You need to find the techniques that will help you right now, and build deeper expertise as you go.

This article is your navigation map. It tells you exactly where to start, what to read next, and what to skip (for now) based on your specific situation.

What You Will Walk Away With

• A personalized reading order based on your role, experience, and tool choice
• Time estimates for each learning path so you can plan accordingly
• A reference map of the guide’s structure so you can find what you need later
• Clear guidance on which sections matter most for your daily workflow

Quick Assessment: Where Should You Start?

Answer these three questions to find your path:

Which tool are you using?

Already chose a tool? Jump directly to its section:

• Cursor users: Cursor IDE Quick Start
• Claude Code users: Claude Code Quick Start
• Codex users: Codex Quick Start

Not sure which tool? Read the Tool Comparison section first, or try the Quick Wins article which shows all three tools in action.

Using multiple tools? Start with one, get comfortable, then expand. Read the Shared Workflows section which covers techniques that work across all three tools.

What is your experience level?

New to AI coding tools: Start with the Quick Start for your chosen tool, then read Quick Wins. Expect 2-3 hours to become productive.

Used Copilot or basic autocomplete: You already understand AI-assisted coding conceptually. Jump past the introduction and into the Quick Start and Lessons sections. Expect 1-2 hours to transition your skills.

Experienced with one tool, learning another: Read just the Quick Start for the new tool, then focus on the comparison articles to understand what is different. Expect 1 hour to get oriented.

Power user looking for advanced techniques: Skip everything below and go directly to Advanced Techniques or the Cookbook.

What is your role?

Individual contributor: Focus on Quick Start, Lessons, and Productivity Patterns for your tool. These give you the highest day-to-day impact.

Tech lead or architect: Start with the Introduction section for the strategic overview, then read Shared Workflows for team-level patterns and Enterprise Development for scaling AI across a team.

DevOps or platform engineer: Prioritize Claude Code’s CI/CD integration, Codex’s automations and cloud execution, and the MCP ecosystem articles for infrastructure integrations.

Freelancer or consultant: Read Quick Wins for immediate client impact, then the Cookbook for framework-specific recipes across different tech stacks.

Recommended Learning Paths

Path 1: The Sprint Starter (3-4 Hours)

For developers who need to be productive by end of day.

1. Read Quick Wins for techniques you can use in the next 30 minutes (30 min)
2. Complete the Quick Start for your chosen tool: Cursor, Claude Code, or Codex (2 hours)
3. Pick a real task from your backlog and tackle it using the PRD-to-implementation workflow (1-2 hours)
4. Bookmark the Command Reference and Keyboard Shortcuts for daily reference

Copy-paste prompt for your first real task

After completing the Quick Start, use this prompt on a real task from your backlog:

I need to implement [describe the feature/fix from your backlog]. Before writing any code, analyze the existing codebase to understand: 1) How similar features are currently implemented, 2) What patterns and conventions this project follows, 3) Which files will need to change. Then propose your implementation plan and wait for my approval before making changes.

Path 2: The Comprehensive Learner (1 Week)

For developers who want to build deep competence with one or more tools.

Day 1-2: Foundations

• Read the full Introduction section (this page plus the three companion articles)
• Complete the Quick Start for your primary tool
• Apply Quick Wins techniques to a real project
• Set up your context file (CLAUDE.md, .cursorrules, or AGENTS.md)

Day 3-4: Core Workflows

• Work through 5-7 Lessons for your chosen tool
• Practice on your actual codebase, not toy examples
• Read 2-3 Shared Workflow articles relevant to your daily work (debugging, testing, refactoring)

Day 5-6: Advanced and Extended

• Explore Advanced Techniques for your tool
• Set up 2-3 MCP integrations relevant to your stack
• Install useful skills from the skills ecosystem
• Read Cookbook recipes for your primary framework

Day 7: Optimization

• Review Productivity Patterns for workflow optimization
• Create custom rules or slash commands for your recurring tasks
• Read Cost Optimization to manage your spending
• If using multiple tools, start the Quick Start for your second tool

Path 3: The Team Champion (2 Weeks)

For tech leads rolling out AI tools across their team.

Week 1: Personal mastery

• Complete the Sprint Starter path on Day 1
• Spend Days 2-5 working through Lessons and building real features
• By end of week, you should have shipped 2-3 features using AI tools

Week 2: Team enablement

• Read Enterprise Development for team-wide patterns
• Create a team-specific context file that encodes your project’s conventions
• Set up shared MCP configurations and custom commands
• Run a pilot with 2-3 early adopters on the team
• Measure before/after metrics (task completion time, PR size, test coverage)
• Prepare a short internal demo showing real wins from your project

Copy-paste prompt for creating team context

Use this to bootstrap a team-level context file:

Analyze this codebase and generate a comprehensive CLAUDE.md (or .cursorrules or AGENTS.md) that any developer on the team can use. Include: 1) Project overview and architecture, 2) All build/test/deploy commands, 3) Coding conventions with specific examples from the codebase, 4) Common gotchas and things to be careful about, 5) File organization patterns, 6) Testing expectations and patterns. This file will be committed to the repo and used by every developer's AI assistant.

Guide Structure: What Lives Where

Here is a map of the entire guide so you can find what you need:

Introduction (You are here)

The strategic overview. Why these tools matter, how they work, and how to navigate this guide.

Tool-Specific Sections

Cursor IDE

• Quick Start: Installation, setup, first feature
• Lessons: 20+ real-world scenarios (new features, debugging, refactoring, testing)
• Advanced Techniques: Agent modes deep dive, custom rules, MCP servers, checkpoints, background agents
• Productivity Patterns: Workflow optimization, prompt engineering, efficiency hacks
• Tips and Tricks: Configuration tweaks, large codebase handling, team collaboration

Claude Code

• Quick Start: Installation, authentication, first project, PRD workflow, MCP setup
• Lessons: 20+ real-world scenarios (codebase analysis, API development, database work, deployment)
• Advanced Techniques: CI/CD integration, hooks, custom sub-agents, memory system, cost control
• Productivity Patterns: Terminal mastery, multi-file workflows, prompt engineering, batch operations
• Tips and Tricks: CLAUDE.md optimization, performance tuning, troubleshooting

Codex

• Quick Start: App setup, CLI installation, IDE extension, Cloud configuration
• Lessons: Real-world scenarios optimized for Codex’s multi-surface approach
• Advanced Techniques: Worktree workflows, automations, cloud execution, GitHub/Slack/Linear integrations
• Productivity Patterns: Parallel task execution, skills creation, delegation strategies

Shared Sections

• Shared Workflows: Techniques that work across all three tools (debugging, testing, refactoring, deployment, MCP ecosystem, enterprise development)
• Cookbook: Framework-specific and language-specific recipes (React, Next.js, Node.js, Python, PHP, Elixir, databases, DevOps)
• Comparison: Feature matrix, cost analysis, migration guides between tools
• Appendices: Command reference, keyboard shortcuts, migration checklists

How to Read Individual Articles

Every workflow article in this guide follows a consistent structure:

1. Problem Hook — A real scenario you will recognize from your own work
2. What You Will Walk Away With — Concrete outcomes, not abstract goals
3. The Workflow — Step-by-step instructions with real prompts and tool interactions
4. Copy-Paste Prompts — Ready-to-use prompts highlighted in tip blocks
5. When This Breaks — Failure modes and recovery strategies
6. What is Next — Links to related articles

You do not need to read articles in order. Each one is self-contained. Jump to whatever is most relevant to your current task and follow the “What is Next” links to explore related topics.

Note

Articles that cover shared workflows use Tabs to show how Cursor, Claude Code, and Codex each handle the same task. If you are focused on a single tool, you can read just that tab. If you are exploring, reading all three tabs gives you a sense of each tool’s strengths.

Building Your Personal Playbook

As you work through the guide, you will discover prompts and workflows that are particularly effective for your projects. Capture these in your context file:

Cursor

Add effective prompts to .cursorrules in your project root:

## Proven Prompts for This Project

### Feature Implementation
When implementing new API endpoints, always:
- Follow the pattern in src/routes/users.ts
- Include input validation with Zod
- Write integration tests in tests/api/

### Debugging
When debugging, start by checking:
- Recent changes in git log
- Error patterns in the logging service
- Related test failures

Claude Code

Update CLAUDE.md with project-specific guidance:

## Effective Workflows for This Project

### Feature Branch Workflow
1. Create feature branch from main
2. Implement with tests
3. Run full test suite before committing
4. Use conventional commit messages

### Database Changes
Always create a migration file, never modify the schema directly.
Run migrations with: npm run db:migrate

Codex

Configure AGENTS.md in your project root:

## Project Conventions

### Code Style
- TypeScript strict mode
- Functional components with hooks
- Barrel exports from index.ts files

### Testing
- Jest for unit tests
- Playwright for e2e
- Minimum 80% coverage for new code

When This Breaks

Common mistakes when using this guide:

• Trying to learn everything at once. Pick one tool, get productive, then expand. Do not bounce between all three sections simultaneously.
• Reading without doing. Every article includes prompts you should try on your real project. Reading alone will not build the muscle memory.
• Skipping the context file setup. The single highest-impact thing you can do is set up a good CLAUDE.md / .cursorrules / AGENTS.md. Without it, every other technique works worse.
• Ignoring the “When This Breaks” sections. These are where the real expertise lives. Anyone can follow the happy path. Knowing what to do when things go wrong is what separates productive users from frustrated ones.

Copy-paste prompt for when you are stuck

If you hit a wall with any technique in this guide, use this meta-prompt:

I'm trying to [describe the technique from the guide] but I'm getting [describe what's going wrong]. My project uses [tech stack]. Here's what I've tried so far: [paste the prompt you used]. Help me debug why this isn't working and suggest a modified approach.

What is Next

You have the map. Now it is time to start capturing value. The Quick Wins article gives you techniques that work in the next 30 minutes, no matter which tool you chose.

Quick Wins Immediate productivity gains you can capture in your first 24 hours

Cursor Quick Start Get productive with Cursor IDE in 2 hours

Claude Code Quick Start Master Claude Code from installation to first feature

Codex Quick Start Set up all four Codex surfaces and start building