A conference lab that escaped the conference
cwc-workshops packages nine exercises from Anthropic's Code with Claude events. Rather than explain agent concepts in abstract prose, each folder gives participants a system to inspect, break apart, complete, or evaluate. The collection spans model selection, prompt decomposition, product design with Claude Code, a first managed agent, a game competition, cross-session memory, evaluation-driven development, a multi-agent deal desk, and an SEC research desk.
This is a strong format for learning because the examples have consequences. The inventory exercise starts with a 402-line system prompt and asks you to move durable instructions into skills, code, and one sub-agent. The slide workshop makes prompt changes compete against programmatic PowerPoint checks and visual judges. The research desk shows a server fulfilling custom tool calls while analyst sessions continue in the cloud. These are architectural lessons, not a gallery of chat completions.
The repository is also unusually clear about its status: these are workshop materials, they are not maintained, and Anthropic is not accepting contributions. That disclaimer should govern every reuse decision.
The best exercises teach boundaries
Several folders demonstrate where an agent should stop and ordinary software should begin. ship-your-first-managed-agent asks participants to implement seven small API functions in a Streamlit incident dashboard. The cloud agent can search a 70,000-line log in its sandbox, but local tools still retrieve application data. The exercise makes agent, environment, session, event stream, and custom-tool responsibilities visible without burying them in a large framework.
agent-decomposition is even more useful for teams with an overgrown agent. Participants compare a monolithic inventory agent with a version using uploaded skills, CSV data, code execution, and a deliberately limited sub-agent. A 12-task evaluation runs after each change. The lesson is not that more agents are always better. It is that instructions, deterministic calculations, and delegated judgment have different homes, and evaluation should decide whether a decomposition helped.
how-we-claude-code covers a different boundary: how to make generated interfaces inspectable. Its final React example gives components fixtures, invariants, and a machine-readable DOM contract, then runs a verification matrix against them. That idea can transfer beyond Claude because it turns visual intent into something an agent or CI job can observe.
Managed Agents access is the real prerequisite
The root looks like a normal TypeScript repository, but there is no universal setup command. Every workshop is a separate project. The simplest local verification demo needs bun. The first managed-agent lab needs Python 3.10, a virtual environment, requirements, and an Anthropic API key. The inventory workshop uses uv. The presentation evaluator requires Node.js 22, Docker, a locally built rendering image, and the ant command-line tool. The game lab also starts a Minecraft server and bot, bringing Java, npm, ports, and local processes into the mix.
Most of the deeper material depends on Claude Managed Agents. The deal desk requires an API key with the beta enabled. The memory workshop says the organization must be opted into a research preview before its bootstrap script can create agents, environments, sessions, and memory resources. The model-sweep exercise requires Claude Code and can run repeated trials across models and inference settings. Those calls have a cost even though the workshop code is Apache 2.0.
Setup scripts help by provisioning resources and writing IDs into environment files, and some are idempotent. They do not remove the need to understand what was created in a cloud account. Participants should use a disposable workspace where possible, set a budget, record resource IDs, and clean up agents, environments, sessions, stores, and deployments afterward.
Excellent examples, fragile foundations
The most ambitious samples are close enough to applications that copying them wholesale is tempting. The Deal Desk has a polished Next.js interface, streaming events, gated tool confirmations, a coordinator, four research sub-agents, memory, outcomes, and optional Linear access through MCP and a vault. The Research Desk adds SEC filing analysis, bounded fan-out, scorecards, shared memory, and a long-running server-side orchestrator. Both include starter code and either a finished reference or solution files.
They are still teaching systems. Deal Desk uses fictitious companies and financials. Research Desk leaves numbered tasks in the main branch and explicitly avoids serverless hosting because its watcher is a long-lived process. Agent Battle depends on event infrastructure originally designed for a timed competition. A production team must add authorization, tenancy, retry policy, observability, data retention, spend controls, and failure recovery based on its own requirements.
Documentation drift is another predictable risk. An open issue reports that a workshop video instructed the user to install from a missing requirements.txt. That file does exist in one workshop, which suggests the problem may be the assumed directory or changed material rather than a repository-wide omission. Either way, it shows why old recordings and current folders must be matched carefully.
Health and the decision
The last repository push was June 26, 2026, when the Research Desk workshop landed. Pull requests were still being opened in August, but the project has declared that contributions are not accepted. The eight open issues and pull requests combined should therefore not be read as an active support queue. There is no tagged GitHub release, and beta interfaces can move faster than copied workshop code.
As educational material, the collection is better than its maintenance posture. Folder-level guides state the scenario, prerequisites, commands, learning goal, and file layout. Many provide a starter, a solution, seeded data, and evaluation tasks, making the intended lesson easy to reconstruct without conference slides.
Use cwc-workshops when you want a concentrated tour of Anthropic's agent design patterns and are comfortable repairing dated setup details. The right output is understanding and a few tested patterns, not a fork you deploy unchanged. Teams seeking stable API references should use maintained documentation and cookbooks alongside it. Teams outside the Claude ecosystem will still find ideas in its eval and verification designs, but much of the runnable value depends on Anthropic access.