cwc-workshops: Best AI Agent Workshops for Developers in 2026

What Is cwc-workshops?

cwc-workshops is an AI Agent Workshops repository built by Anthropic PBC that publishes workshop materials for Code with Claude sessions. It is one of the best AI Agent Workshops tools for developers, indie hackers, and AI platform teams learning Claude Code and Managed Agents. The repo is Apache-2.0 licensed and includes eight workshop tracks that cover model selection, multi-agent decomposition, memory, evals, and runtime-verifiable UI workflows.

This is not a productized framework, and it is explicitly not maintained and not accepting contributions. Treat it as a frozen reference set of exercises for Claude-first agent design, not as a dependency you should bet production on without adapting the patterns yourself.

Quick Overview

Who Should Use cwc-workshops?

cwc-workshops is best for people who learn by shipping small, concrete systems rather than reading abstract agent theory.

• Claude Code power users who want hands-on patterns for prompts, Skills, MCP servers, and managed execution instead of generic agent advice.
• Indie hackers prototyping AI products who need working examples of agent decomposition, memory, and eval loops before they design their own stack.
• Platform and product engineers who want to see how Anthropic frames agent workflows, especially around task decomposition, runtime checks, and human-in-the-loop control.
• Workshop instructors and internal enablement teams who need a ready-made curriculum for a team session on Claude-first development.

Not ideal for:

• Teams that need a maintained starter kit with issue support, active releases, and dependency updates.
• Builders looking for a single opinionated framework with an API surface you can import and extend.
• Organizations that need a production-ready SaaS instead of a learning repository.

Key Features of cwc-workshops

• Anthropic-run workshop curriculum — Each folder is a focused lab with a specific AI workflow, from model selection to multi-agent orchestration. The material is written around real Claude Code usage, so the exercises map directly to the toolchain Anthropic actually demonstrates.
• Skill-based agent decomposition — The agent-decomposition workshop shows how to break a long prompt into Skills, code execution, and callable agents. That pattern is useful when a single prompt turns into a maintenance problem and you need sharper boundaries.
• Eval-first iteration — The eval-driven-agent-development track uses a two-layer grader: programmatic .pptx XML metrics plus LLM-as-judge scoring on rendered slides. That is a practical example of measuring prompt changes instead of arguing about vibes.
• Managed Agents with real tools — Several labs use Claude Managed Agents to call local tools, inspect logs, and work through multi-step tasks. The ship-your-first-managed-agent example shows a Streamlit incident dashboard plus an offline SRE assistant that can grep a 70k-line log and point at the bad commit.
• Memory primitives for long-lived agents — The agents-that-remember workshop demonstrates cross-session persistence with a memory store and transcript consolidation with the Dreaming Service. That is useful if you are building assistants that need continuity across sessions rather than stateless chat.
• Runtime-verifiable UI contracts — The how-we-claude-code track builds a Vite + React app whose components emit a machine-readable DOM contract. That lets an agent or CI assert UI structure at runtime, which is a better guardrail than screenshot-only checks.
• Fast decision-probe loops — The agent-battle workshop uses a --eval path that can validate configuration changes in about 30 seconds before committing to a longer run. That is a strong pattern for reducing the cost of agent tuning.

cwc-workshops vs Alternatives

Pick cwc-workshops when you want examples that show how Anthropic thinks about agent design, evals, and tool use in practice. Pick Claude Code Canvas when you want to visually structure a workflow before writing code. Pick Brainstorm MCP when you need a structured ideation layer for prompt and task splitting.

Choose OpenSwarm if you want a more general multi-agent orchestration layer rather than workshop material. If you are instrumenting these flows, pair the repo's ideas with OpenTrace for event inspection or Claude Context Mode for tighter context management.

How cwc-workshops Works

cwc-workshops works as a foldered curriculum: each workshop is a self-contained scenario with a goal, a stack, and a set of implementation constraints. The core design choice is to teach agent architecture through finished exercises, not through a large shared library, which keeps the surface area small and the lessons concrete. The repo is therefore closer to a lab manual than an SDK.

The technical thread across the repository is consistent: start with a real workflow, then introduce Claude Code, MCP, Skills, or Managed Agents where the workflow breaks down. That means the material repeatedly emphasizes decomposition, tool boundaries, and validation, which are the parts most teams get wrong when they try to build agents from a single system prompt.

A typical setup looks like this:

git clone https://github.com/anthropics/cwc-workshops.git
cd cwc-workshops/ship-your-first-managed-agent
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
streamlit run app.py

That pattern clones the workshop repo, isolates Python dependencies, and starts a local Streamlit app for one of the managed-agent labs. Different folders use different runtimes, so the exact entrypoint changes by workshop, but the workflow stays the same: read the folder README, install the declared dependencies, and run the local app or script that matches the exercise.

The design philosophy is explicitly evaluation-driven. Workshops such as eval-driven-agent-development and agent-battle show that agent behavior should be probed with task suites, scoring rules, and repeatable runs, not hand-waved with prompt edits. If you are building adjacent tooling, this pairs well with OpenTrace for tracing and with Claude Context Mode for context hygiene.

Pros and Cons of cwc-workshops

Pros:

• The repository gives you concrete agent patterns instead of generic AI platitudes.
• The labs cover Claude Code, MCP, Skills, memory, and Managed Agents in one place.
• The exercises are scenario-driven, which makes them easier to port into real products.
• The eval-centric tracks show how to measure changes with programmatic checks and LLM judges.
• The examples include real app surfaces like Streamlit dashboards and Vite + React UIs.
• The Apache-2.0 license makes the material easy to inspect, fork, and adapt.

Cons:

• The repo is not maintained, so dependency drift and stale instructions are real risks.
• It is workshop material, not a polished framework or supported starter kit.
• The examples are split across multiple folders, so there is no single canonical runtime.
• Some labs assume access to Anthropic-specific products and concepts, which narrows portability.
• There is no promise of issue triage, release cadence, or backward compatibility.

Getting Started with cwc-workshops

The fastest way to use cwc-workshops is to clone the repo, pick one workshop folder, and run the stack that folder expects. For a Python-backed lab, a realistic starting point looks like this:

git clone https://github.com/anthropics/cwc-workshops.git
cd cwc-workshops/how-we-claude-code
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
python app.py

After that, you should expect the workshop README to tell you which Anthropic feature to wire up, which local tools or MCP servers to expose, and which eval or manual check to use. If you switch to a React or Vite-based folder, the install step changes, but the pattern stays the same: install dependencies, run locally, then validate the workflow against the exercise instructions.

Verdict

cwc-workshops is the strongest option for Claude-first agent education when you want real workshop scaffolding instead of a generic framework. Its biggest strength is the way it turns Anthropic's agent ideas into runnable exercises with evals, and its main caveat is that the repo is frozen and not maintained. Use it as a reference curriculum, then port the patterns into maintained code you control.