Anthropic apps

For most of this course you've been building with the Claude API — wiring up tool use, writing conversation loops, managing your own state. Anthropic also ships a handful of applications built on top of that same API, and two of them are worth studying carefully because they're the clearest public examples of Claude running as an agent. This short module looks at Claude Code and Computer Use less as products you might use casually and more as case studies for the agent patterns you'll build in the next module.

Why these two

Claude Code and Computer Use are both built on the exact primitives you already know. They're tool-use applications. They use the MCP ecosystem. They run conversation loops that execute multiple tool calls autonomously until the task is done. What makes them interesting is that they take those primitives and push them into territory that looks much less like a chat app and much more like a peer engineer or a human desktop user.

Looking at how they integrate tools, how they manage multi-step execution, and how they interact with their environment builds intuition for designing your own agents. Every decision Anthropic made for these apps — what tools to expose, how to structure context, when to stop — is a decision you'll have to make for anything non-trivial you build.

Claude Code, in one line

Claude Code is a terminal-based coding assistant that runs Claude as an interactive agent inside your shell. You cd into a project directory, type claude, and you have a peer engineer at the prompt:

• It can read and edit files in your project.
• It can run commands in your terminal (tests, builds, linters, git operations).
• It can search documentation on the web.
• It can connect to MCP servers for anything else your workflow needs.
• It maintains project context through CLAUDE.md files that it generates and updates.

From an architecture perspective, Claude Code is a managed agent loop with a curated tool set plus MCP support. The rest of this module walks through its installation, effective workflows for using it well, and how to extend it with MCP servers for your own tooling.

Computer Use, in one line

Computer Use is a set of tools that lets Claude interact with a full desktop environment — read the screen, click, type, navigate UIs, fill out forms, browse websites. Claude is essentially given eyes and hands in a sandboxed computer, and tasks that previously required a human clicking through a UI can be handled by the model.

Where Claude Code's surface area is text — files, commands, source code — Computer Use's surface area is everything. Any application with a graphical interface, any website, any workflow that involves moving data between systems that don't have APIs. It's a more general-purpose agent substrate than Claude Code and correspondingly more open-ended.

This module covers Claude Code in depth. Computer Use is mentioned in passing so you know it exists and know where it fits on the spectrum of agent designs, but the deep dive stays with Claude Code because its workflows are where most developers starting with Claude will spend their time.

What both apps teach about agent design

Independent of their specific use cases, Claude Code and Computer Use surface four principles that apply to any agent you build:

1. Tool integration and usage. Both apps have carefully-curated toolkits. The tools are powerful enough to do real work but constrained enough that Claude doesn't get lost in them. Choosing the right set of tools is most of agent design — too few and the agent can't complete tasks, too many and the model spends its capacity deciding which one to use.

2. Multi-step task execution. Real work isn't one tool call. It's "read this file, then plan a change, then write the change, then run the tests, then fix what broke, then commit." Both apps run conversation loops that chain tool calls across many turns without asking the user for permission on each step. The loop is agentic, not reactive.

3. Environmental interaction. Both apps make their environment available to Claude in a structured way. Claude Code gives Claude a filesystem, a terminal, and a web fetch tool. Computer Use gives Claude a screen, a keyboard, and a mouse. The environment is part of the agent's design, and the quality of that environment shapes what the agent can actually accomplish.

4. Autonomous problem-solving. Neither app babysits Claude step by step. You describe a task, and the agent plans, executes, self-corrects, and reports back. This only works because the tool loop, the stop conditions, and the error handling are all designed to keep Claude productive across many sequential decisions. When it doesn't work — which is sometimes — the failure mode is usually visible in one of those three areas.

The plan for this module

The rest of Module 10 walks through Claude Code concretely:

• Setup — installing Node.js, installing the CLI, authenticating with Anthropic, and getting to a working prompt.
• In action — the /init command, CLAUDE.md context files, the context-plan-implement workflow, and the test-driven variant. How to actually use Claude Code well.
• MCP enhancements — extending Claude Code with MCP servers for Sentry, Playwright, Jira, Figma, and anything else. The module-9 ecosystem idea made concrete.

Module 11 then picks up the agents thread and builds your own custom agents from scratch, drawing on everything you'll have seen in Claude Code's design. Treat this module as a reference implementation — a working example of what the next module teaches you to build.