Workshop · Developer · Level 2

Claude Code: Customization & Production

The full customization stack: memory, custom slash commands, skills, hooks, MCP, and custom subagent files. The inflection point from smarter CLI to programmable, team-shareable development partner.

This is an advanced Claude Code course for experienced developers. The two sessions cover the full customization stack: Claude memory, custom slash commands, skills, hooks, MCP, custom subagent files, and production patterns.

Most engineers' Claude Code productivity flattens after the first few weeks of casual use. This course is the inflection point: the customization layer that turns Claude Code into a programmable, customizable, and team-shareable development partner.

There are two valid ways in. The first is from a foundational course such as Claude Code Foundations for Developers, where you've learned the basics in a structured way. The second is to skip introductory training entirely because you've been using Claude Code regularly and want the customization and production layer that experience-only learning doesn't reliably teach. Either way, you'll build your own CLAUDE.md for a project, ship a custom slash command and a skill, wire hooks that enforce guardrails, design custom subagent files for repeated specialized tasks, and refine your personal workflow.

By the end of this course, learners will be able to extend Claude Code from a personal CLI into a programmable, customizable, and team-shareable development partner. They will:

Configure a three-tier CLAUDE.md hierarchy with @-imports for any repository
Ship custom slash commands and skills that automate prompts and workflows previously done by hand
Wire PreToolUse and PostToolUse hooks that enforce safety guardrails
Build a working MCP server with the TypeScript SDK, exposing your own tools to Claude Code
Design custom subagent files with pinned tools and models for specialized recurring tasks
Configure Claude Code to run safely in headless mode within a CI pipeline
Compose memory, commands, skills, hooks, and subagent files into a single end-to-end automated workflow, and recognize the five canonical anti-patterns that signal a customization has gone wrong
Harden a personal customization kit they can defend to a senior teammate on the basis of cost vs. benefit

Topic Outline

Two sessions, six modules

One curriculum · delivered across two hands-on sessions

Module 01Memory

Memory and Project Configuration

Configuring the three-tier hierarchy of user, project, and local CLAUDE.md, and what belongs in each tier
Keeping CLAUDE.md short with the @-imports router pattern that routes to deeper docs
Editing memory live with /memory, two-way binding for in-session conventions
Recognizing the anti-patterns: bloat, capability-instead-of-convention, and stale auto-generated content

Module 02Commands & Skills

Custom Slash Commands and Skills

Building slash commands from markdown files, with explicit invocation and parameter substitution
Writing skills, from SKILL.md frontmatter to the trigger description that serves as the routing contract
Choosing between a slash command (manual), a skill (auto-triggered), and a memory line (passive)
Composing memory, commands, and skills into the customization triangle

Module 03Hooks

Hooks and Guardrails

Following the hook lifecycle, PreToolUse, PostToolUse, and Stop, and knowing when each fires and what state is available
Implementing the JSON contract: stdin payload in, exit code out, and the allow / non-blocking error / block outcomes
Building guardrails that deny-list dangerous bash, lint on save, and keep audit logs for post-incident traceability
Scoping settings across user and project, and avoiding the tilde-doesn't-expand pitfall

Module 04MCP & Subagents

MCP and Custom Subagent Files

Understanding MCP: tools, resources, prompts, and the stdio transport
Scaffolding a working MCP server with the TypeScript SDK, and verifying it with /mcp
Writing tool descriptions as contracts, the text Claude reads to decide when to call your tool
Building custom subagent files with pinned tools, models, and system prompts for recurring specialized tasks
Choosing when a subagent file is the right primitive vs. a slash command or skill

Module 05Team & Production

Team Patterns, Headless CI, and Security

Adopting team patterns such as code-review subagents, refactor pipelines, and structured PR workflows
Running headless in CI with the four safety flags: -p, --output-format, --max-turns, and --allowed-tools
Enforcing managed settings at the org level that individual users can't override
Knowing when --dangerously is appropriate (sandboxed CI runners) and when it isn't (laptops, workstations)

Module 06Capstone

Composition, Advanced MCP, and the Capstone

Composing the five canonical patterns, from command-spawns-subagent to skill-invokes-MCP
Going deeper on MCP: resources, prompts, and the stdio vs. HTTP vs. SSE transports
Climbing the customization pyramid lightest-tier first, and applying the demotion test to every primitive you own
Touring the anti-patterns gallery, kitchen-sink subagent, always-on hook, wrapper MCP, CLAUDE.md novel, and phantom skill, with the tell and fix for each
Composing at least three primitives into an end-to-end capstone workflow you'll use weekly, and defending it on cost vs. benefit

Upcoming Sessions

Cohort 01Live online

September 29 & October 1, 2026

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

Cohort 02Live online

November 3 & 5, 2026

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