Standalone article · part of a sequenced guide
What you'll unlock: Claude is a stateless, probabilistic reasoning engine with a finite context window — living inside a growing product ecosystem. Master those four facts and every feature click becomes intentional.
The Claude Mental Model
Before you touch the interface — the foundational understanding that separates power users from prompt typers
Chapter context
You adopted Claude because everyone else did — but your team still copies prompts from Twitter, hits mysterious refusals, picks the wrong product for the job, and wonders why 'the AI forgot' what you said Tuesday.The gap is not intelligence. It is architecture literacy. This chapter gives you the same foundation Anthropic engineers assume you have — without requiring a machine learning degree.
Is this chapter for you?
Will you use Claude at least 3 times per week for professional work in the next month?
Yes — invest 55 minutes in this chapter; it pays back on every future session.
Do you need Claude inside a product your customers use (not just internal chat)?
Yes — pay special attention to sections 1.2, 1.4, 2.2, and 2.7; you'll need API + tools, not only Claude.ai.
Does your work involve sensitive data (legal, medical, financial, unreleased product)?
Yes — read 1.5, 1.8, and 2.8 carefully; surface choice and prompt framing affect compliance.
Are multiple people on your team using different Claude products without a shared standard?
Yes — section 2.8 gives you a surface map to document as team policy.
Most people open Claude like a search box with manners. Power users open it like an instrument — they know what it can hear, what it forgets, which surface to use, and why the same prompt sometimes answers differently.This chapter is not a feature tour. It is the operating system layer for everything that follows in this playbook: interfaces, APIs, agents, office plugins, and production systems.
Chapter insight
Claude is a stateless, probabilistic reasoning engine with a finite context window — living inside a growing product ecosystem. Master those four facts and every feature click becomes intentional.
Reference diagrams
How Claude produces an answer
Not lookup — prediction. Each step samples from probable continuations until the response completes.
Anthropic Claude surfaces
Choose by who acts and where data lives — not by hype. Most organisations need 2–3 surfaces, not all eight.
Implementation paths
Start from actor and data sensitivity — not from the newest launch announcement.
Concept 1
What Claude Actually Is
Not a search engine, not a chatbot — the right mental model changes everything about how you use it
1.1
Claude as a probabilistic reasoning system
Why every response is a distribution, not a lookup — the mental shift that explains why prompting is a skill
Key takeaway
Claude does not retrieve a stored answer. It predicts the most useful continuation of text given your prompt — which means the same question can yield different (equally plausible) answers.
Why this matters
Teams that treat Claude like Google blame 'the AI' when outputs vary. Power users expect variance, design for it with structure, evals, and verification — and treat prompting as steering a distribution, not pressing a button.
Under the hood, Claude is a large language model that completes text. When you ask a question, it does not look up a row in a table. It runs billions of probability calculations to choose the next word, then the next, until the response ends. The answer you see is one sample from a very large space of plausible answers.
This is why temperature matters in the API, and why Claude.ai can feel slightly different on repeat tries. Low temperature narrows the distribution for factual or code tasks. Higher temperature widens it for brainstorming — but also increases the chance of an unlikely (wrong) completion.
Practical implication: never ship a workflow that assumes bit-identical outputs. Design for structured outputs, human review on high-stakes decisions, and regression tests that check semantic correctness — not string equality.
Workflow — do this next
- 01Run the same prompt 3 times on a critical task — note what varies vs what stays stable.
- 02If facts drift, add sources (documents, retrieval) or lower temperature in API calls.
- 03Define 'good enough' as a range (key points present) not a single golden string.
Real example
PM writing a PRD outline — variance that helps vs hurts
A PM asks Claude to draft a PRD outline for a notification preferences feature. Run 1 emphasises compliance; Run 2 emphasises engagement metrics; Run 3 emphasises engineering complexity. All are valid framings. The power-user move: ask Claude to produce three strategic angles first, pick one, then request a full outline locked to that angle — using variance as exploration, not noise.
1.2
The stateless default
Why Claude has no memory between conversations unless you build it — and why most users don't realise this until it costs them
Key takeaway
Each new chat starts cold. Claude only 'remembers' what is in the current thread's context — or what you explicitly attach via Projects, memory features, or your own database.
Why this matters
The most expensive mistake in enterprise Claude rollouts is assuming the model remembers last week's decision. Stateless design is a feature (privacy, predictability) that becomes a bug when users expect persistence without architecture.
By default, stateless inference means Claude has no enduring memory of you. Close the tab, open a new chat — the model has zero knowledge of the previous conversation unless Anthropic product features (Projects, team context) or your integration stores and resends history.
Within a single conversation, Claude can use the full context window as working memory — but long threads fill that window. Early instructions get compressed or dropped as you approach limits. Power users restart threads with a distilled 'state of play' summary rather than dragging 200-message threads.
Builders solve persistence with RAG and session stores. Claude Code solves it by reading your repo and git history. Claude.ai Projects solve it by attaching persistent knowledge files. None of these are automatic — you choose the layer.
Workflow — do this next
- 01Before a multi-day task, create a Project or doc called SESSION_STATE.md — update it at end of each session.
- 02Start new chats with: 'Read SESSION_STATE below. Confirm understanding before we continue.'
- 03For API apps, store user_id → summary in your DB; prepend summary to every request.
Real example
The lost pricing decision — an illustrative rework story
A startup ran pricing workshops in Claude over two weeks across separate chats. No Project, no shared doc. Engineering built to $29/seat because that number appeared in the most recent thread — an abandoned brainstorm, not the approved $39 tier from week one. Stateless default + human assumption of memory = shipped wrong price. Fix: one Project with PRICING_DECISIONS.md as source of truth; all chats in that Project.
1.3
Claude vs GPT vs Gemini
The architectural and character differences that matter for real use — not benchmarks, but behaviour
Key takeaway
Model choice is a product decision: Claude tends toward careful reasoning, long-context synthesis, and explicit refusals; GPT toward breadth and plugin ecosystem; Gemini toward Google workspace integration. Benchmarks rarely predict your workflow.
Why this matters
Procurement teams pick from leaderboard scores. Practitioners pick from behaviour on their actual tasks — contract review, code refactor, campaign copy. This section is the behaviour map.
Claude is often chosen for long-document analysis, nuanced writing, and cases where false confidence is dangerous. Teams report fewer 'made up with confidence' moments on compliance tasks — at the cost of sometimes refusing or over-hedging when pushed.
GPT models excel in ecosystem surface area — if your stack is already OpenAI-native (Assistants API, Azure OpenAI), switching has migration cost. Gemini's advantage is native Google Workspace, Search grounding, and Gmail/Docs adjacency.
The power-user approach in 2026: multi-model routing. Use Claude for draft-and-reason workflows; use others where integration wins. Your playbook library should document which surface owns which job.
Workflow — do this next
- 01Pick 5 real tasks from your job (e.g. summarise RFC, write SQL, critique slide deck).
- 02Run identical prompts on Claude Sonnet and one alternative; score: accuracy, tone, edit time.
- 03Document winners per task type in a team MODEL_ROUTING.md — revisit quarterly.
Real example
Legal ops team — Claude for review, GPT for templates
A 30-person legal ops team routes M&A contract review to Claude Opus (long context, citation-style answers). They route mail-merge style NDA variants to a faster GPT model with templating scripts. Neither vendor 'won' — task routing won. PM lesson: evals are per workflow, not per brand.
1.4
The context window as working memory
Why everything Claude knows in a session lives in one finite space — and why managing it is your job
Key takeaway
The context window is RAM, not disk. Everything you paste, upload, and say competes for the same limited space — and quality degrades as you approach the ceiling.
Why this matters
Users paste 80 PDFs and ask 'why is it forgetting instructions?' — because attention budgets are real. Managing context is the core skill of production-grade Claude use.
Claude's context window defines how much text it can see at once. A 200k window sounds infinite until you attach ten annual reports, three codebases, and a full chat history. Everything counts: system prompts, tool results, hidden formatting.
Performance often degrades before you hit the hard limit — the lost in the middle effect means critical instructions should live at the start or end of prompts, not buried page 47 of an upload.
Power users run a context budget: attach only relevant excerpts; summarise large docs first; use Projects for stable reference material instead of re-pasting; split multi-phase work across chats with handoff summaries.
Workflow — do this next
- 01Before each session, list what Claude must know vs nice-to-know — cut nice-to-know.
- 02Put non-negotiable rules in the first 500 words of the system prompt or opening message.
- 03At 70% of estimated context, ask Claude to summarise thread + decisions before continuing.
Real example
Consulting firm diligence — chunking that saved the deal
Analysts uploaded an entire data room (400MB) to a single chat. Claude slowed, contradicted earlier findings, missed a change-of-control clause. Re-run: index documents in a Project; per-workstream chats with only 3–5 relevant files each; executive summary chat with 2-page brief only. Time to insight dropped 40%; partner trust went up because citations mapped to specific files.
1.5
How Claude was trained
RLHF, Constitutional AI, and what that means for how it responds to you — the character behind the model
Key takeaway
Claude's 'personality' — helpful, cautious, refusal-prone on harm — is engineered through Constitutional AI and reinforcement learning from human feedback, not accident.
Why this matters
When Claude refuses or hedges, it's often doing what training optimised for. Understanding that lets you reframe prompts productively instead of fighting the model.
After initial training on text, Claude undergoes RLHF so human raters prefer helpful, honest, harmless answers. Anthropic's Constitutional AI adds a layer where Claude evaluates its own drafts against principles — shaping the careful, sometimes verbose tone users recognise.
This training creates predictable behaviours: Claude will often surface uncertainty, offer balanced views on contentious topics, and refuse requests that look like harm facilitation — even when a user only wanted a security audit example.
Legitimate reframes: specify role ('you are a red-team security consultant'), scope ('for authorised penetration test on my app'), and output format. You're not 'jailbreaking' — you're disambiguating intent within policy.
Workflow — do this next
- 01When you get a refusal, ask: was intent ambiguous? Add role, audience, and legitimate use case.
- 02For nuanced work, invite Claude to state assumptions before answering — uses its caution as a feature.
- 03Log refusals in team playbook — patterns reveal prompt templates that need fixing.
1.6
Claude's knowledge cutoff
What it knows, what it doesn't, and how to work around the gap with web search and documents
Key takeaway
Parametric knowledge freezes at training time. For anything after the cutoff — or anything private — you must attach sources, enable search, or use tools.
Why this matters
Hallucinated launch dates and invented API methods usually trace to cutoff gaps, not 'AI being dumb.' Architecture fixes this; yelling at the chat does not.
Claude's internal knowledge has a training cutoff. It will not reliably know last month's pricing change, yesterday's API deprecation, or your company's org chart unless you provide it.
Mitigations stack: web search in Claude.ai for public facts; document upload / Projects for private facts; MCP connectors for live systems (Notion, Drive, GitHub); API tool use for databases.
Power-user rule: treat Claude as reasoning engine over provided evidence, not oracle. Every factual claim in production workflows should trace to a source you attached or a tool result you logged.
Workflow — do this next
- 01For time-sensitive tasks, start prompt with: 'Use web search; cite URLs; say if uncertain.'
- 02Maintain a TEAM_FACTS.md with versioned API endpoints, pricing, headcount — attach to Project.
- 03In API pipelines, inject retrieved snippets with timestamps in metadata.
Ready-to-use artifacts
Complete templates — paste directly into your AI tool or automation workflow.
Knowledge cutoff handoff prompt
Paste at the start of research or strategy chats.
You are helping with a task that may require current information. Rules: 1. If a fact may have changed after your training cutoff, say so explicitly. 2. When web search is available, use it for: pricing, API versions, regulations, competitor features. 3. Separate "from your training" vs "from search results" vs "from attached docs". 4. If you cannot verify, recommend what the human should check. My task: [DESCRIBE TASK] Attached sources: [LIST OR NONE]
1.7
The three Claude models — Haiku, Sonnet, and Opus
What each is built for, what each costs, and when to choose which
Key takeaway
Haiku for speed and scale; Sonnet for daily professional work; Opus for hardest reasoning. Wrong model choice shows up as either wasted money or rework from shallow answers.
Why this matters
Teams default to the most expensive model for everything, or the cheapest for everything — both fail. Model routing is cost engineering and quality engineering at once.
Haiku handles triage, tagging, and simple extraction at millions of tokens. Sonnet is the default for serious professional use. Opus earns its cost when mistakes are expensive and ambiguity is high.
Routing pattern: Haiku classifies incoming request → Sonnet handles 80% of work → Opus escalates on low confidence or high stakes. Same architecture customer support teams use for ticket triage, applied to model selection.
Workflow — do this next
- 01Label last week's Claude tasks: easy / medium / hard.
- 02Map easy → Haiku, medium → Sonnet, hard → Opus for next week.
- 03Track cost per task type in a spreadsheet — adjust boundaries monthly.
Real example
SaaS support stack — 62% cost reduction with routing
A 120-person SaaS routed all API calls through Opus ($15/M input). After task labelling: 55% were simple categorisation → Haiku; 35% draft responses → Sonnet; 10% escalations → Opus. Quality held (CSAT flat); inference spend dropped 62%. PM owned the routing spec, not infra magic.
1.8
Why Claude refuses things
The values and safety training behind refusals — and the legitimate ways to get better responses when the default is wrong
Key takeaway
Refusals are often ambiguous-intent triggers, not moral judgments on your job. Clarity, professional framing, and structured scope usually unlock the work.
Why this matters
Executives interpret refusals as 'we can't use AI for this.' Power users interpret them as 'my prompt looked risky.' The second group ships.
Claude is trained to refuse assistance with clear harm: weapons, exploitation, bypassing security of systems you don't own. Gray zones — security research, medical info, legal drafts — trigger refusals when intent is unclear.
Productive moves: name the authorised context ('I'm the CISO'); specify defensive purpose; request educational framing; break task into smaller non-sensitive steps; use API with system prompt in controlled enterprise environment.
Document team-wide approved prompt patterns for security reviews, HR investigations, and medical-adjacent content — reduces random refusals and standardises quality.
Workflow — do this next
- 01On refusal, copy the exchange to REFUSAL_LOG — note task type and fix that worked.
- 02Add role + scope + output format before retrying.
- 03For enterprise, request policy docs from Anthropic on acceptable use for your industry.
Concept 2
The Anthropic Ecosystem Map
Every Claude product and how they connect — the landscape you need to understand before choosing where to work
2.1
Claude.ai
The consumer interface and what it gives you that the API does not
Key takeaway
Claude.ai is the fastest path from idea to result — Projects, artifacts, vision, and team plans without writing code. It is not the same as embedding Claude in your product.
Why this matters
Many teams conflate 'we use Claude' with 'we have Claude in our app.' Claude.ai is for human-in-the-loop work; the API is for automated systems. Choosing wrong blocks procurement and architecture.
Claude.ai provides Projects, conversation history, file upload, analysis artifacts (side-by-side outputs), and optional team billing. You get Anthropic's safety and model updates without managing API keys.
What the API adds: programmatic scale, custom UI, integration with your auth and data, fine-grained logging, and model routing in your backend. What Claude.ai adds: zero engineering, faster iteration for knowledge workers, built-in sharing.
Workflow — do this next
- 01Use Claude.ai for: strategy docs, ad-hoc analysis, personal productivity, pilot before API investment.
- 02Use API for: customer-facing features, batch jobs, strict data residency pipelines.
- 03Run a 2-week pilot in Claude.ai before scoping an API integration — same models, lower setup cost.
Real example
Product team — Claude.ai as spec lab before API
A B2B product team prototyped an AI summary feature entirely in Claude Projects with sample customer PDFs. PM validated UX and failure modes in two weeks. Engineering then replicated the prompt chain via API with confidence — avoiding a 3-month build based on assumptions.
2.2
Claude API
What it unlocks for builders and sophisticated users — and when you need it
Key takeaway
The API turns Claude into infrastructure — embeddable, metered, observable. You need it when Claude must run inside your product, on your schedule, at your scale.
Why this matters
API literacy separates teams that 'use AI' from teams that ship AI features. This is the builder surface.
The Messages API supports streaming, tool use, vision, PDF input, prompt caching, and batch processing. You control temperature, max tokens, and model ID per request.
Enterprise patterns: prompt caching for stable system prompts; Batch API for overnight jobs at discount; VPC / Bedrock / Vertex for residency requirements.
Workflow — do this next
- 01Start with Messages API + one Sonnet model before adding tools.
- 02Add tool definitions only when you need live data — each tool is maintenance.
- 03Instrument: log prompt hash, model, latency, token count per request from day one.
Ready-to-use artifacts
Complete templates — paste directly into your AI tool or automation workflow.
Minimal API request pattern (conceptual)
Structure every production integration around this shape.
POST /v1/messages
{
"model": "claude-sonnet-4-20250514",
"max_tokens": 1024,
"system": "You are... [stable instructions — cache this]",
"messages": [
{ "role": "user", "content": "User input + retrieved context" }
],
"tools": [ /* only when needed */ ]
}
// Always log: request_id, model, input_tokens, output_tokens, latency_ms2.3
Claude Code
The agentic coding tool that lives in your terminal — what it is and what it is not
Key takeaway
Claude Code is an agent that reads your repo, runs commands, and edits files — not a chat window in your IDE. It ships software, not snippets.
Why this matters
Developers who treat it as autocomplete underuse it; PMs who ignore it miss how eng velocity is changing.
Claude Code operates with agentic loops in your repository context. It can run tests, fix failures, and open PRs — bounded by permissions you grant.
It is not a replacement for code review or architecture ownership. Best for: scoped tasks with clear success criteria (add endpoint, fix test, refactor module). Risky for: greenfield architecture without human design doc.
Workflow — do this next
- 01Write a TASK.md with acceptance criteria before invoking Claude Code.
- 02Scope to one module or feature branch — not 'improve the whole codebase'.
- 03Require human review on all diffs; run CI before merge.
Real example
Fintech startup — 3-day API migration
Team migrated 12 REST endpoints to a new auth middleware using Claude Code with a written migration checklist. Human architect approved plan; agent executed repetitive edits; engineer reviewed 100% of diffs. Calendar estimate was 2 weeks.
2.4
Claude in Chrome
The browser agent that can see and act on what you're viewing
Key takeaway
Claude in Chrome is a browser extension agent — reads DOM, navigates multi-step flows, extracts tables, assists forms — with per-action approval on sensitive steps.
Why this matters
Huge category of knowledge work is trapped in web UIs without APIs. Browser agents unlock ops, procurement, research, and legacy admin workflows.
Install Claude in Chrome from official channel. Sign in with work account per policy. The extension gives Claude DOM access on tabs you authorise. Use cases: competitive research, government portals, vendor quotes, internal admin tools without APIs, SSO-gated dashboards (where policy allows).
Workflow pattern: (1) open target tab, (2) prompt with extraction schema, (3) approve each navigation/submit, (4) export artifact CSV/markdown. Never auto-submit payments, legal agreements, or production config.
Blockers: CAPTCHA, hardware 2FA, heavy JS SPAs, cross-origin iframes — document 'Chrome can't' list per portal. Supplement with manual upload or MCP when API exists.
Workflow — do this next
- 01List 5 repetitive browser tasks (expense, portal upload, competitor pricing).
- 02Pilot lowest-risk extraction-only task with step approval.
- 03Document portals: WORKS | PARTIAL | BLOCKED (CAPTCHA/2FA).
- 04Pair with Ch 9.5.3 portal workflow and Ch 3 vision for screenshot fallback.
Real example
Competitive intel — pricing page extraction
PM used Chrome to extract visible pricing tiers from three competitor sites into a comparison artifact. No form submits. Citations included URL + capture time. Analyst verified numbers against screenshots before board deck.
Ready-to-use artifacts
Complete templates — paste directly into your AI tool or automation workflow.
Claude in Chrome safety checklist
□ Work account / policy allows extension? □ Low-risk or sandbox login — not prod admin? □ Prompt forbids submit without approval? □ Output schema defined (table columns)? □ CAPTCHA/2FA exit plan documented? □ Sensitive pages excluded (banking, HR)?
2.5
Claude in Excel and PowerPoint
The document agents and what office automation actually looks like in practice
Key takeaway
Office integrations (Excel, PowerPoint, Word plugins + document Skills) meet users where models and decks live — Claude as analyst inside the file with formula/deck verification discipline.
Why this matters
Finance and strategy teams live in Excel/PPT. Adoption follows the file format; document Skills extend automation to native Office file generation.
Excel plugin: formula debugging, scenario modelling, variance commentary, range-scoped analysis — select data range explicitly, never whole workbook with hidden sheets. PowerPoint: storyline, speaker notes, slide condensation. Word: contract structure, redline prep (human counsel signs).
Document Agent Skills (pptx, xlsx, docx, pdf) in Claude.ai/Code generate native files — pair with brand template in Project. Limitation: complex macros/VBA need human review.
Verification rule: Claude drafts commentary; human owns every number touching external reporting. Export PDF audit trail for board materials.
Workflow — do this next
- 01Select only the data range Claude should see.
- 02Ask for formulas + plain-English logic explanation.
- 03For decks: enable pptx skill → QA in PowerPoint → PDF export.
- 04Cross-reference Ch 8.5.2 pre-built document skills.
Real example
FP&A team — monthly board pack
FP&A reduced board pack prep from 2 days to 6 hours: Claude in Excel drafted variance commentary from structured P&L export; human verified numbers; Claude in PowerPoint tightened narrative on 12 slides. Numbers never unverified.
2.6
Cowork
The desktop automation layer — where it fits in the ecosystem and who it is for
Key takeaway
Cowork is Anthropic's desktop automation layer — multi-app workflows with full MCP and plugin support when no single integration or browser tab is enough.
Why this matters
Ops, EA, and admin roles lose hours copying between email, files, spreadsheets, and calendar — Cowork reasons across apps; Zapier triggers on events.
Cowork targets cross-application tasks without clean APIs. Supports MCP connectors and plugins (Ch 8.5.7) like Claude Code. Compare: Cowork = UI reasoning across desktop; Zapier = event-triggered recipes; Chrome = single-browser scope.
Example flow: summarise Outlook thread → update Excel tracker → save attachment to SharePoint → calendar hold for follow-up — human approves each write step.
Workflow — do this next
- 01Map workflow as numbered steps across apps before automating.
- 02Install required Cowork plugin bundle.
- 03Pilot read-only path, then add writes with checkpoints.
- 04See Ch 9.5.4 for full Cowork workflow pattern.
2.7
The MCP ecosystem
How third-party tools connect into Claude's reasoning — the extensibility layer
Key takeaway
Model Context Protocol (MCP) lets Claude call Notion, GitHub, Slack, databases — with your credentials — in a standard way. It is the USB-C of agent tools.
Why this matters
Without MCP, every integration is bespoke. With MCP, your connector story scales — critical for enterprise 'Claude everywhere' strategies.
MCP servers run locally or remote. Claude Desktop and Claude Code consume MCP today; API tool use is the parallel for custom backends.
PM questions for MCP rollouts: which systems are read vs write? audit log per tool call? who approves new servers on employee laptops?
Workflow — do this next
- 01Install one read-only MCP server (e.g. GitHub read) on a pilot machine.
- 02Run 10 real queries; log failures and latency.
- 03Draft MCP_ALLOWLIST.md before company-wide rollout.
Ready-to-use artifacts
Complete templates — paste directly into your AI tool or automation workflow.
MCP server evaluation checklist
Before approving an MCP server for team use: □ Read-only or write? If write, what can it delete? □ Where do credentials live? (env vars, OS keychain) □ Is traffic logged with user ID + timestamp? □ Vendor maintained? Last update date? □ Test: 5 queries that match our real workflows □ Fallback when server is down — does work stop?
2.8
Choosing your Claude surface
The decision framework for which product to use for which task
Key takeaway
Pick surface by: who acts (human vs software), data sensitivity, repeatability, and integration depth — not by which product launched most recently.
Why this matters
Tool sprawl kills ROI. One decision framework prevents 'everyone picked a different Claude product.'
Human, exploratory, document-heavy → Claude.ai Projects + Skills. Developer shipping → API/Bedrock/Vertex. Repo engineering → Claude Code + plugins. Web-only legacy → Chrome. Finance decks → Excel/PPT + document skills. Cross-app desktop → Cowork. Live systems → MCP + connectors. Vision/screenshots → Claude.ai upload. Hard reasoning → extended thinking.
Workflow — do this next
- 01For each recurring task, fill: Actor (human/bot), Data class (public/internal/secret), Frequency (daily/once).
- 02Match to surface using the matrix in this section.
- 03Revisit quarterly — Anthropic ships fast; last quarter's answer may change.
Real example
50-person agency — surface map on one page
Creative: Claude.ai for briefs. Dev: Claude Code + API for client portals. Account: Chrome for competitor audits. Finance: Excel plugin. Leadership banned 'random API keys' — central IT runs one API account with logging. Adoption went up because each role had a default front door.
Concept 3
Platform Capabilities — Skills, Reasoning & Agents
Agent Skills, extended thinking, computer use, vision, and cloud deployment — the capabilities that extend Claude beyond chat
3.1
Claude Agent Skills
SKILL.md folders, pre-built document skills, and custom skills across Claude.ai, Claude Code, and the API
Key takeaway
Agent Skills are modular packages (SKILL.md + optional scripts/resources) that Claude loads on demand via progressive disclosure — procedural expertise, not just static instructions.
Why this matters
Skills are Anthropic's answer to repeatable specialist behaviour without pasting 2,000-word prompts every session.
Agent Skills ship pre-built for PowerPoint, Excel, Word, and PDF workflows. Custom skills: upload zip in Claude.ai Settings → Features; place in `.claude/skills/` for Claude Code; upload via Skills API for workspaces.
Skills stack and compose — Claude may coordinate multiple skills on one task. Distinct from MCP (live tools), Projects (static knowledge), and CLAUDE.md (repo context).
Workflow — do this next
- 01Browse pre-built skills in Claude.ai Customize → Skills.
- 02Pilot one custom SKILL.md for your top recurring task.
- 03Document skill version in workflow registry (Ch 9).
Ready-to-use artifacts
Complete templates — paste directly into your AI tool or automation workflow.
SKILL.md starter template
--- name: weekly-competitive-brief description: Produces structured competitive intel brief from approved sources. --- # Weekly competitive brief ## When to use User asks for competitor update, market scan, or weekly brief. ## Steps 1. Confirm competitor list from Project COMPETITORS.md 2. Search + extract facts with citations only 3. Output markdown artifact: Summary | Moves | Implications | Open questions ## Output schema [required sections] ## Scripts (optional) ./scripts/fetch_rss.sh
3.2
Extended thinking & adaptive reasoning
How Claude reasons harder on complex tasks — UI controls, API thinking blocks, and when the extra cost pays off
Key takeaway
Extended thinking lets Claude deliberate before answering — use for hard analysis, multi-step math, architecture trade-offs; skip for simple drafts.
Why this matters
Without thinking mode, users blame 'dumb AI' on tasks that need deliberation budget.
In Claude.ai, enable extended thinking (or adaptive reasoning where available) for complex threads. API: thinking blocks with configurable budget. Trade-off: higher latency and token cost for better structured reasoning on hard problems.
Best for: strategy options, debugging subtle logic, financial model review, legal clause comparison. Poor fit: rewrite this paragraph, format this JSON.
Workflow — do this next
- 01Tag tasks HARD vs FAST before starting.
- 02Enable thinking on HARD; use Haiku/Sonnet fast path on FAST.
- 03Ask Claude to show assumptions after thinking completes.
Real example
Architecture review with thinking on
Team enabled extended thinking for ADR drafts. Claude surfaced three non-obvious coupling risks in microservice split that instant mode missed. Extra 40s latency acceptable for 2-hour human review saved.
3.3
Computer use
Claude interacting with desktop environments — screenshots, UI actions, and the safety model for agentic desktop automation
Key takeaway
Computer use lets Claude see and act on GUIs (click, type, navigate) — powerful for legacy apps without APIs; requires strict human approval and sandboxed accounts.
Why this matters
Ops work trapped in desktop UIs is a major category — computer use is the API-less automation path.
Available via API and select Claude products. Flow: screenshot → plan action → execute → verify. Never run unattended on production admin, banking, or HR systems.
Pair with allowlisted apps, dedicated VM, and session recording for audit. Prefer MCP or Chrome extension when a narrower scope exists.
Workflow — do this next
- 01Pilot on disposable VM with test account.
- 02Define stop conditions and forbidden windows.
- 03Log every action; human approves high-risk clicks.
3.4
Vision & multimodal input
Images, screenshots, diagrams, and PDFs as first-class inputs — what Claude sees and what it can misread
Key takeaway
Claude accepts images and PDFs as input — use for UI mockup review, whiteboard photos, chart interpretation, redacted screenshot debugging; always verify small text and numbers.
Why this matters
Vision unlocks design, field ops, and incident triage workflows that text-only cannot serve.
Upload PNG/JPG/screenshots or PDF pages. Prompt: 'Describe only what is visible; flag unreadable regions.' For diagrams: 'List components and arrows; do not invent labels.'
Limits: tiny text, compressed JPEG artifacts, colour-only encodings. Supplement with typed labels for critical data.
Workflow — do this next
- 01Crop to relevant region before upload.
- 02Ask for structured extraction table first.
- 03Human verifies numbers and labels before action.
Real example
PM — Figma screenshot to acceptance criteria
PM uploaded mobile mockup screenshot. Claude produced accessibility and edge-case checklist from visible UI only. Designer confirmed three items Claude misread due to low-res crop — fixed by re-upload at 2× resolution.
3.5
Claude Desktop & Mobile
Native apps, MCP on desktop, remote MCP on mobile, and when to use app vs browser
Key takeaway
Claude Desktop: full local MCP, desktop extensions (MCPB), system integration. Mobile: remote MCP, capture/quick Q&A. Deep work stays on desktop.
Why this matters
MCP and extensions are platform-gated — picking wrong surface blocks connector workflows.
Desktop: install from Anthropic; configure mcpServers in settings; use Desktop Extensions gallery for MCP Bundles. Mobile: remote connectors, voice capture where supported, not full local MCP.
Workflow — do this next
- 01Install Desktop if using local MCP or extensions.
- 02Sync connector auth across devices where policy allows.
- 03Reserve mobile for triage; export to Project on desktop.
3.6
Cloud deployment paths
Amazon Bedrock, Google Vertex AI, and Microsoft Foundry — when to run Claude through hyperscaler marketplaces
Key takeaway
Bedrock, Vertex, and Foundry offer Claude inside existing cloud contracts, IAM, residency, and procurement — same models, different control plane and billing.
Why this matters
Enterprise buyers often cannot use console.anthropic.com directly — cloud paths are mandatory.
Amazon Bedrock — fit when stack is AWS-native. Google Vertex AI — fit for GCP shops. Microsoft Foundry — fit for Microsoft-centric orgs.
Skills and features availability vary by cloud surface — verify Anthropic release notes per platform. Pin model IDs; run regression suite after platform upgrades.
Workflow — do this next
- 01Map procurement constraint → cloud path.
- 02Pilot one model in sandbox VPC.
- 03Align logging with SIEM before production traffic.
Ready-to-use artifacts
Complete templates — paste directly into your AI tool or automation workflow.
Cloud deployment path picker
AWS primary + IAM/VPC needs → Bedrock GCP primary + Vertex governance → Vertex AI Azure EA + Microsoft stack → Foundry Direct API + Anthropic console → api.anthropic.com Need Skills API workspace-wide → verify path supports Skills
3.7
Claude Agent SDK
Building production agents with Anthropic's agent runtime — loops, tools, and deployment beyond chat
Key takeaway
Agent SDK packages observe-reason-act loops with tool execution — use when Claude Code patterns become customer-facing or scheduled products.
Why this matters
Ch 8 builds agents manually; SDK is the supported path to hardened production agents.
SDK agents combine Messages API, tool use, MCP, Skills, and optional computer use. Deploy with your auth, rate limits, and eval harness.
Workflow — do this next
- 01Prototype loop in Claude Code first.
- 02Port to Agent SDK with same tool contracts.
- 03Add evals before customer exposure.
3.8
Skills, MCP, plugins & commands — the extensibility map
How Agent Skills, MCP connectors, Claude Code plugins, and slash commands relate — and which to use when
Key takeaway
MCP = live tools/data. Skills = procedural packages. Plugins = bundled MCP + skills + commands + sub-agents. Commands = single-shot slash prompts. Use the smallest layer that fits.
Why this matters
Teams duplicate the same workflow across four mechanisms — or pick the wrong one and fight the platform.
Decision: need live Salesforce record → MCP. Need repeatable deck structure → Skill. Need team-shareable eng bundle → Plugin. Need one-off release checklist → slash command.
Workflow — do this next
- 01Draw workflow; label each step LIVE DATA vs PROCEDURE.
- 02LIVE → MCP; PROCEDURE → Skill.
- 03Bundle recurring combos into plugin when mature.
Real example
Product team extensibility stack
Notion MCP for live specs + custom PRD Skill + GitHub MCP for issues. Packaged as plugin for PMs on Claude Code. Claude.ai users get Skills + remote MCP only — documented in team SURFACE_MAP.
Ready-to-use artifacts
Complete templates — paste directly into your AI tool or automation workflow.
Claude surface picker
Paste into your team wiki — one decision per row.
| Task | Actor | Data | Surface | |------|-------|------|---------| | Draft strategy memo | Human | Internal | Claude.ai Project | | Customer-facing chatbot | Software | Customer PII | API + your auth | | Fix failing tests in repo | Engineer | Code | Claude Code | | Pull data from vendor portal | Ops | Login session | Claude in Chrome | | Board variance commentary | Finance | Confidential | Excel plugin | | Live Notion + Slack context | Team | Mixed | MCP + Claude Desktop | Rule: if two rows match, pick the one with better logging and audit trail.
Session handoff template
End every long Claude.ai thread with this — paste into next chat.
## Session handoff — [DATE] ### Decisions made - ### Open questions - ### Constraints (do not violate) - ### Next actions 1. ### Context to load - [files, links, Project name]
Knowledge cutoff handoff prompt
Paste at the start of research or strategy chats.
You are helping with a task that may require current information. Rules: 1. If a fact may have changed after your training cutoff, say so explicitly. 2. When web search is available, use it for: pricing, API versions, regulations, competitor features. 3. Separate "from your training" vs "from search results" vs "from attached docs". 4. If you cannot verify, recommend what the human should check. My task: [DESCRIBE TASK] Attached sources: [LIST OR NONE]
Minimal API request pattern (conceptual)
Structure every production integration around this shape.
POST /v1/messages
{
"model": "claude-sonnet-4-20250514",
"max_tokens": 1024,
"system": "You are... [stable instructions — cache this]",
"messages": [
{ "role": "user", "content": "User input + retrieved context" }
],
"tools": [ /* only when needed */ ]
}
// Always log: request_id, model, input_tokens, output_tokens, latency_msClaude in Chrome safety checklist
□ Work account / policy allows extension? □ Low-risk or sandbox login — not prod admin? □ Prompt forbids submit without approval? □ Output schema defined (table columns)? □ CAPTCHA/2FA exit plan documented? □ Sensitive pages excluded (banking, HR)?
MCP server evaluation checklist
Before approving an MCP server for team use: □ Read-only or write? If write, what can it delete? □ Where do credentials live? (env vars, OS keychain) □ Is traffic logged with user ID + timestamp? □ Vendor maintained? Last update date? □ Test: 5 queries that match our real workflows □ Fallback when server is down — does work stop?
SKILL.md starter template
--- name: weekly-competitive-brief description: Produces structured competitive intel brief from approved sources. --- # Weekly competitive brief ## When to use User asks for competitor update, market scan, or weekly brief. ## Steps 1. Confirm competitor list from Project COMPETITORS.md 2. Search + extract facts with citations only 3. Output markdown artifact: Summary | Moves | Implications | Open questions ## Output schema [required sections] ## Scripts (optional) ./scripts/fetch_rss.sh
Cloud deployment path picker
AWS primary + IAM/VPC needs → Bedrock GCP primary + Vertex governance → Vertex AI Azure EA + Microsoft stack → Foundry Direct API + Anthropic console → api.anthropic.com Need Skills API workspace-wide → verify path supports Skills
Distributed product org — 90 days to coherent Claude practice
A 180-person product company had engineers on Claude Code, PMs on Claude.ai, marketing on free accounts, and one rogue API key in a side project. Security flagged data risk; leadership flagged inconsistent quality.
Before
No shared mental model. PMs assumed Claude 'remembered' pricing. Engineers burned Opus tokens on lint fixes. Legal saw unapproved Chrome extension use on client portals.
After
Chapter 1 workshop (this content) became mandatory 60-min onboarding. Team published SURFACE_MAP.md, SESSION_HANDOFF template, and model routing (Haiku/Sonnet/Opus). API centralized under platform team with logging.
- Inference spend → down 48% with model routing
- Security incidents from shadow tools → 0 in Q2
- Self-reported 'Claude confusion' in pulse survey → 34% to 9%
- Time to first useful output for new hires → 3 days to 4 hours
What goes wrong
Treating Claude like Google — single-shot questions without context or verification.
Adopt Projects + handoff template; require sources for factual claims in team outputs.
Using Opus for every task because 'it's the best'.
Implement Haiku → Sonnet → Opus routing from section 1.7; review monthly spend by task type.
Assuming memory across chats — decisions drift, versions conflict.
Single source of truth doc in a Project; session handoffs mandatory for multi-day work.
Rolling out MCP and Chrome extensions company-wide without allowlists.
Pilot read-only MCP; document approved surfaces in 2.8 before expanding.
Vetted by Krishna KumarCurator, FactorBeam
Discussion
Discussion coming soon
Shared comments for this playbook are not live yet. When they are, you'll be able to ask questions, share what worked, and see replies from other readers.