Build real software faster and better using Claude Code as an agentic AI collaborator. This workshop teaches developers how to work with Claude Code — Anthropic's CLI for Claude — across the full development lifecycle: project setup, TDD, refactoring, testing, documentation, and workflow automation.
Unlike completion-based tools, Claude Code is an agent that reads your codebase, runs commands, and takes multi-step actions. This workshop teaches you how to harness that power effectively — and safely.
Choose Your Technology Stack: This workshop supports both 🔷 .NET and 🟩 Spring Boot implementations.
This workshop runs over two days:
Learn to work with Claude Code as a development partner — setting up project memory with CLAUDE.md, turning requirements into code with TDD, choosing the right permission mode and planning large tasks in Plan Mode, refactoring code with a checkpoint safety net, and integrating Claude Code into your git workflow. Works with either .NET 9 or Spring Boot 4.x.
Master advanced Claude Code capabilities: a dedicated security review gate, the permissions and safety model, extending Claude Code with MCP servers and Skills, building and chaining custom subagents, headless/automation mode for CI pipelines, and a capstone where you build your own subagent or skill and package it as a plugin. Output styles (Lab 14) are self-study.
Full workshop duration: about 12 hours of instruction across two days (plus breaks)
What makes this workshop unique:
- Agentic-first mental model — teaches the trust-and-verify workflow, not just "how to prompt"
- CLAUDE.md mastery — project/subdir/user memory hierarchy plus path-scoped
.claude/rules/for encoding team standards - Ready-to-use customizations — shipped subagents, a skill, and rules in
.claude/to study, run, and extend - Hooks & automation —
.claude/settings.jsonfor pre/post-tool workflow gates - MCP server integration — extending Claude Code with GitHub, filesystem, and custom tools
- Safety by design — permissions model, reviewing diffs, scoping tasks appropriately
- Bilingual support — same concepts, your technology stack (.NET or Spring Boot)
- Claude Code: Installed with the native installer (recommended — auto-updates, no Node.js needed):
- macOS / Linux / WSL:
curl -fsSL https://claude.ai/install.sh | bash - Windows PowerShell:
irm https://claude.ai/install.ps1 | iex - Alternatives:
brew install --cask claude-code,winget install Anthropic.ClaudeCode, ornpm install -g @anthropic-ai/claude-code(Node.js 22+)
- macOS / Linux / WSL:
- A Claude account, one of:
- A Claude subscription (Pro, Max, Team, or Enterprise) — sign in with
/loginon first run - A Claude Console API key from platform.claude.com, set as
ANTHROPIC_API_KEY - Amazon Bedrock, Google Vertex AI, or Microsoft Foundry access (see the authentication docs)
- A Claude subscription (Pro, Max, Team, or Enterprise) — sign in with
- Visual Studio Code (optional but recommended): 1.94+, with the Claude Code extension (
anthropic.claude-code) - Git: Basic familiarity with git commands, and a GitHub account to fork this repo
Devcontainer users: The containers install Claude Code for you. Sign in inside the container with
/login, or setCLAUDE_CODE_OAUTH_TOKEN(fromclaude setup-token) orANTHROPIC_API_KEYon your host before opening it — both are forwarded automatically. See.devcontainer/README.md.
- .NET 9 SDK: Verified with
dotnet --version - C# Dev Kit extension for VS Code
- Java 21 JDK: Verified with
java -version - Maven 3.9+: For building Spring Boot projects
- Spring Boot extension pack for VS Code
# Claude Code
claude --version
claude doctor # Install & settings diagnostics
# .NET Track
dotnet --version # Should show 9.x.x
# Spring Boot Track
java -version # Should show Java 21
mvn --versionBy the end of Day 1, participants will be able to:
- Explain the agentic model — how Claude Code differs from completion-based assistants
- Configure CLAUDE.md at project and subdirectory levels to encode team standards
- Turn requirements into code — from a user story to a tested
Priority/DueDatefeature andPOST /tasksendpoint - Apply TDD with Claude Code using the full Red-Green-Refactor cycle
- Choose the right permission mode (Manual, Accept edits, Plan, Auto), plan large tasks in Plan Mode before any files change, and dial reasoning with
/effortorultrathinkwhen it's worth the cost - Perform multi-file refactoring safely, reviewing diffs before accepting changes
- Recover from a bad edit using checkpoints and rewind, without touching git
- Manage context with
/compact, session continuity, and scoped tasks - Integrate with git — conventional commits, PR descriptions,
/code-review
By the end of Day 2, participants will be able to:
- Run a dedicated security review with
/security-reviewbefore code goes out as a PR - Navigate the permissions model — allow/deny tool use, understand safety boundaries
- Automate workflows with hooks — pre/post-tool hooks in
.claude/settings.json - Configure MCP servers — extend Claude Code with GitHub MCP, filesystem MCP, and custom tools
- Package reusable procedures as Skills — SKILL.md, progressive disclosure, when to use a skill vs. MCP vs. CLAUDE.md
- Build and chain custom subagents — use the shipped
backlog-generator,architecture-reviewer, andtest-strategistagents, and design your own with least-privilege tools - Use headless/automation mode —
-p,--output-format,--continue, CI pipeline integration - Customize how Claude Code communicates with output styles (self-study, Lab 14)
- Design and share a team configuration — encode standards in CLAUDE.md and rules, then package a subagent or skill as a plugin
Each numbered module below is a short slide intro and its matching hands-on lab, delivered back-to-back as one time block — the duration shown is the combined total (condensed intro plus the upper end of the lab's stated duration). See the Presentations Catalog for full slide-only durations and the Facilitator Guide for an agenda with breaks and fast-track options.
| Module | Duration |
|---|---|
| Kickoff & Setup | 15 min |
| Claude Code Features Tour | 10 min |
| Lab 1: First Contact — CLI basics & the agent model (no dedicated module; follows the intro above) | 25 min |
| Module 2: CLAUDE.md & Project Memory (+ Lab 2) | 55 min |
| Module 3: TDD & Requirements → Code (+ Lab 3, two parts) | 105 min |
| Module 4: Plan Mode, Permission Modes & Thinking (+ Lab 4) | 35 min |
| Module 5: Multi-File Refactoring & Context Management (+ Lab 5) | 60 min |
| Module 6: Checkpoints & Rewind (+ Lab 6) | 25 min |
| Module 7: Git Workflow & PR Preparation (+ Lab 7) | 30 min |
| Day 1 Wrap-Up & Discussion | 15 min |
| Day 1 total | 375 min |
| Module | Duration |
|---|---|
| Day 2 Kickoff & Recap | 10 min |
| Module 8: Security Review Workflows (+ Lab 8) | 45 min |
| Module 9: Permissions, Safety & Hooks (+ Lab 9) | 40 min |
| Module 10: MCP Servers (+ Lab 10) | 45 min |
| Module 11: Skills (+ Lab 11) | 45 min |
| Module 12: Custom Subagents & Agent Workflows (+ Lab 12) | 50 min |
| Module 13: Headless & Automation Mode (+ Lab 13) | 40 min |
| Module 15: Capstone — Team Configuration & Plugins (+ Lab 15) | 75 min |
| Day 2 Wrap-Up & Next Steps | 15 min |
| Day 2 total | 365 min |
Self-study: Module 14, Output Styles & Custom Personas (+ Lab 14, 20–25 min). It's the least dependent lab, so it's done after the workshop. Facilitators with spare time can run it between Modules 13 and 15.
Module numbers here match each module's lab number exactly (Module 9 pairs with Lab 9, Module 15 with Lab 15, and so on) — the only exception is Lab 1, which has no dedicated module of its own and follows directly after the Day 1 intro.
- Lab 1: First Contact (20–25 min) — Install, authenticate, first run, slash commands, permission modes and prompts
- Lab 2: CLAUDE.md & Project Memory (40–45 min) — Project/subdir/user hierarchy,
/init, imports, path-scoped.claude/rules/ - Lab 3: TDD & Requirements → Code (90–100 min, two parts) — Red-Green-Refactor, then a user story to
Priority/DueDateandPOST /tasks - Lab 4: Plan Mode, Permission Modes & Thinking (25–30 min) — Manual / Accept edits / Plan / Auto, read-only planning,
/effortandultrathink - Lab 5: Multi-File Refactoring (45–50 min) — Legacy code, context management,
/context,/compact - Lab 6: Checkpoints & Rewind (20 min) — Session-level undo with
/rewind, separate from git - Lab 7: Git Workflow & PR Preparation (20–25 min) — Conventional commits,
/code-review, PR descriptions
- Lab 8: Security Review Workflows (30–35 min) —
/security-review, a project-specific security skill - Lab 9: Permissions, Safety & Hooks (25–30 min) — Permission rules and modes,
.claude/settings.json, hooks - Lab 10: MCP Servers (30–35 min) — Configure and use MCP servers (including GitHub's) with Claude Code
- Lab 11: Skills (30–35 min) — SKILL.md, progressive disclosure, the shipped
test-data-generatorskill, building your own - Lab 12: Custom Subagents & Agent Workflows (35–40 min) — Built-in subagents, the shipped
.claude/agents/, chaining backlog → architecture review → test strategy - Lab 13: Headless & Automation Mode (25–30 min) —
-p, output formats, piping, CI integration with GitHub Actions - Lab 14: Output Styles & Custom Personas (20–25 min, self-study) — Persistent tone/behavior customization
- Lab 15: Capstone — Team Configuration (60–65 min) — Design a team config, build your own subagent or skill, and package it as a plugin
Presentations use Marp format. View in VS Code with the Marp extension.
- Day 1 Modules — 9 standalone modules
- Day 2 Modules — 9 standalone modules
- Presentations Catalog — delivery patterns and timing
- Local Setup Guide — For participants who cannot use devcontainers
- Pre-Workshop Checklist — Everything to complete before the session
- Customization Decision Guide — CLAUDE.md vs. rules vs. skills vs. subagents vs. hooks vs. MCP vs. plugins: when to use which
- Agent Design Guide — How to design, test, and chain effective subagents
- Agent Governance Guide — Managing Claude Code config at enterprise/team scale
- Facilitator Guide — Pre-workshop setup, agenda and timings, per-lab talking points and pitfalls, troubleshooting
CLAUDE.md— Project-level memory for this workshop reposrc-dotnet/CLAUDE.md— .NET-specific context for Claude Codesrc-springboot/CLAUDE.md— Spring Boot-specific context.claude/— Shipped subagents, skill, rules, and settings (see What's in.claude/)
This repo ships a working set of Claude Code customizations. You'll study, run, and extend them in the labs, and you can copy them into your own projects.
| Path | What it is | Used in |
|---|---|---|
.claude/agents/architecture-reviewer.md |
Read-only subagent that checks Clean Architecture/DDD boundaries in both stacks | Labs 3, 12, 15 |
.claude/agents/backlog-generator.md |
Subagent that turns a feature request into INVEST user stories saved to docs/backlog/ |
Labs 3, 12 |
.claude/agents/test-strategist.md |
Read-only subagent that plans tests (xUnit v3 / JUnit 5) before you write them | Labs 3, 12 |
.claude/skills/test-data-generator/ |
Skill (/test-data-generator) that generates builders, theory data, and JSON payloads through the real domain factories |
Lab 11 |
.claude/rules/dotnet.md, .claude/rules/springboot.md |
Path-scoped rules that load only when Claude works on files in that stack | Lab 2 |
.claude/rules/follow-up-questions.md |
Always-on rule: ask targeted clarifying questions before non-trivial changes | Lab 2 |
.claude/settings.json |
Teaching artifact: allow/ask/deny permission rules plus audit-log hooks (requires jq) |
Labs 1, 9 |
Not sure which mechanism to reach for? See the Customization Decision Guide and the Agent Design Guide.
This workshop is the Claude Code counterpart to Centric's GitHub Copilot workshop and follows a similar learning arc. If you've done that workshop, here's how the concepts map:
| GitHub Copilot | Claude Code | Where you'll see it |
|---|---|---|
.github/copilot-instructions.md |
CLAUDE.md (project, subdirectory, user) |
Lab 2 |
*.instructions.md with applyTo globs |
.claude/rules/*.md with paths: frontmatter |
Lab 2 |
Prompt files (*.prompt.md) |
Skills you invoke with /name (legacy .claude/commands/*.md still work) |
Labs 8, 11 |
Agent skills (SKILL.md) |
Skills — same Agent Skills open standard | Lab 11 |
Custom agents (*.agent.md) |
Subagents (.claude/agents/*.md) |
Lab 12 |
| Agent handoffs | Subagent chaining ("use X, then use Y") | Lab 12 |
| Ask / Plan / Agent modes | Permission modes: Plan / Manual / Accept edits / Auto (Shift+Tab) | Labs 1, 4 |
@workspace / codebase search |
Agentic codebase reading and the built-in Explore subagent | Labs 1, 12 |
| MCP servers | MCP servers (claude mcp add, .mcp.json) |
Lab 10 |
| Hooks | Hooks in .claude/settings.json |
Lab 9 |
| Copilot code review | /code-review and /security-review |
Labs 7, 8 |
| Copilot coding agent in GitHub Actions | Headless mode (claude -p) and the Claude Code GitHub Action |
Lab 13 |
| — | Output styles | Lab 14 |
| — | Plugins (bundle skills, subagents, hooks, and MCP servers for sharing) | Lab 15 |
🔷 .NET Solution (src-dotnet/ directory):
- Clean Architecture: Domain / Application / Infrastructure / API layers
LegacyTaskProcessorfor refactoring exercises- xUnit test stubs with FakeItEasy —
dotnet testinitially reports 1 passed, 11 skipped, 0 failed; you implement the skipped stubs during the labs - Starter domain: a
Taskwith title, description, and status — priorities, due dates, and more are added during the labs
🟩 Spring Boot Solution (src-springboot/ directory):
- Clean Architecture: domain / application / infrastructure / web layers
LegacyTaskProcessor/LegacyBatchImportServicefor refactoring exercises- JUnit 5 tests with Mockito
Claude Code Configuration:
CLAUDE.md(project root): Workshop repo memorysrc-dotnet/CLAUDE.md: .NET context for Claude Codesrc-springboot/CLAUDE.md: Spring Boot context for Claude Code.claude/settings.json: Permissions and hooks example.claude/agents/,.claude/skills/,.claude/rules/: Shipped subagents, skill, and rules (see What's in.claude/)
-
Fork this repository on GitHub (click Fork in the top-right corner).
Forking is required — not optional. Labs 8 (
/security-reviewneeds anoriginremote), 10 (GitHub MCP), 13 (headless/CI), and 15 (the capstone) all work against your own remote. You'll push commits, trigger workflows, and query your fork's issues during the workshop. -
Clone your fork:
git clone https://github.com/YOUR-GITHUB-USERNAME/ai-coding-workshop-claude-code.git cd ai-coding-workshop-claude-code -
Add the upstream remote (so you can pull workshop updates):
git remote add upstream https://github.com/centricconsulting/ai-coding-workshop-claude-code.git
-
Create your working branch:
git checkout -b workshop/your-name
-
Verify Claude Code:
claude --version claude doctor claude # Opens Claude Code (sign in on first run) — try asking "what is this project?" -
Verify your stack:
# .NET — expect 1 passed, 11 skipped, 0 failed (skipped = test stubs you'll implement) dotnet build src-dotnet && dotnet test src-dotnet # Spring Boot — expect BUILD SUCCESS, about 100 tests, all passing cd src-springboot && mvn clean test
-
Ready! Follow your facilitator or start with Lab 1.
- Write a good CLAUDE.md first — the more context Claude Code has, the less re-prompting you need
- Scope tasks clearly — Claude Code works best with specific, bounded requests
- Review diffs before accepting — treat every change as a code review
- Use
/compactproactively — don't wait for context limits - Start with read-only tasks — get familiar with how Claude Code explores your code before letting it write
- Trust but verify — Claude Code can be wrong; always run tests after changes
Found an issue or have suggestions? Create an issue with the lab number, section, and your environment details.
Workshop content is proprietary to Centric Consulting. See LICENSE.md.