Anthropic Academy: Claude Code in Action
Master Claude Code through Anthropic's official training—structured exercises, real-world patterns, and insider tips straight from the team that built it.
Course Overview
Anthropic Academy's Claude Code in Action is the official training course built by the team behind Claude. It's designed for developers who want to move beyond basic prompting and learn the workflows that Anthropic's own engineers use daily.
The course is structured around hands-on exercises—not lectures. Each module pairs a concept with a practical project, so you're coding from the first minute. Topics progress from basic interactions to advanced agentic patterns, with each lesson building on the previous one.
What makes this course unique is the insider perspective. The exercises are based on real patterns discovered by Anthropic's engineering team while building Claude itself. You're learning how the tool's creators use their own tool.
Getting Started Exercises
The first module covers the fundamentals—installation, project setup, and your first agent-driven changes.
Installation and Authentication
Walk through installing Claude Code CLI, authenticating with your Anthropic API key, and verifying the setup works. The course includes troubleshooting tips for common platform-specific issues on macOS, Linux, and Windows (via WSL).
Your First Agentic Edit
Open an existing project and make your first agent-driven change. The exercise guides you through describing a feature in natural language, watching Claude Code plan the implementation, reviewing the proposed changes, and accepting or rejecting them.
Understanding the Agent Loop
Learn how Claude Code's read-plan-implement-verify loop works under the hood. Understanding this cycle helps you write better prompts and know when to intervene versus letting the agent iterate.
Using /commands and Shortcuts
Master the built-in commands: `/help`, `/compact`, `/clear`, `/review`, and custom slash commands. These dramatically speed up common workflows like reviewing changes, clearing context, and switching between tasks.
Real-World Project Walkthroughs
The middle modules are the heart of the course. Each one tackles a realistic project scenario:
Project 1: API Integration — Build a complete REST API integration from scratch. Start with the API documentation, generate types, create the client library, add error handling, and write tests. This teaches the full cycle of a typical backend task.
Project 2: UI Component Library — Create a design system component from a Figma spec. Covers generating the base component, adding variants, writing Storybook stories, and ensuring accessibility. Demonstrates multi-file coordination.
Project 3: Bug Investigation — Given a bug report and a medium-sized codebase, use Claude Code to investigate, identify the root cause, and fix it. This is where the agent really shines—tracing through call stacks and identifying issues faster than manual debugging.
Project 4: Refactoring — Take a messy, monolithic file and refactor it into clean, modular code. The agent handles file splitting, import updates, and maintaining feature parity while you guide the architectural decisions.
Advanced Agentic Workflows
Multi-Turn Conversations for Complex Features
Learn to break large features into a series of focused prompts. The course teaches a "plan → scaffold → implement → test → polish" workflow that produces higher-quality results than single-shot prompts.
Custom Slash Commands
Create reusable slash commands for your team's common workflows. For example, `/test-coverage` that runs tests and asks Claude to fill coverage gaps, or `/pr-review` that generates a code review summary.
Headless Mode and Automation
Use Claude Code in CI/CD pipelines for automated code generation, test writing, and documentation updates. The course covers setting up non-interactive mode with predefined prompts.
Context Management Strategies
Learn techniques for managing context in long sessions: when to use `/compact`, how to reference specific files, and when to start a fresh session. Effective context management is the biggest differentiator between novice and expert users.
What You'll Learn
By completing the course, you'll have practical experience with:
- Setting up projects for optimal AI interaction (AGENTS.md, directory structure, conventions files)
- Writing effective prompts that produce correct, production-quality code on the first try
- Debugging workflows that leverage the agent's ability to trace through complex codebases
- Multi-file coordination for features that span models, APIs, hooks, and components
- Quality assurance patterns including test generation, coverage analysis, and automated review
- Team workflows for sharing conventions and maintaining consistency across a development team
The course is self-paced and typically takes 4-6 hours to complete. Each module has optional challenge exercises for deeper practice.
