The Complete Claude Handbook
From Mindset to Building a Business

▶ The 21-Day Roadmap: Zero to First Result

Before you drown in the sea of features, look at this map. You don't need to read the whole handbook at once; just take one small step each day. This path is designed for two types of reader, and wherever they diverge, we show it.

Persona 1: General user / non-technical freelancer Persona 2: Developer / builder

Week 1 — Familiarity and a First Foothold

Week 2 — Skill and Automation

Week 3 — Value Creation and Income

0 Mindset: From "Prompt Writing" to "Delegating an Outcome"

Before learning any button or tool, you need a mental shift. The people who get the most out of Claude aren't the ones who write the best sentences; they're the ones who delegate the right tasks. This chapter is the philosophical lens through which you'll read the rest of the handbook.

0.1 Three Generations of the Human–AI Relationship

To understand what Claude has made possible, look at this evolution:

• First generation — Search: You asked a question, the machine returned links. You did the work yourself.
• Second generation — Chat: You asked a question, the machine gave an answer. You still did the work, just faster.
• Third generation — Agent: You describe an outcome, and the machine does the work — creates files, calls tools, takes several steps on its own, and delivers the result.

Claude works across all three, but its real power is in the third. Anthropic itself describes the shift this way: older tools were built "around the prompt," but the new design is built "around the outcome." This means you need to learn to think like a manager, not an operator.

0.2 The Key Metaphor: "Give the Agent a Computer"

The single most important design principle across the entire Claude ecosystem is this phrase: give the agent a computer. What does a human knowledge worker use? A file system (to read and write files), a terminal (to run commands), a browser (to search), and the ability to write and run code. When you give Claude these same things, it can do almost any digital task — just like a human.

This explains why tools like Claude Code and Cowork are so powerful: they aren't merely "intelligence," they're "intelligence + a computer." Once you put on this lens, you find a golden question you can use to evaluate any task:

0.3 The Delegation Spectrum: Where Does Your Task Sit?

Every task can be placed on a spectrum from "low autonomy" to "high autonomy." Choosing the right level is the key to success. This spectrum is the backbone of this entire handbook:

0.4 The Simplicity Principle: The Simplest Thing That Works

A common temptation is to reach for the most complex solution (a clever multi-agent system). But Anthropic's own research says the most successful implementations didn't use complex frameworks; they were built with simple, composable patterns. Agency has a cost: it's slower, more expensive, and less predictable. Only accept that cost when the task genuinely requires flexibility and dynamic reasoning. Many tasks are better solved with a simple workflow than a complex agent.

0.5 Human in the Loop: Trust, but Supervise

The more autonomy you give an agent, the more important supervision becomes. A practical, memorable test:

This isn't just caution; it's a commercial advantage. In the business chapter we'll see that this very "human in the loop" is what reassures clients and justifies a higher fee.

0.6 From Prompt Writing to "Context Engineering"

The real skill isn't writing one magic sentence; it's context engineering: finding the smallest set of high-signal tokens that maximizes the likelihood of the desired outcome. That means giving Claude exactly what it needs for the task — no less (or it gets confused), no more (or it gets lost in the noise). All the tools you'll see ahead — Projects, Skills, Memory, CLAUDE.md — are in fact context-engineering tools.

1 Anatomy of the Ecosystem: Four Surfaces, Two Glues

Claude is no longer a "chatbot"; it's a work operating system. To avoid getting lost, here's the whole thing on one simple map: four "surfaces" that do the work, and two "glues" that connect everything to each other and to the outside world.

1.1 The Four Work Surfaces

These four surfaces aren't a hierarchy where one is "better" than another; they're four gateways to a single engine. The interesting part is that they're all built on a shared core: the same "agentic machine" behind Claude Code also runs under Cowork and the Agent SDK. That's why the skills you learn on one surface (like writing a Skill or connecting MCP) carry over almost identically to the others.

1.2 The Two Universal Glues

Here is the heart of a deep understanding of the ecosystem. Two open standards live in all four surfaces and are the main reason Claude is so powerful in combination:

• MCP Model Context Protocol — the standard that connects Claude to external tools and data (Gmail, Drive, Slack, GitHub, databases, and any service you like). It's called "USB-C for AI": a standard port that everything plugs into.
• Skills Agent Skills — packages of instructions and knowledge that teach Claude to do a task "your way." Like an "onboarding guide for a new employee."

We explore these two in the next two chapters (before any other surface), because without understanding them you'll never grasp the power of combining features. And Claude's real power is precisely in combination.

1.3 The Power Equation = Combination

One feature alone is useful; but combining several multiplies the power. A few examples that unfold throughout the handbook:

Projects + Skills + MCP = a "specialist colleague" Cowork + Routines + Live Artifacts = an "always-awake assistant" Agent SDK + MCP + Subagents = a "product agent team" Claude Code + GitHub + Routines = an "automated maintenance engineer"

2 MCP — The Ecosystem's Nervous System

If Claude is the "brain," MCP is the "nervous system" that connects it to hands, eyes, and external memory. Understanding MCP is the difference between someone who sees Claude as a "smart chatbot" and someone who sees it as an "automation platform."

2.1 What Exactly Is MCP?

In plain terms: MCP (Model Context Protocol) is a "common language" that lets Claude talk to any external tool or data source. Anthropic released it as an open standard in November 2024, and now the whole industry (including competitors) has adopted it.

Why does "open standard" matter? Before MCP, every connection between an AI and a service was a custom, separate job — like the era when every device had its own charging cable. MCP is the "USB-C": one standard port that Gmail, Slack, your database, and everything else plug into, without reinventing the wheel.

2.2 Architecture: Server and Client

MCP has two sides:

• MCP client: Claude itself (in the app, Code, SDK, or API). The side that wants to connect to a tool.
• MCP server: a small program that "exposes" a service to Claude. For example, the "GitHub MCP server" offers a set of tools (create an issue, read a PR, etc.).

Servers come in two kinds:

• Remote servers: hosted on the internet and connected via OAuth (like connecting to Notion or Linear). These are the "Connectors" in the app.
• Local servers: run on your own machine (e.g., access to an internal database or local file system). On the desktop app they install via one-click extensions.

2.3 What Does Claude Connect to via MCP?

The MCP server ecosystem is large. Common examples:

GmailGoogle CalendarGoogle Drive SlackGitHubJira NotionAsanaLinear FigmaDatabases (Postgres, etc.) Local file systemYour custom server

2.4 Use Cases at Three Levels

2.5 Building a Simple MCP Server

Building a server is easier than you think. Here's a conceptual example in Python:

# An MCP server exposing a "gold price" tool
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("gold-tools")

@mcp.tool()
def get_gold_price(karat: int) -> dict:
    """Return the live gold price for a given karat."""
    price = fetch_from_internal_api(karat)   # your own logic
    return {"karat": karat, "price": price}

if __name__ == "__main__":
    mcp.run()

That's it. Now you introduce this server to Claude (in the desktop app, Code, or SDK) and Claude can call the "gold price" tool whenever needed.

2.6 Why Is MCP the Main "Glue"?

Because it lives on all four surfaces with the same pattern:

3 Skills & Plugins — Reusable Skill Memory

If MCP tells Claude "what to connect to," Skills tell it "how to do the work your way." This is what turns Claude from a generic assistant into your customized specialist.

3.1 What Is a Skill?

In plain terms: A Skill is a folder containing an instruction file (called SKILL.md) and — if needed — a few helper files like scripts, templates, or samples. Anthropic likens it to an "onboarding guide for a new hire": you write down the right way to do a task once, and from then on Claude applies that method whenever relevant.

The key intelligence is that Claude doesn't read all Skills at once (which would clutter the context); it only sees each one's title and short description, and when a relevant task comes up, it "opens" that specific Skill. This is exactly the "context engineering" we discussed in the philosophy chapter.

3.2 The Structure of a Skill

# SKILL.md — the heart of a skill
---
name: invoice-builder
description: Build a formal invoice using our company's template and rules.
  Activate when the user wants to create an invoice or bill.
---

# Invoice-building instructions
1. Always use the company template in template.html.
2. Compute and show the 9% VAT separately.
3. Format amounts with thousands separators.
4. Build the invoice number following the pattern INV-YYYY-NNNN.

The description line is critical: that one sentence determines when Claude activates the Skill. Writing it well is the line between a great Skill and a useless one.

3.3 Skill Creator — Building a Skill with Claude's Help

You don't have to write a Skill by hand. An official skill called Skill Creator runs the whole loop for you: it drafts the SKILL.md, checks with dozens of test queries whether it activates correctly, compares "with-skill" vs "without-skill" results, and optimizes the description so it triggers at exactly the right moment. In other words, you use the tool to build the tool.

3.4 Ready-Made Skills

Some skills are pre-built and activate automatically — like creating professional-quality PowerPoint, Excel, Word, and PDF files. When you say "make a 10-slide presentation," Claude uses the pptx skill behind the scenes.

3.5 Plugins — Packaging a Whole Job

In plain terms: if a Skill is "one instruction set," a Plugin is a "complete toolkit for a job": several Skills + several Connectors (MCP) + several subagents + slash commands, all in one installable package. Anthropic has published ready-made Plugins for sales, finance, legal, marketing, HR, engineering, design, and operations.

Organizations (on Team/Enterprise plans) can build a "private marketplace" to distribute their internal Plugins among employees. This is one of the monetization paths we open up in Chapter 12.

3.6 The Differences at a Glance

3.7 The Golden Combination: Projects + Skills + MCP

Now that you know all three, see the first powerful combination — building a "specialist colleague":

4 Claude.ai — Web, Mobile, and Desktop

This is the gateway most people enter through: a simple chat window, with layer upon layer of deep capability behind it. We explore this chapter piece by piece, and at the end of each part we show its combinations.

4.1 Chat and Multimodal Capabilities

In plain terms: the core of the app is conversation; but Claude doesn't just understand text. It can see images (Vision), read files (PDF, Word, Excel, image, CSV, code), and take voice input. On paid plans the context window is up to 200,000 tokens (about a 500-page book), and larger on Enterprise.

Use cases

• Writing & rewriting: letters, reports, contracts, social posts, poems, code.
• Analysis & summary: compressing a long report, extracting key points, comparing several documents.
• Image understanding: reading a table from a photo, explaining a chart, extracting text from a screenshot, analyzing a design.
• Translation & teaching: fluent translation, explaining a complex concept simply, acting as a private tutor.

4.2 Artifacts — Live, Usable Outputs

In plain terms: when Claude creates something worth keeping — code, a document, a chart, a small web page, a diagram — it shows it in a separate panel called an Artifact that you can view, edit, and reuse. Since launch, hundreds of millions of Artifacts have been created.

Artifacts have gone beyond a "preview" and become a micro-app platform: they can persist data, and even make Claude calls themselves (i.e., you build a small app with AI working inside it). An interesting economic note: when you share an Artifact with someone, their usage counts against their own subscription, not yours — so sharing is free for the creator.

Use cases

• Interactive tools: calculator, unit converter, quiz, checklist.
• Documents and reports: editable text, tables, letters.
• Visuals: charts, flow diagrams, flowcharts, SVG.
• Prototypes: a landing page, a form, a UI component.

4.3 Live Artifacts — Always-Alive Dashboards

In plain terms: an ordinary Artifact is a static snapshot of one moment. A Live Artifact (in Cowork) is a live dashboard that connects to your apps (via MCP) and refreshes with fresh data each time you open it. It also has version history so you can roll back.

Use cases

• A morning dashboard: today's tasks from Linear + important Slack messages + calendar events, all in one place.
• A competitor tracker: competitors' prices and news, auto-refreshed.
• A sales-pipeline view from a CRM.
• A content calendar pulling from several data sources.

4.4 Projects — A Dedicated Workspace

In plain terms: a Project is a "separate workroom" for one topic that holds four things: a persistent instruction (the Project system prompt), a knowledge base (reference files), conversation history, and an Artifact library. In addition, each Project's memory is separate from the rest.

Why does it matter? Without Projects, everything blends together; the context of project "A" leaks into the conversation of project "B." For a lawyer or consultant, that's a confidentiality problem. A Project keeps each topic within its own walls. It also prevents the "cold start": you don't have to re-supply documents and context each time.

Use cases

• One Project per client, per case, per product, per thesis.
• A "write in my style" Project with a few samples of your previous writing as knowledge.
• A "product support" Project with technical docs as knowledge.

4.5 Memory — Cross-Conversation Memory

In plain terms: Claude can remember important facts about you and your work from previous conversations — your profession, your language, your tools, your ongoing projects — so you don't have to repeat everything each time. This capability is available to everyone (even the free plan).

A distinguishing feature of Claude is that it tells you when it uses a memory ("Based on what you told me about your React project last week..."). You have full control: in settings you can see what has been remembered, edit or delete it, or directly say "remember this."

4.6 Web Search and Deep Research

In plain terms: Claude can search the web in real time to give fresh, cited information. But Deep Research mode is a different phenomenon: instead of one search, it launches a research team.

Behind the scenes, a "lead" agent plans and dispatches 3–5 (and on complex tasks 10+) specialized subagents in parallel; each runs several tools at once and returns findings; and at the end a dedicated agent attributes every claim to its source. That very parallelization cuts the time of complex research by up to about 90%.

Use cases

• Market research and competitor analysis before a big decision.
• Reviewing the background of a scientific or legal topic.
• A comprehensive, cited report to present to stakeholders.

4.7 Other App Features

• Styles: tune Claude's tone and writing format to your preferred style.
• Chat Search: search through past conversations (on paid plans).
• Incognito: a confidential conversation that isn't stored and isn't used for training.
• Inline charts and diagrams: build charts and diagrams right inside the chat.

4.8 This Chapter's Combination Map

5 Cowork — Your Desktop Collaborator

Cowork is the most important 2026 development for non-technical users: all the agentic power of Claude Code — which upended the programming world — is now available for knowledge and office work in a desktop app with a simple interface. As Anthropic puts it: "Most AI tools are built around the prompt; Cowork is built around the outcome."

5.1 How Is Cowork Different from Chat?

In chat, Claude talks; in Cowork, Claude works. With your explicit permission, it accesses a specific folder on your computer, reads, creates, and edits files, takes several steps in a row, coordinates parallel subagents, and even schedules tasks. It runs in an isolated virtual machine and draws its power from the advanced Opus model.

Cowork came out of preview and became generally available on macOS and Windows in April 2026, and is available on all paid plans (Pro and up).

5.2 Key Features

• Folder access (with permission): only the folder you specify, with a defined access level.
• Scheduled tasks: run a task on a recurring basis with the /schedule command (e.g., every Monday morning).
• Parallel subagents: for big jobs, several agents work simultaneously.
• Skills, Plugins, and Connectors: all available here too.
• Global and folder instructions: persistent rules for all tasks or one specific folder.
• Dispatch (mobile thread): assign tasks to Cowork from your phone, even when you're away from the computer.
• Live Artifacts: the live dashboards we saw in the previous chapter are built and maintained here.

5.3 Use Cases at Three Levels

5.4 Combining with Other Features

5.5 Security — Take This Section Seriously

6 Claude Design and Other Surfaces

Claude has come to the places you already work: the browser, Excel, Word, and a dedicated design environment. This chapter covers those surfaces.

6.1 Claude Design — Conversational Design

In plain terms: an environment with a design canvas where Claude (with the Opus vision model) creates visual content and you iterate and refine it through chat. It can build prototypes, slides, websites, and marketing assets.

A powerful capability: by analyzing your existing files, it can detect and reproduce your brand design system — so outputs match your visual identity. It exports in various formats and integrates with Canva and Figma.

Use cases

• Building a presentation deck with your company brand in minutes.
• Designing a landing page for a campaign.
• Producing a set of social-media posts in a consistent style.
• Building a design system (colors, fonts, components) from existing samples.

6.2 Claude in Chrome — The Browser Agent

In plain terms: a browser extension (beta, on paid plans, for Chrome and Edge) that reads, clicks, and navigates pages in a side panel, manages tab groups, and has built-in knowledge of Gmail/Calendar/Docs/GitHub/Slack. It can record a browser workflow and schedule recurring browser tasks, and for debugging it can read console errors and network requests.

6.3 Claude in Excel, Word, and Microsoft 365

• Claude in Excel: understands the whole workbook, cell-level citations, and preserves formulas across multi-sheet dependencies. Great for formula writing, analysis, and data cleaning.
• Claude for Word: help with writing and editing directly inside Word.
• Claude for Microsoft 365 / Outlook: help managing and composing email and office work.

The Excel and PowerPoint add-ins now share conversation context with each other and support Skills — meaning you can analyze data in Excel and immediately turn it into slides.

6.4 An Overview of the Work Surfaces

7 Claude Code — Agentic Software Engineering

Claude Code is the tool that changed the pattern of working with AI in programming. It's not just a "code assistant"; it's a collaborating engineer that lives in your terminal, IDE, desktop, and web, understands the whole codebase, and carries work through to the end.

7.1 Why the Terminal?

Instead of copying code out of a chat window, Claude Code works right where you work. You tell it what you want; it plans, writes code, runs tests, reads errors, fixes them, and makes commits. Its loop is: read files → run tests → read errors → search → edit → re-run.

7.2 Install and Get Started

# macOS / Linux — official script
curl -fsSL https://claude.ai/install.sh | bash

# or with Homebrew
brew install --cask claude-code

# then in your project folder:
cd your-project
claude

7.3 The Unix Philosophy: Composable and Scriptable

Claude Code can be piped like any command-line tool and placed in scripts and CI. The -p flag means "do this task and output the result" (no interactive conversation) — which makes automation possible:

# analyze logs and alert
tail -200 app.log | claude -p "summarize any anomalies you see"

# security review of changed files
git diff main --name-only | claude -p "review these files for security issues"

# automate translation in CI
claude -p "translate new strings to French and open a PR"

7.4 The Seven Extensibility Systems

Claude Code's real power is in these seven systems, which you can combine:

• CLAUDE.md: the project's "constitution" — rules, style, and context that's read every session and survives compaction.
• Plan mode: shows you a plan first so you can approve it (often a strong model plans and a fast model executes).
• Subagents: each subagent has its own context window; up to 10 can work in parallel.
• Agent Teams: subagents that share a task list and message each other — "Skills are knowledge, Subagents are workers, and Agent Teams are workers that talk to each other."
• Skills and Plugins: the same concepts from Chapter 3.
• Hooks: code that runs before/after each tool call — the ideal place for guardrails (e.g., vetoing rm -rf or scanning for secrets).
• MCP: connecting to Drive, Jira, Figma, Slack, and your internal tools.

7.5 Routines — Cloud Automation

In plain terms: a saved configuration (prompt + repos + connections) that runs on Anthropic's cloud — your laptop can be closed. It has three triggers you can combine:

• Schedule: hourly/daily/weekly or cron (minimum 1-hour interval).
• API: fired by an HTTP request.
• GitHub events: on opening a PR, push, issue, release, etc.

Use cases

• Automatic PR reviews every morning.
• Analyzing CI failures nightly.
• Weekly dependency audit and building a security report.
• Syncing documentation after every PR merge.

7.6 CI/CD and GitHub Integration

The official GitHub Action responds to @claude mentions, issue assignments, and automation prompts, and emits structured output. It's set up with /install-github-app and works on the Anthropic API, Bedrock, Vertex, and Foundry.

7.7 Three-Level Examples

claude
> What does this project do? Explain its overall architecture.
> Where do I start if I want to add feature X?

> Users say they sometimes get a 500 error at checkout.
  Find the cause, fix it, write a test for it,
  and commit with a clear message.

8 Agent SDK and Managed Agents — Building Your Own Agent

Here you go from "user" to "builder." The Agent SDK gives you the very engine behind Claude Code so you can build your own custom agents with Python or TypeScript — for a product, for a business, or for complex internal automation.

8.1 What Is the Agent SDK?

In plain terms: a library (pip install claude-agent-sdk for Python or npm for TypeScript) that programmatically gives you the same agent loop, tools, and context management as Claude Code. It used to be called "Claude Code SDK," and since people were building beyond code (email assistants, research, finance, support) with it, it was renamed to Agent SDK.

Recall the philosophy chapter: give the agent a computer. That's exactly what it does.

8.2 Built-in, Ready-Made Tools

Without writing a single line, your agent has these:

ReadWriteEdit BashGlobGrep WebSearchWebFetch AskUserQuestionAgent (subagent) NotebookEditTodoWrite

Plus: automatic context management (compaction), prompt caching, session management, hooks, fine-grained permissions, and MCP connections.

8.3 Two Interfaces

• query() — one-shot and stateless; for scripts and automation.
• ClaudeSDKClient — stateful and multi-turn; for interactive apps and chatbots, with interrupts, custom tools, and hooks.

8.4 Three-Level Examples

import asyncio
from claude_agent_sdk import query

async def main():
    async for msg in query(prompt="find files larger than 1MB in this folder"):
        print(msg)

asyncio.run(main())

from claude_agent_sdk import query, ClaudeAgentOptions

opts = ClaudeAgentOptions(
    setting_sources=["project"],          # read CLAUDE.md
    allowed_tools=["Read","Edit","Bash","Grep"],
    permission_mode="acceptEdits",
)
async for msg in query(prompt="find and fix the login bug and run the tests", options=opts):
    print(msg)

from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions

opts = ClaudeAgentOptions(
    system_prompt="You are an SRE engineer who triages production incidents.",
    mcp_servers={"linear": {"url": "https://mcp.example.com/linear"}},
)
async with ClaudeSDKClient(options=opts) as c:
    await c.query("check the payment service logs and find the outage cause")
    async for m in c.receive_response(): handle(m)
    await c.query("now create a Linear ticket with the findings")  # context retained

8.5 Managed Agents — When You Don't Want to Build Infrastructure

In plain terms: instead of building the server and secure environment to run an agent yourself, Anthropic does it. You define an Agent (model + prompt + tools), an Environment (an isolated sandbox), and a Session (one run), and call it via REST. Sessions are long-lived and survive disconnections.

Its advanced capabilities: Orchestration (a lead agent coordinates up to ~20 subagents on a shared file system), Outcomes (you write a quality rubric and a separate grader iterates and improves the result), and built-in memory.

8.6 The Monthly Agent SDK Credit (from June 15, 2026)

8.7 What Agents Can You Build?

SRE / incident-commander agentsecurity review bot oncall assistantcode reviewer legal assistantfinance agent personal assistantcustomer support research agentvideo creationnote-taking

9 The Claude API — The Programming Core

The API is the most fundamental and flexible gateway: you send a message, Claude responds. Any app, bot, or service you can imagine is built on this interface. The Agent SDK itself is built on this very API.

9.1 The Messages API — First Call

# Python
import anthropic
client = anthropic.Anthropic()

msg = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role":"user","content":"write a slogan for a jewelry store"}],
)
print(msg.content[0].text)

9.2 Models and Token Economics

Claude is a family. Choosing the right model for each task is the key to both quality and cost.

9.3 Tool Use — The Basis of Every Agent

In plain terms: you tell Claude what tools you have. When needed, it says "call this tool with this input"; you run it and return the result. Two kinds of tools:

• Client tools: your own app runs them (e.g., "get a price from an internal system").
• Server tools: Anthropic runs them (next section).

Advanced capabilities: parallel tool calls, tool search (discovering a tool among hundreds without loading them all), and programmatic tool calling.

9.4 Server-Side Tools (Anthropic-Hosted)

You don't have to build these yourself:

• Web Search / Web Fetch: searching and reading web pages.
• Code Execution: running Python/Bash in a secure environment — for data analysis, computation, and file creation.
• Memory tool: persistent memory across calls (client-side files).
• Bash & Text Editor: running commands and editing files (trained-in, so more reliable).
• Computer Use: seeing the screen and controlling mouse/keyboard to automate any GUI.

These tools are designed to combine: search + code execution (research), text editor + bash (the coding loop), and Memory alongside everything.

9.5 Cost-Reduction and Control Capabilities

• Prompt Caching: caching repeated context — reads from cache up to about 90% cheaper.
• Batch API: non-urgent jobs at 50% off (delivered within 24 hours). Stacked with caching, up to about 95% savings.
• Streaming: receiving the response live.
• Structured Outputs: forcing output into precise JSON for programmatic use.
• Compaction / Context editing: managing the context window in very long conversations.
• Token counting: counting tokens before sending to control budget.

9.6 Three-Level Examples

system = "Return only JSON, with no explanation."
prompt = "From this invoice: extract the number, date, total, and buyer."
# clean JSON output, ready to store in a database

10 Chains and Workflow Patterns

A single call is powerful, but real work is multi-step. A "chain" means linking steps so each step's output is the next one's input. Anthropic has introduced five simple, composable patterns as a roadmap — these five are the alphabet for building any intelligent system.

10.0 Workflow vs Agent

• Workflow: the model and tools pass through predefined code paths — like a recipe. Predictable, cheap, controllable.
• Agent: the model itself dynamically chooses the path and tools. Flexible but more expensive and less predictable.

The basic building block of both is the "augmented LLM": model + retrieval + tools + memory. And remember (from the philosophy chapter): choose the simplest thing that works.

10.1 Prompt Chaining

What it is: you break the task into sequential steps; each model's output becomes the next model's input. You can place a "gate" (quality check) between steps.

When: low-complexity tasks with clear steps.

Example: writing a document ← step 1: an outline ← gate: does the outline meet the criteria? ← step 2: write the full text ← step 3: edit the tone. (Translation is the same: translate ← review ← revise.)

10.2 Routing

What it is: first you classify the input, then route it to a specialized path/prompt.

When: inputs have distinct categories.

Example: in support, a lightweight model classifies the question as "technical/billing/general"; simple ones go to Haiku and complex ones to Opus. Quality goes up and cost comes down — this is the single most important cost-saving pattern.

10.3 Parallelization

What it is: several models work at once and outputs are combined. Two modes: sectioning (splitting work into independent subtasks) and voting (running multiple times for more confidence).

When: speed matters or you want multiple perspectives.

Example: for a code review, send three agents at once — security, performance, readability — and merge the reports.

10.4 Orchestrator-Workers

What it is: an "orchestrator" model dynamically breaks the work down and delegates to "workers," then gathers the results. Unlike simple parallelization, the subtasks aren't known in advance.

When: tasks of unpredictable complexity, like multi-file changes or open-ended research.

Example: the same Deep Research system we saw in Chapter 4; or coding agents that resolve an issue across several files. This is the Subagents mechanism.

10.5 Evaluator-Optimizer

What it is: one model produces output and another critiques it; this feedback loop repeats until quality reaches the desired level.

When: when the quality criterion is clear and iteration genuinely improves the result (literary translation, code that must pass tests).

Example: "write this article" (generator) ← "weigh each claim against the evidence and list the weaknesses" (evaluator) ← rewrite ← repeat until approved. (In Managed Agents this is the Outcomes capability.)

10.6 Mapping the Patterns to Claude Tools

11 Discovering Use Cases — How to Find What's Possible in Any Job

This chapter is the heart of the matter: not a list of ready-made use cases, but a method of discovery so that for any job and any situation you can figure out for yourself what's possible. First the method, then examples across dozens of domains.

11.1 The Three-Question Discovery Method

Whenever you face a task, ask these three questions:

1. Is this task "digital and describable"? If you can describe it step by step and it's done on a computer, it's a good candidate. (Recall the golden "smart intern" question from Chapter 0.)
2. How often does it recur? The more recurring, the more valuable to automate. A one-off task = chat. A daily task = Skill/Cowork. An automated, scheduled task = Routine/Agent.
3. What's the risk of error? High risk = more human oversight and less access. Low risk = more autonomy.

The answers to these three simultaneously tell you whether Claude helps and which tool/rung fits.

11.2 The Universal Pattern of Work: Six Basic Verbs

Almost every knowledge task is a combination of these six verbs. When you break your task into these verbs, you immediately see where Claude helps:

11.3 Discovery by Role and Domain

Now we apply the method to various domains. Read each through the "delegation spectrum" lens.

Office & administrative work

• Simple: writing and summarizing email, preparing minutes, rewriting text.
• Medium: building a monthly report from several Excel files, standardizing dozens of documents (Cowork + Skill).
• Advanced: a live KPI dashboard connected to Slack/Drive/Calendar that auto-refreshes (Live Artifact + MCP + Routine).

Software engineering

• Simple: explaining code, fixing a bug, writing a function.
• Medium: refactoring, writing a test suite, migrating a library (Claude Code + CLAUDE.md).
• Advanced: an SRE agent or automated security review in CI (Agent SDK / Routines).

Sales & marketing

• Simple: writing a cold email, generating several ad versions, summarizing a call.
• Medium: producing a content campaign in your brand style (Claude Design), analyzing the sales funnel from a CRM.
• Advanced: a lead-qualification agent that works with the CRM and hands hot leads to a salesperson.

Legal

• Simple: summarizing a contract, finding a clause, explaining a legal term.
• Medium: reviewing a contract per company policy (Project + Skill + knowledge).
• Advanced: a contract-review agent that pulls versions from Drive and flags differences.

Finance & accounting

• Simple: analyzing a financial statement, explaining a financial ratio.
• Medium: extracting data from a bulk of invoices into Excel (Batch API for cheapness).
• Advanced: a reconciliation or fraud-detection agent that produces a daily report.

Research & data analysis

• Simple: summarizing a paper, explaining a method.
• Medium: analyzing a dataset and producing charts (Code Execution / Artifacts).
• Advanced: a multi-agent research team for a comprehensive review of a field (Deep Research / Orchestration).

Education

• Simple: explaining a concept at different levels, creating practice questions.
• Medium: building an interactive learning tool (Artifact), designing a course.
• Advanced: an adaptive private tutor that tracks the student's level (Memory + Project).

Health & medicine (with caution)

• Simple: explaining a medical concept in plain terms, summarizing a paper.
• Medium: organizing clinical documentation, producing a draft note (with specialist review).
• Advanced: an agent assisting administrative healthcare processes (like prior authorization) in a compliant environment (Enterprise/HIPAA).

Operations & HR

• Simple: writing a job description, summarizing résumés.
• Medium: organizing the hiring process, building an onboarding guide (Plugin).
• Advanced: an initial-screening agent that works with the ATS and produces a structured report.

11.4 A Discovery Exercise: Break Down Your Own Work

12 Making Money & Building a Business

Claude doesn't just raise your productivity; it can be the foundation of a business. This chapter is full of revenue models, real stories, and the economics behind each — so you can see where the money actually gets made.

12.1 A Map of Revenue Models

12.2 Real Stories

12.2.1 Micro-Stories — A Scale Possible Starting Today

The stories above are inspiring but can create a "scale illusion." Everyday reality is smaller but fully within reach. These narratives are hypothetical but illustrate a realistic pattern:

12.2.2 Contract and Service-Level Agreement (SLA) Template

If you build an agent or automation for a client, a clear agreement prevents future trouble. Here is a simple skeleton (a fuller template is in the "Ready-Made Templates" chapter):

• Scope of work: exactly what gets automated and what is out of scope.
• Quality level: what the success criterion is (e.g., "90% of cases handled correctly without human intervention").
• Human in the loop: which decisions always require human approval.
• Usage cap: the API spending cap and what happens when it's exceeded (this clause saves you from financial disaster).
• Liability: explicitly state the output must be reviewed by the client and the final decision is theirs.
• Maintenance: what the monthly retainer covers (updates, bug fixes, monitoring).

12.3 Practical Steps to Start

1. Find a real, recurring pain of a business (not a generic idea).
2. Solve it manually with the Claude app first to prove it has value.
3. Automate it with the simplest pattern (a workflow, not a complex agent).
4. Measure the cost per transaction and set the price above it.
5. Monitor quality and safety; provide a path for human escalation.
6. Scale gradually: from freelance to product, from one client to several.

12.4 Margin Economics — Where a Business Lives or Dies

Revenue without cost control is an illusion. Three main levers:

• Model routing: a mix of, say, 60% Haiku / 35% Sonnet / 5% Opus can be about 37% cheaper than "all Sonnet." Send the simple task to the cheap model.
• Caching + Batch: prompt caching (90%) and Batch (50%) stack to about 95% savings.
• Usage caps: always set a cap. One real abandoned multi-agent loop ran for 11 days and racked up about a $47,000 bill. In fixed-price contracts, be sure to specify a usage cap.

12.5 Plans and Pricing (Quick Reference)

⚠ Real Failures and Mistakes — Learning from Error

Claude is not a wizard. It makes mistakes, sometimes with complete confidence. This chapter deliberately focuses on errors, because learning from mistakes is stronger than learning from success. Each item shows the error and then how to detect and fix it.

✦ Claude for the Non-Native / Constrained User

This chapter addresses the real challenges of users who work in a non-English language or under access constraints — kept general and without naming any specific service. The goal is realism, not circumventing any restriction.

The access and payment challenge

Users in some regions face geographic restrictions and difficulty with foreign-currency payment. Rather than a specific solution, a few general principles:

• A foreign-currency subscription may be costly for many; before any financial commitment, see how much of your need the free plan covers — for many everyday tasks it's enough.
• If your work has a specific, predictable volume, the pay-as-you-go model (API) may be more economical than a fixed subscription; estimate cost based on your actual token volume.
• Before any decision, review your regional laws as well as the service's terms of use.

The right-to-left (RTL) text challenge

One of the most troublesome practical issues for users of RTL languages is text-direction breakage — especially when the language and English/numerals are mixed, or in code and Artifact output. A few approaches:

• In HTML/document output, explicitly ask for dir="rtl" and a suitable font to be set.
• For mixed RTL-English text, ask Claude to handle directional separators correctly or to put English numbers/code in a separate container.
• If text breaks in another tool (like Word), you can ask Claude to produce a cleaned-up version compatible with that tool.

The language-quality challenge

As we said in the failures chapter, sometimes the generated non-English text is fluent but shallow. For serious work in your language, provide a tone sample, proceed section by section, and take the final human review seriously.

Connecting to local services

Technically, MCP is an open standard, and you can write an MCP server for local services (payment gateways, content-management systems, internal software) — provided that service offers a programming interface (API). In other words, the constraint isn't technical; it merely depends on the existence of an API and on complying with the law.

§ Ethics and Responsibility

With more power comes more responsibility. This chapter is short but important, because ignoring it can be costly — both ethically and legally.

Copyright and ownership of output

You can use Claude's output, but a few notes: generated content may inadvertently resemble existing works; the responsibility to check originality and potential copyright infringement is yours. For commercial work and wide publication, run originality checks and read the service's terms about ownership of output.

Legal liability

If Claude produces a wrong contract, an incorrect financial recommendation, or faulty code, the ultimate responsibility lies with whoever uses it, not the tool. In sensitive domains (legal, medical, financial), the output must always be reviewed by a responsible professional. Claude is not a substitute for expert advice.

Bias

Language models are trained on human data and can reflect that data's biases — in analyses, recommendations, or judgments. In important decisions (hiring, credit assessment, evaluation), treat the output as a "supporting opinion," not an impartial verdict. Preserve diversity of viewpoint and human review.

Transparency and privacy

If you present AI output to others (a client, an audience), be transparent. Don't input others' sensitive data without permission; for confidential work, use Incognito mode and appropriate retention policies.

⛓ Golden Combinations, Step by Step

In earlier chapters we introduced the combinations; here we implement two important ones practically and step by step, so you know exactly where to start and what to set up first.

Combination 1: "Specialist Colleague" — Project + Skill + MCP

Goal: an assistant that performs a recurring specialized task to your standard and with access to your data.

1. Build the context: create a new Project and upload reference documents and rules as knowledge.
2. Write the persistent instruction: in the Project settings, write the role and general rules (e.g., "You are our contract reviewer and always act per this policy").
3. Build the method: create a Skill for that specialized task (with Skill Creator) and write its description precisely.
4. Connect the hands: connect the needed Connectors (storage, calendar, etc.).
5. Test: give a real example and measure the output against your standard; refine the Skill and instructions.
6. Put it to work: from now on, start every new task in this Project.

Combination 2: "Always-Awake Assistant" — Cowork + Routine + MCP + Live Artifact

Goal: a report/dashboard that is ready automatically every day, without you doing anything.

1. Grant access: in Cowork, set a low-risk folder and connect the data-source Connectors.
2. Do it manually once: build the task by hand once to make sure the output is correct (the "manual first, then automate" principle).
3. Turn it into a Live Artifact: ask Cowork to render the result as a live dashboard connected to the data sources.
4. Schedule it: with /schedule, create a Routine that refreshes it daily/weekly.
5. Set a delivery channel: ask it to send you the summary at the end of each run (email/message).
6. Supervise: review the output the first few times until you trust it (the long-weekend test).

▤ Ready-Made Templates

You can copy these templates and customize them for your own work. A practical starting point for implementing the things you read about in the handbook.

1. Sample SKILL.md

---
name: monthly-report
description: Build a monthly report from raw data per our company template.
  Activate when the user wants a monthly report, sales summary, or performance report.
---

# Monthly report instructions
1. Read the raw data from the input file and validate it.
2. Compute three key metrics: total, growth vs last month, best/worst.
3. Build a monthly bar chart.
4. Write the executive summary in at most 5 sentences.
5. Produce the output with the company's color template (brand.css).
6. Format dates and numbers with thousands separators.

2. Sample CLAUDE.md (for Claude Code)

# Project rules
- Comment language: English. Variable names: English.
- Before any big change, show your plan and get approval.
- Always write tests for new code.
- Use library X, not Y (for compatibility reasons).
- Never push directly to main; always create a new branch.
- Never hardcode secrets; read from the .env file.

# Project structure
- src/ : main code
- tests/ : tests
- docs/ : documentation

3. Sample Project Instruction

You are the specialist assistant for [role] at [project/company name].

Standing rules:
- Tone: [formal/friendly]. Language: [English].
- Always use this project's reference documents as the primary source.
- If something isn't in the sources, explicitly say "not in the sources" and don't guess.
- Prepare the final output for human review, not as a final verdict.

Quality criterion:
- [e.g., every legal claim must cite a specific statute.]

4. Automation Contract / SLA Skeleton

1. Scope of services: [exactly what gets automated]
2. Out of scope: [what is not included]
3. Success criterion (SLA): [e.g., 90% of cases without human intervention]
4. Human in the loop: [which decisions require human approval]
5. Usage cap: [monthly API cost cap and behavior when exceeded]
6. Liability: output must be reviewed by the client; the final decision is theirs.
7. Cost: [one-time build] + [monthly maintenance]
8. Maintenance includes: updates, bug fixes, monitoring, monthly report.
9. Confidentiality: how the client's data is retained and deleted.

5. Sample Routine Prompt

Every [Monday at 8 a.m.]:
1. Read the week's data from [source].
2. Reconcile it with [second source].
3. Build a summary report with a chart.
4. Flag anomalies or items needing attention.
5. Send the summary to [recipient].
6. If an error occurs, report the error instead of continuing.

▣ Cheat Sheet — The Whole Handbook at a Glance

Print this page and keep it beside you. All the key concepts, condensed.

⌨ Glossary — Jargon in Plain Language

Every technical term you saw in the handbook, explained in plain language here.

Token

The unit of text counting for AI; roughly every 0.75 English words ≈ 1 token. Cost is computed per token.

Context Window

The amount of text Claude can hold "in mind" at once. When it fills up, quality degrades.

Agent

An AI that doesn't just answer but takes several steps on its own and does the work.

MCP (Model Context Protocol)

A common standard language that connects Claude to external tools and data (email, calendar, databases, etc.).

RAG (Retrieval-Augmented Generation)

A method where, instead of relying on memory, the AI first retrieves relevant information from a source and then answers based on it.

Hooks

Code that runs automatically before or after an action; a good place to put guardrails and rules.

OAuth

The standard secure sign-in method that lets one service access another without sharing the password.

CI/CD (Continuous Integration/Delivery)

The automated process of testing and releasing code in software development; each change is automatically checked and shipped.

SRE (Site Reliability Engineering)

The engineering of system reliability; the role that makes sure services stay available and healthy.

SCIM / SSO

Enterprise standards for user management and single sign-on, so employees access all tools with one account.

Prompt Injection

An attack where malicious text (in a file or web page) gives hidden instructions to the AI to make it do something unintended.

Prompt Caching

Temporarily storing the repeated part of the input so subsequent times are processed cheaper and faster.

Batch API

Batch processing of non-urgent jobs at 50% off; results within at most 24 hours.

Subagent

A secondary agent that the main agent spawns for a specific task; it has its own context window.

Artifact

A usable output (code, document, tool) that Claude builds in a separate panel and that's editable and shareable.

Hallucination

When the AI invents information that doesn't exist but presents it confidently.

Headless mode

Running a tool without an interactive conversation, usually for automation in scripts (like the -p flag in Claude Code).

13 Conclusion, Security & Resources

We've reached the end. Let's gather everything into a simple mental toolkit you can use every day.

13.1 The Whole Handbook in Five Sentences

1. Think in terms of "delegating an outcome," not "writing a prompt"; like a manager, not an operator.
2. Place your task on the "delegation spectrum" and pick the right rung (chat ← Project ← Cowork/Code ← Agent).
3. The power is in combination: use MCP (connection) + Skills (method) + Projects/Memory (context) together.
4. Start simple; add complexity (an agent) only when needed; and always verify quality.
5. For business, sell a specific vertical with "human in the loop," and protect your margin with model routing and caching.

13.2 Security and Trust Checklist

• Never give an agent delete access to irreplaceable files; back up.
• Don't trust unknown content (file/web page); the prompt-injection risk is real.
• Require human approval for sensitive actions (send, delete, pay, change access).
• Run the "weekend test": if you're not confident leaving it unsupervised, reduce its autonomy.
• For sensitive data, use Incognito, retention policies, and in an organization, compliant options.

13.3 The Big Combination Map (at a glance)

13.4 Official Resources

• General docs and API: docs.claude.com
• Claude Code: docs.claude.com/.../claude-code
• Agent SDK: docs.claude.com/.../agent-sdk
• "Building Effective Agents" article: anthropic.com/research/building-effective-agents
• Support and app help: support.claude.com
• Up-to-date pricing: claude.com/pricing
• Skills (open standard): agentskills.io