Learning to Build Agents with Anthropic

Lately everyone's talking about AI agents, but when it comes down to it, most examples end up being simple chatbots that can only summarize text. If you're tired of looking at "Hello World"-level demo projects, I found something more interesting. The cwc-workshops repository contains internal workshop materials from Anthropic's own Code with Claude team.

There's no dry documentation or marketing promises here. It's a collection of practical scenarios where Anthropic engineers show how they actually use Claude for working with code and building complex systems.

What's Inside This Repository

The project is a collection of nine workshops. Each one is a separate mini-project solving a specific engineering problem. An important detail: the repository is marked as "not maintained," meaning the authors don't plan to update the code or accept pull requests. Essentially, it's a snapshot of knowledge at a specific point in time, but for learning purposes that's actually better—you see a working configuration "as is."

Inside you'll find scenarios for a wide range of tasks: from selecting the optimal model by cost-to-performance ratio to building systems with long-term memory. Most examples are built around Claude Managed Agents and the MCP (Model Context Protocol), which the Claude developers are actively promoting right now.

What You Can Learn Here

I've highlighted several of the most interesting directions that will help you stop "guessing at prompts" and start designing systems.

From Golfish to Colleague Evolution

In folder agents-that-remember there's an excellent example of how to deal with agent "amnesia." Instead of simply passing chat history, the authors propose using memory primitives. First, you launch an agent that remembers nothing between sessions, and then you incrementally add storage and a so-called Dreaming Service for consolidating past dialogues. This is a great way to understand how to turn a one-off assistant into a system that knows the context of your past decisions.

Stop Taking It on Faith

Workshop eval-driven-agent-development is probably what 90% of LLM-based projects are missing. Instead of changing the prompt and hoping it got better (I call this "vibe-based development"), they propose building an evaluation pipeline. You run the agent through six iterations (from a naive implementation to a complex system with a QA cycle) and measure the result programmatically using XML metrics and through a "judge" based on another LLM.

Division of Labor

In agent-decomposition they show how to split one massive 400-line prompt (which usually breaks sooner or later) into a system of multiple agents with clear roles and skills. This is a classic decomposition approach adapted for neural networks.

Technical Stack

The primary language in the examples is TypeScript. For interfaces, they often use Streamlit (for quick dashboard assembly) or Next.js.

The main technologies that power the magic:

• Claude Managed Agents API: managing the agent lifecycle.
• MCP (Model Context Protocol): a standard for connecting AI to your local tools and databases.
• Vite + React: for frontend parts where the agent needs to interact with the DOM.

Who Will Find This Useful at Work

If you're working on internal process automation or building a product where AI needs to do more than just answer questions—it needs to perform actions (write code, dig through logs, update tickets in Linear)—these workshops will save you weeks of experimentation.

I especially recommend checking out ship-your-first-managed-agent. It covers an SRE agent scenario that needs to analyze 70,000 lines of logs in a sandbox, find a bad commit, and fix a dashboard. This is as close to real operations tasks as it gets, the kind we face every day.

Short Summary

The cwc-workshops project isn't trying to sell you Claude. It shows architectural patterns: how to decompose tasks, how to test changes, and how to give agents access to tools so they don't break anything.

If you're planning to deploy agents to production, set aside an evening and work through at least a couple of scenarios. This is much more useful than reading another "top 50 productivity prompts" article. The code examples will give you an understanding of how model interaction with the outside world works through MCP and skills.