Claude Code Training

Foundations of Claude Code as an Agentic Coding Tool

• Understanding the spectrum of AI coding tools: from autocomplete to conversational to agentic, and where Claude Code sits
• Learning what "agentic" means, and why it changes how you give instructions and review results
• Seeing how an agentic tool's awareness of your whole project differs from file-level autocomplete
• Installing Claude Code and setting up the local environment
• Navigating to a project directory and launching a session
• Using Claude Code to map and explain an unfamiliar codebase in plain language
• Understanding what Claude Code can and cannot see in your environment
• Reviewing proposed changes: reading a diff, understanding scope, accepting or rejecting
• Configuring permission levels: when it asks, when it acts, and when to intervene
• Adopting the verify-don't-accept mindset that anchors the rest of the course

Precision Prompting and Instruction Design for Claude Code

• Understanding the anatomy of an effective instruction: role, context, task, constraints, and desired format
• Guiding output with positive examples versus negative examples
• Using structure and delimiters to organize complex inputs so the tool stays focused
• Applying chain-of-thought prompting for diagnostic and analytical tasks
• Iterative prompting: treating the first output as a conversation opener, not a final answer
• Scoping instructions for engineering-specific outputs like test plans, specs, and documentation
• Diagnosing why an instruction didn't work and revising it systematically
• Writing instructions that produce specific, usable output on the first attempt

Multi-File Work, Refactoring, and Legacy Code using Claude Code

• Writing instructions scoped clearly enough for multi-file changes
• Understanding how Claude Code uses agentic search to build project context
• Delegating a bug fix across dependent files: instruct, review, accept
• Breaking a small feature into sub-steps that can each be delegated
• Reviewing diffs critically: what to look for and what to question
• Handling Claude Code making a wrong assumption mid-task
• Knowing when to break a large task into smaller, sequenced instructions
• Generating documentation for undocumented functions and modules
• Building a dependency map of a legacy system through natural-language queries
• Incremental refactoring: modernizing without a full rewrite
• Writing characterization tests before touching legacy code
• Identifying technical debt systematically and prioritizing it
• Telling the difference between a good diff and a plausible-looking bad one, and knowing when to approve, redirect, or start over

Claude Code Workflow: Git, Pull Requests, and CLAUDE.md

• Using Claude Code to stage changes and generate meaningful commit messages
• Creating and switching branches through natural language
• Opening a pull request and writing a description that accurately reflects AI-assisted changes
• Reviewing AI-generated commits in a team context and communicating provenance
• Generating changelogs and release notes
• Avoiding common pitfalls: over-committing, mixed-scope commits, and lost context between sessions
• Understanding what CLAUDE.md is and how Claude Code uses it at session start
• Deciding what to put in it: coding standards, architecture decisions, library preferences, review checklists
• Deciding what to keep out of it: sensitive credentials and context that changes frequently
• Structuring a CLAUDE.md for a real project and encoding domain-specific vocabulary and constraints
• Team governance: who owns CLAUDE.md, how it's updated and reviewed, and versioning it alongside code

Testing, Validation, and Autonomous Iteration using Claude Code

• Directing Claude Code to write unit and integration tests from a function description
• Running test suites through Claude Code and interpreting failures
• Understanding the autonomous iteration loop: when to let it run and when to intervene
• Defining acceptance criteria clearly enough for the tool to validate against
• Reviewing test coverage: what Claude Code tends to miss
• Using tests as a specification tool: writing tests first, then delegating the implementation
• Recognizing when not to let it iterate autonomously: risk thresholds in safety-relevant or high-stakes code
• Evaluating AI-generated test suites for coverage gaps and false confidence

Extending Claude Code: MCP and Data Workflows

• Understanding what MCP is and why it exists: giving Claude Code a longer reach
• Surveying integration categories: project management, documentation, data sources, and custom tooling
• Connecting Claude Code to an internal data source via MCP
• Delegating data cleaning and transformation scripts
• Describing an analysis goal in plain language and reviewing the resulting Python or R code
• Iterating on visualizations conversationally rather than through trial-and-error coding
• Turning ad hoc scripts into repeatable, documented analysis pipelines
• Reviewing statistical logic in AI-generated analysis code: what to verify manually
• Weighing security considerations: what access you grant, to what, and with what controls
• Evaluating whether an integration creates value or just complexity