Claude Code in Action Course

Lesson 1 • Installing and Configuring the Environment

Walks through installation prerequisites, authentication, and initial configuration. Ensures every student has a functional, authenticated Claude Code setup.

Lesson 2 • Navigating the Claude Code Interface

Covers the interactive REPL, slash commands, and session lifecycle. Students gain fluency with the interface before writing any real prompts.

Lesson 3 • What Claude Code Is

Defines Claude Code as an agentic CLI tool and explains how it differs from chat-based AI. Establishes the conceptual baseline for all subsequent chapters.

Lesson 1 • Anatomy of a Strong Coding Prompt

Breaks down the components of high-quality prompts: goal, constraints, context, and output format. Provides a reusable template students apply throughout the course.

Lesson 2 • Prompt Patterns for Common Code Tasks

Catalogs proven prompt patterns for generation, explanation, refactoring, and debugging. Students build a personal prompt library for daily use.

Lesson 3 • Iterative Prompt Refinement

Introduces a feedback loop for improving prompts when initial results miss the mark. Students practice diagnosing prompt failures and applying targeted fixes.

Lesson 1 • Validating and Integrating Generated Code

Teaches a review checklist for generated code before merging into a codebase. Students learn to spot hallucinated imports, incorrect logic, and style violations.

Lesson 2 • Scaffolding Project Structures

Demonstrates generating full directory layouts, config files, and entry points for new projects. Students scaffold a complete starter project during practice exercises.

Lesson 3 • Generating Functions from Specifications

Covers translating written requirements into working function code. Students practice writing specs that yield correct, idiomatic implementations.

Lesson 1 • Submitting Bugs for Diagnosis

Covers how to present error messages, stack traces, and failing code for accurate diagnosis. Students learn the minimum reproducible context needed for reliable fixes.

Lesson 2 • Explaining Unfamiliar Code

Demonstrates prompts that produce plain-language explanations of complex or legacy code. Students apply this to real inherited files in practice exercises.

Lesson 3 • Documenting Bugs and Fixes

Shows how to use Claude Code to draft bug reports, changelogs, and fix summaries. Students produce documentation artifacts alongside code changes.

Lesson 1 • Identifying Refactoring Opportunities

Teaches prompts that surface code smells, duplication, and complexity hotspots. Students build a prioritized refactoring backlog from Claude Code's analysis.

Lesson 2 • Applying Targeted Refactoring Patterns

Covers extract-function, rename, simplify-conditional, and other common refactoring patterns. Students apply each pattern with Claude Code assistance and verify outcomes.

Lesson 3 • Enforcing Style and Conventions

Demonstrates using Claude Code to align code with team style guides and linting rules. Students produce consistently formatted output ready for code review.

Lesson 1 • Writing Integration and End-to-End Tests

Extends test generation to multi-component flows and user-facing scenarios. Students learn to describe system behavior so Claude Code produces meaningful integration tests.

Lesson 2 • Maintaining Tests as Code Evolves

Addresses updating tests after refactoring or feature changes using Claude Code. Students establish a workflow that keeps tests synchronized with production code.

Lesson 3 • Generating Unit Tests from Code

Covers prompts that produce unit tests for existing functions, including happy paths and failure cases. Students generate a full test suite for a sample module.

Lesson 1 • Monitoring and Debugging Agentic Runs

Teaches how to inspect logs, detect failures mid-run, and resume or restart agentic tasks. Students practice diagnosing and recovering from common pipeline failures.

Lesson 2 • Understanding Agentic Task Execution

Explains how Claude Code plans and executes multi-step tasks, including tool use and file edits. Students understand the execution model before designing their own pipelines.

Lesson 3 • Designing Safe Agentic Pipelines

Covers permission scoping, confirmation checkpoints, and rollback strategies for autonomous tasks. Students apply safety patterns to prevent unintended file or system changes.

Lesson 1 • Governance, Permissions, and Cost Control

Addresses permission models, usage limits, and cost monitoring for team deployments. Students configure guardrails that balance productivity with budget and security constraints.

Lesson 2 • Managing Shared Memory and Context

Explains memory files, persistent notes, and how to share context across team members. Students set up a shared memory structure for a multi-developer project.

Lesson 3 • Customizing Claude Code with Config Files

Covers CLAUDE.md, settings files, and project-level configuration for consistent behavior. Students create a project config that encodes team conventions and tool preferences.