Workshop · Developer · Level 1

Claude Code Foundations For Developers

Safe agentic habits and daily-workflow fluency on Claude Code, the fastest-growing coding tool in software. Plan mode, the agentic debugging loop, subagents, and headless mode, carried into your job the next workday.

An introductory Claude Code course for working developers. Learners should already have experience in at least one language and be comfortable working in a terminal.

Participants work directly with Claude Code, Anthropic's command-line AI tool, to tackle real coding tasks through natural conversation. Whether writing a function from scratch, tracking down a stubborn bug, refactoring a tangled module, or onboarding to an unfamiliar codebase, this course gives practical experience with AI as a collaborative coding partner.

The emphasis throughout is on safe habits and daily-workflow fluency, the discipline that keeps an agentic session shipping instead of costing you an hour of fighting the tool. Participants leave having planned and shipped changes on real repositories, mapped an unfamiliar codebase, debugged failing code with the agentic loop, orchestrated a small multi-step workflow with subagents, and built a daily workflow they can carry into work the next day.

By the end of this course, learners will be able to use Claude Code productively on codebases, following safe agentic habits. They will:

Demonstrate the audit-first habit on every proposed change, and use plan mode and the core slash commands to scope work before any code is written
Map an unfamiliar codebase using Claude's file-system tools, and recover from drift using the three escalating recovery moves
Apply the agentic debugging loop to broken code at three levels of difficulty
Spawn ephemeral subagents for parallel exploration, and run Claude Code in headless mode for simple scripted automation
Polish code through deliberate refactoring, documentation generation, and clean commit-message authoring
Ship at least one end-to-end feature using the full Level 1 toolkit, ready to carry into the next workday

Topic Outline

Two sessions, six modules

One curriculum · delivered across two hands-on sessions

Module 01Foundations

Claude Code Foundations

Distinguishing Claude Code from Claude.ai and inline copilots, and when each fits
How Claude Code reads files, runs commands, and produces diffs you control
The four risks of unsupervised 'vibe coding' and the dominant failure modes
Verifying the environment, opening the REPL, and sending a first prompt against your own codebase

Module 02Safe Habits

Safe Habits and the First Real Win

Building the audit-first habit of reading every proposed diff before applying, the cheapest accuracy check there is
Learning the slash commands that matter, /init, /cost, /clear, /compact, and /memory, and when to reach for each
Letting Claude propose before it acts with plan mode, and when the overhead earns its keep
Banking daily wins with commit-message generation, explain-this-code, and quick docstring or test-stub scaffolding
Shipping a small but real change to a working CLI utility, using the audit-first workflow end to end

Module 03Reading Code

Understanding Unfamiliar Code Fast

Onboarding from clone to "I could explain this to a teammate," using Claude as your reader
Choosing the right file-system tool, Read, Edit, Grep, or Glob, for each step of understanding
Using Claude as a fast structural-query engine to find every TODO, API endpoint, and error handler
Practicing context discipline with file scoping, and the trade-off between /clear and /compact when the window fills
Onboarding yourself to an unfamiliar open-source repo: an architecture summary, the hardest-to-change files, and one structural pattern

Module 04Plan & Recover

Plan Mode in Depth and Recovering from Drift

Writing the five-tag plan, GOAL, FILES, SEQUENCE, RISKS, VERIFY, and what makes each strong vs. weak
Iterating with three moves, narrow scope, flip approach, tighten verify, and when each fits
Recognizing Claude going off-track before it costs the session
Recovering with redirect, scope, or restart, from cheapest to most expensive
Shipping a real change to a moderately sized repo with the full map, plan, ship workflow

Module 05Debugging

The Agentic Loop and Debugging

Naming the agentic loop explicitly: Plan, Act, Verify, Iterate
Climbing the verification ladder, five levels of confidence from vibes to proof
Running the agentic debugging loop, Run, Observe, Propose, Verify, on real failing code
Submitting errors well, and the debugging anti-patterns to recognize: infinite fix-it loop, lying about success, kitchen-sink rewrite, phantom bugs

Module 06Capstone

Subagents, Headless Mode, and the Capstone

Spawning ephemeral subagents in their own context, using researcher, planner, worker, and verifier patterns
Running multiple subagents in a single response for true parallel execution
Running Claude Code headless as a scripted CLI with the four CI safety flags
Refactoring through three lenses, readability, performance, and maintainability, with a different prompt shape for each
Shipping one end-to-end capstone feature with the full Level 1 toolkit: plan, execute, refactor, polish, and a Conventional Commits message

Upcoming Sessions

Cohort 01Live online

September 15 & 17, 2026

Schedule: 9:00 AM – 12:00 PM PST
Tuition: US$495
Instructors: Josh Alpert

Cohort 02Live online

October 20 & 22, 2026

Schedule: 9:00 AM – 12:00 PM PST
Tuition: US$495
Instructors: Josh Alpert

Cohort 03Live online

January 19 & 21, 2027

Schedule: 9:00 AM – 12:00 PM PST
Tuition: US$495
Instructors: Josh Alpert

Programs can be customized for your organization. Delivered on-site, in-person, live-online, or asynchronously as a course library.
Inquire About Custom Solutions

Going Further

This Course Counts Toward A Certification

Interested in going further? This course is one of the catalog courses that make up the AI-Enabled Developer Certification. Complete the full path and pass the certificate exam to earn the credential.

About the certification All workshops