AI-Assisted Development with Claude Code

This course provides a comprehensive guide to AI-assisted software development using Claude Code, equipping participants with the skills needed to investigate codebases strategically, validate AI-generated code rigorously, and operate Claude efficiently in production environments. The curriculum focuses on professional workflows, safety practices, and cost discipline. Students work hands-on with a realistic Go codebase (riftbattle-labs), learning both the thinking skills that make AI development safe and the practical tools that make it scalable.

By the end of this course, participants will be able to:

• Investigate unfamiliar codebases systematically without writing code, identifying architecture, risks, dead code, and fragile areas.
• Diagnose bugs efficiently using minimal context, asking the right strategic questions before reading files.
• Design features through multi-pass workflows, forcing critique and revision before implementation.
• Write tests before code when working with Claude, ensuring AI output matches specifications.
• Integrate Claude with production systems using MCP (Model Context Protocol) for live context and cross-system automation.
• Build specialized subagents for focused tasks like code review, test coverage analysis, and security audits.
• Optimize Claude API costs by 60-90% through prompt caching, with additional savings from intelligent model routing and batch processing.
• Orchestrate complex, multi-step workflows using sequential, split-and-merge, and dynamic patterns.
• Use /cost to measure token efficiency, run tests to validate code quality, and apply investigation discipline to diagnose when AI output is correct versus when it needs refinement.

AI-Assisted Development with Claude Code Course Outline

Investigation Like a Senior Engineer

• Investigate systems before making changes.
• Decompose architecture strategically.
• Identify red flags such as dead code, duplication, and tight coupling.
• Synthesize findings into actionable onboarding briefs.
• Practice asking specific questions, requiring evidence, and understanding systems without coding.

Efficient Bug Investigation

• Apply constraint-driven diagnosis to reduce wasted context.
• Follow the four phases: symptom clarification, investigation planning, targeted investigation, and root cause articulation.
• Diagnose real bugs within a token budget.
• Read only the files that matter.
• Use /cost to measure efficiency and reinforce context discipline.

Multi-Pass Development – Claude Debates Claude

• Recognize why single-pass development is risky.
• Use a multi-pass workflow to understand the existing system, design approaches, critique options, implement, and review.
• Design features through deliberate iterations.
• Force Claude to challenge its own designs before coding begins.
• Use critique to catch hidden complexity early and reduce rework.

Testing & Validation Strategies for AI-Generated Code

• Identify common AI-generated code failures, including hallucinated APIs, logic drift, tautological tests, and edge case blindness.
• Use write-before-code practices when working with AI.
• Apply higher coverage expectations, such as 85-90% instead of 70-80%.
• Balance test distribution across unit, integration, end-to-end, and adversarial testing.
• Write comprehensive failing tests before asking Claude to implement to specification.

MCP (Model Context Protocol) Integration

• Understand MCP as an open standard for connecting Claude to production systems.
• Recognize MCP as “a USB-C port for AI.”
• Explore available servers such as GitHub, Slack, Notion, Linear, Figma, Jira, and Supabase.
• Apply integration patterns for analysis, automation, and context.
• Use GitHub MCP to triage issues without file-by-file prompting.

Building Custom Subagents

• Use subagents to reduce context bloat.
• Create focused, fresh sessions for specialized tasks.
• Identify when to use subagents for code review, security audit, and test coverage.
• Configure tool access appropriately, including read-only access for auditors.
• Build a test-coverage-reviewer subagent and evaluate the efficiency gains of clean context.

Token Optimization & Cost Efficiency

• Reduce API costs through prompt caching, intelligent model routing, and batch processing.
• Understand cache economics, including cache-read tokens at approximately 10% of normal input cost.
• Route lightweight tasks to Haiku, analytical work to Sonnet, and complex reasoning to Opus.
• Monitor cache hit rates and identify optimization opportunities.
• Measure baseline token usage, apply caching, adjust model choice, and calculate real-world savings.

Advanced Workflow Orchestration

• Move beyond single-prompt workflows.
• Use sequential workflows where one output feeds the next step.
• Apply split-and-merge workflows for parallel independent subtasks.
• Use dynamic workflows where Claude plans based on the task.
• Design a parallel code review workflow and synthesize results into a prioritized action list.

Efficiency with Loops and Skills

• Automate repetitive workflows using /loop and reusable Skills.
• Identify when to encapsulate review criteria as a Skill.
• Iterate Skills across multiple files.
• Practice multi-file code review using Skills composed in parallel.
• Measure token efficiency and understand how automation patterns reduce repetition at scale.

Key Teaching Principles

• Investigation before coding: Understand systems thoroughly; ask specific questions; require evidence
• Test-first for AI code: Define expected behavior before asking Claude to implement
• Constraint-driven efficiency: Use minimal context; control what gets read; measure token usage
• Systematic design: Think before coding; generate options; critique harshly; justify choices
• Specialization through tools: Use MCP for systems integration, subagents for focused analysis, Skills for automation
• Production discipline: Validate AI output rigorously; optimize costs; monitor in production