Gold & Diamond Standard Edition — Verified against official docs as of July 28, 2026

How this guide was built: Compiled from Anthropic’s official documentation (code.claude.com/docs, claude.com/docs/cowork, platform.claude.com/docs), the official Claude Code changelog and weekly “What’s New” digests, and current pricing references — all fetched live on July 28, 2026. Anthropic ships updates weekly, so treat this as an accurate snapshot, not eternal truth. Canonical sources are linked throughout.

PART 0 — THE 30-SECOND MENTAL MODEL

Claude Code and Claude Cowork are the same agentic engine wearing two different outfits.

• Claude Code = the engine pointed at code: terminal, IDE, desktop, web, CI. For developers.
• Claude Cowork = the engine pointed at knowledge work: files, documents, spreadsheets, research, browsers. For everyone else (and for developers doing non-code work).

Both share one philosophy: you delegate outcomes, not keystrokes. You describe what “done” looks like, Claude plans, executes across many steps and tools, verifies, and comes back with finished work. The skill you’re really learning in this guide is delegation engineering.

PART 1 — THE CLAUDE MODEL FAMILY (Deep Dive, July 2026)

1.1 The current lineup at a glance

Legacy but still callable: Sonnet 4.6, Opus 4.7/4.6/4.5, Sonnet 4.5, Opus 4.1/4. There’s rarely a reason to use them except compatibility.

Standing API discounts: prompt caching cuts cache-hit input cost by ~90%, and the Batch API halves everything for non-urgent workloads. Verify live numbers at platform.claude.com before budgeting.

1.2 Deep profile: each model

Claude Fable 5 (released June 9, 2026)

The first “Mythos-class” model — a new tier that sits above Opus. The most intelligent generally available Claude. Fable 5 always uses extended thinking (it cannot be disabled), which is part of why its output is expensive. Its sibling Mythos 5 is the identical model without dual-use safety measures, available only to approved organizations. Plan access shifted on July 20, 2026: Fable 5 is included on Max plans and premium Team/Enterprise seats (capped at roughly half of weekly limits), with Pro and standard seats accessing it through usage credits — check claude.com/pricing for your plan’s exact terms.

Use Fable 5 when: the problem is genuinely at the frontier — novel architecture design, research-grade analysis, gnarly multi-system debugging where cheaper models have already failed, or work where a wrong answer costs far more than $50/M tokens. Don’t use it for: routine coding, drafting, or anything Sonnet handles. At 5x Sonnet’s output price, habit-driven Fable use is the fastest way to burn budget.

Claude Opus 5 (released late July 2026 — days old)

A step-change over Opus 4.8, with the largest gains in deep reasoning, agentic/long-horizon tasks, and test-time compute scaling. Key specs: 1M-token context window (default and maximum — no smaller variant), 128K max output, thinking on by default, and a breaking change to when thinking can be disabled. It supports mid-conversation tool changes (beta header mid-conversation-tool-changes-2026-07-01) so agents can swap tools between turns while preserving the prompt cache. A Fast mode runs at roughly 2.5x speed for about 2x the base price. Because it’s brand new, check the official “What’s new in Claude Opus 5” page before relying on edge behaviors.

Use Opus 5 when: long autonomous runs, complex multi-file refactors, agent orchestration, or anywhere you’d have used Opus 4.8 and want the ceiling raised at the same $5/$25 price.

Claude Opus 4.8 (released late May 2026)

The battle-tested default engine of Claude Code for the past two months. Same $5/$25 pricing as Opus 5, 1M context, supports fast mode at reduced pricing. Extremely strong at coding and agentic reliability. If Opus 5’s newness makes you cautious, 4.8 is the stable choice.

Claude Sonnet 5 (released June 30, 2026)

The new production default for Free and Pro plans and the best value in the lineup right now thanks to introductory pricing of $2/$10 through August 31, 2026 (rising to $3/$15 on September 1). 1M context. Handles the overwhelming majority of real coding, writing, and agent tasks. This is the model most teams should default to, escalating only on evidence.

Claude Haiku 4.5

$1/$5, 200K context, very fast. The right choice for classification, routing, extraction, summarization at scale, and — critically for this guide — as the model for simple subagents inside Claude Code, where it does grunt work at a fifth of Opus prices.

How thinking/effort works now

The current generation uses adaptive reasoning with effort levels (low → max, with xhigh introduced alongside Opus 4.7) instead of fixed thinking-token budgets on newer models. In Claude Code you control this with /effort or inside /model. Older fixed-budget models respect MAX_THINKING_TOKENS (e.g., MAX_THINKING_TOKENS=8000). Thinking tokens bill as output tokens — this is a major, often invisible cost lever (see Part 6).

1.3 The model-routing decision tree

1. Is it high-volume, simple, or a subagent chore? → Haiku 4.5
2. Is it normal coding, drafting, analysis, or agent work? → Sonnet 5 (near-free upgrade during intro pricing)
3. Is it a long autonomous run, hard refactor, or did Sonnet visibly struggle? → Opus 5 (or 4.8 for stability)
4. Did Opus fail, or is this frontier-difficulty knowledge work where quality is everything? → Fable 5
5. Never route up by default; route up on evidence. Never route down mid-task if context continuity matters — a model switch invalidates the prompt cache and triggers one expensive uncached turn.

In Claude Code specifically: set your default in /config, switch mid-session with /model, use the opusplan alias to plan with Opus and execute with Sonnet, and pin model: haiku in subagent configs.

PART 2 — CLAUDE CODE: THE COMPLETE PICTURE

2.1 What it is

Claude Code is Anthropic’s agentic coding tool. It reads your codebase, edits files, runs commands, uses git, browses when allowed, and integrates with your toolchain. Under the hood it runs an agentic loop: choose tool → execute → read result → decide next step → repeat until done, with compaction managing long sessions. Safety comes from permission modes, checkpoints, sandboxing, and managed settings. The same loop is exposed programmatically through the Agent SDK.

2.2 Every surface (and when to use each)

All surfaces share the same engine — your CLAUDE.md, settings, and MCP servers work everywhere. Move work between surfaces: claude --teleport pulls a web session into your terminal, claude --cloud pushes local work to the cloud, /desktop hands a terminal session to the Desktop app, and Remote Control continues a local session from your phone.

2.3 Installation (current official methods)

Native install (recommended — auto-updates):

<em># macOS / Linux / WSL</em>
curl -fsSL https://claude.ai/install.sh | bash
<em># Windows PowerShell</em>
irm https://claude.ai/install.ps1 | iex
Code language: HTML, XML (xml)

Also available: brew install --cask claude-code (or claude-code@latest channel), winget install Anthropic.ClaudeCode, and apt/dnf/apk on Linux. Homebrew and WinGet do not auto-update. On native Windows, install Git for Windows so Claude gets a Bash tool (otherwise it uses PowerShell). Then:

cd your-project && claude

2.4 The one constraint that explains everything: the context window

Nearly every best practice exists because of this: the context window holds your whole conversation — every message, every file read, every command output — and model performance degrades as it fills. A single debugging session can consume tens of thousands of tokens. Manage context and you’ve mastered 80% of Claude Code. Track it continuously with a custom status line, inspect it with /context, and see Part 6 for the full reduction playbook.

2.5 Permission modes (Shift+Tab cycles them)

Fine-grained control: /permissions allowlists specific commands (e.g., npm run lint, git commit), --allowedTools "Edit,Bash(git commit *)" scopes headless runs, deny/ask rules can match tool parameters, and /sandbox enables the sandboxed Bash tool — OS-level filesystem and network isolation so Claude works freely inside boundaries you define. For stronger isolation choose dev containers, Docker, or VMs (see the sandbox-environments doc).

2.6 Sessions, checkpoints, and time travel

Every prompt creates a checkpoint; Claude snapshots files before each change. Esc stops Claude mid-action (context preserved). Esc Esc or /rewind opens the rewind menu: restore conversation, code, or both, or summarize from/up to a point (partial compaction). Checkpoints persist across sessions — but they only track Claude’s changes; they’re not a git replacement.

Sessions are persistent: claude --continue resumes the latest, claude --resume shows a picker, /rename names a session (treat sessions like branches: oauth-migration), --from-pr finds the session that created a PR (you can even paste a PR URL into /resume), and /rewind can resume a conversation from before a /clear. Transcripts are stored locally and searchable across projects with Ctrl+R.

PART 3 — THE EXTENSION SYSTEM (CLAUDE.md, Skills, Subagents, Hooks, MCP, Plugins)

This is the customization hierarchy. Choosing the right mechanism is the difference between a tuned instrument and a bloated mess.

3.1 CLAUDE.md — write it like code

Run /init to generate a starter from your codebase, then prune ruthlessly. The official test for every line: “Would removing this cause Claude to make mistakes?” If not, cut it. Bloated CLAUDE.md files cause Claude to ignore your actual instructions. Aim for under ~200 lines.

Include: bash commands Claude can’t guess, style rules that differ from defaults, test-runner preferences, branch/PR conventions, architectural decisions, required env vars, non-obvious gotchas. Exclude: anything Claude can read from the code, standard conventions, API docs (link instead), file-by-file tours, “write clean code” platitudes.

Power moves: add emphasis (“IMPORTANT”, “YOU MUST”) to rules Claude skips; import files with @path/to/file syntax; add compaction instructions (# Compact instructions — always preserve modified-file list and test commands); check it into git so it compounds.

Placement: ~/.claude/CLAUDE.md (all sessions), ./CLAUDE.md (project, shared), ./CLAUDE.local.md (personal, gitignored), parent dirs (monorepo roots), child dirs (pulled in on demand — the key pattern for large codebases and monorepos).

3.2 Skills

A directory with a SKILL.md in .claude/skills/. Claude applies them automatically when relevant, or you invoke directly as /skill-name arguments. Two flavors:

---
name: api-conventions
description: REST API design conventions for our services
---
# API Conventions
- kebab-case URL paths, camelCase JSON, pagination on list endpoints, /v1/ versioning
Code language: PHP (php)

---
name: fix-issue
description: Fix a GitHub issue
disable-model-invocation: true
---
Analyze and fix GitHub issue: $ARGUMENTS.
1. `gh issue view` for details  2. Understand  3. Search codebase
4. Implement fix  5. Write & run tests  6. Lint/typecheck  7. Commit, push, PR
Code language: JavaScript (javascript)

disable-model-invocation: true = manual-only, for workflows with side effects (/fix-issue 1234). Key cost insight: skills load on demand, so moving specialized instructions out of CLAUDE.md into skills keeps every session’s base context small.

3.3 Subagents

Markdown files in .claude/agents/ defining specialists with their own context window, tool allowlist, and model:

---
name: security-reviewer
description: Reviews code for security vulnerabilities
tools: Read, Grep, Glob, Bash
model: opus
---
You are a senior security engineer. Review for injection, authz flaws,
secrets in code, insecure data handling. Give line references and fixes.

Invoke explicitly: “Use a subagent to review this code for security issues.” Why subagents are the single most powerful context tool: research that would flood your main context happens in a separate context, and only a summary returns. Since June 2026, subagents can spawn their own subagents. Use model: haiku for grunt work.

3.4 Hooks

Deterministic scripts at lifecycle events (PreToolUse, PostToolUse, Stop, and more — including async hooks, HTTP hooks, prompt hooks, MCP tool hooks). Unlike CLAUDE.md (advisory), hooks are guaranteed. Let Claude write them: “Write a hook that runs eslint after every file edit.” Browse configured hooks with /hooks. A killer cost pattern appears in Part 6 (test-output filtering).

3.5 MCP

claude mcp add connects servers; claude mcp login authenticates from the shell; /mcp lists and toggles them. MCP tool definitions are deferred by default — only names enter context until a tool is actually used (tool search handles thousand-tool fleets). Still, prefer CLI tools (gh, aws, gcloud, sentry-cli) when they exist — they add zero per-tool context. Claude learns unknown CLIs from --help. Orgs can allowlist/denylist servers via managed MCP configuration.

3.6 Plugins

/plugin opens the marketplace; plugins bundle skills + hooks + subagents + MCP into one install, loadable even from .zip archives and URLs. Two standouts: code intelligence plugins for typed languages (precise symbol navigation, automatic type-error reporting after edits — a big token saver) and the security-guidance plugin (Claude reviews its own diffs for vulnerabilities in-session). Teams can run private marketplaces, declare plugin dependency version constraints, and have Claude Code auto-suggest org plugins by relevance.

PART 4 — COMMAND, FLAG & SHORTCUT REFERENCE

4.1 Essential slash commands

4.2 Essential CLI flags

claude                       <em># interactive session</em>
claude -p "prompt"           <em># headless/non-interactive (CI, scripts, pipes)</em>
claude -p "..." --output-format json          <em># parseable output</em>
claude -p "..." --output-format stream-json --verbose
claude --continue            <em># resume most recent session</em>
claude --resume              <em># session picker</em>
claude --worktree            <em># isolated git worktree session</em>
claude --cloud               <em># push task to Claude Code on the web</em>
claude --teleport            <em># pull a web session into your terminal</em>
claude --from-pr <pr>        <em># resume the session that made a PR</em>
claude --permission-mode auto -p "fix all lint errors"
claude --allowedTools "Edit,Bash(git commit *)" -p "..."
claude --debug               <em># verbose debugging incl. hook rewrites</em>
claude mcp add / claude mcp login
claude project purge [path]  <em># delete all local state for a project</em>
cat error.log | claude       <em># pipe anything in</em>
Code language: HTML, XML (xml)

4.3 Keyboard

Esc stop mid-action · Esc Esc rewind menu · Shift+Tab cycle permission modes · Ctrl+G edit plan in your editor · Ctrl+R search command history across projects · @file reference files · paste/drag images directly · voice dictation (hold-to-record) available in the CLI. Keybindings are customizable via a keybindings file; fullscreen rendering mode gives flicker-free output with mouse support.

PART 5 — GOLDEN WORKFLOWS & PROMPTING MASTERY

5.1 The #1 principle: give Claude a way to verify its work

Official guidance, verbatim spirit: give Claude a check it can run — tests, a build, a screenshot to compare. It’s the difference between a session you watch and one you walk away from.

Without a runnable check, “looks done” is Claude’s only signal and you become the verification loop. With one, Claude iterates until it passes. Four escalating ways to enforce it:

1. In the prompt: “…run the tests after implementing and fix failures.”
2. Across the session: /goal — an evaluator re-checks the condition after every turn.
3. Deterministic gate: a Stop hook runs your check as a script and blocks the turn from ending until it passes (overridden after 8 consecutive blocks).
4. Second opinion: a verification subagent or dynamic workflow where a fresh model tries to refute the result.

Always ask Claude to show evidence — test output, commands run, screenshots — rather than asserting success.

5.2 Explore → Plan → Code → Commit

The canonical workflow for anything non-trivial:

1. Explore (plan mode): “read /src/auth and understand how we handle sessions and login.”
2. Plan (plan mode): “I want to add Google OAuth. What files change? What’s the session flow? Create a plan.” Then Ctrl+G to edit the plan directly.
3. Implement (default mode): “implement the OAuth flow from your plan. write tests for the callback handler, run the suite, fix failures.”
4. Commit: “commit with a descriptive message and open a PR.”

Skip planning when you could describe the diff in one sentence — plan mode adds overhead for typo-fixes.

5.3 Prompt engineering: the before/after patterns (official)

Vague prompts are right for exploration (“what would you improve in this file?”).

5.4 The most effective prompt prefixes & templates

The Interview pattern (official — best for large features):

I want to build [brief description]. Interview me in detail using the
AskUserQuestion tool. Ask about technical implementation, UI/UX, edge
cases, concerns, and tradeoffs. Don't ask obvious questions — dig into
the hard parts I might not have considered. Keep interviewing until
we've covered everything, then write a complete spec to SPEC.md.
Code language: PHP (php)

Then start a fresh session to execute the spec with clean context.

The Investigation delegate:

Use subagents to investigate how our authentication system handles token
refresh, and whether we have existing OAuth utilities I should reuse.
Code language: PHP (php)

The Adversarial reviewer:

Use a subagent to review the rate limiter diff against PLAN.md. Check that
every requirement is implemented, listed edge cases have tests, and nothing
outside scope changed. Report gaps, not style preferences.
Code language: CSS (css)

(Warn the reviewer off nitpicks — reviewers asked to find gaps will find some even in sound work; only correctness findings matter.)

The CLI-learning prefix: Use 'foo-cli --help' to learn the tool, then use it to solve A, B, C.

The onboarding prompts (no special phrasing needed — ask like you’d ask a senior engineer): “How does logging work?” · “How do I add a new API endpoint?” · “What edge cases does CustomerOnboardingFlowImpl handle?”

5.5 Scaling: parallel Claudes

• Worktrees (--worktree): parallel CLI sessions in isolated git checkouts.
• Desktop app: parallel sessions visually, each in its own worktree.
• Web: cloud sessions in isolated VMs; fire-and-forget from your phone.
• Agent view: dispatch and monitor many sessions from one screen; see who needs input.
• Agent teams: multiple coordinated instances with shared tasks, inter-agent messaging, and a lead. Experimental — enable with CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1. Costs ~7x a normal session; keep teams small, use Sonnet teammates, shut idle teammates down.
• Dynamic workflows: Claude writes an orchestration script that fans subagents out over audits, migrations, and cross-checked research — rerunnable.
• Writer/Reviewer pattern: Session A implements; Session B (fresh context, unbiased) reviews; feed the review back to A. Same trick works as test-writer vs. implementer.
• Fan-out for migrations: have Claude generate the file list, then loop claude -p "Migrate $file… Return OK or FAIL" --allowedTools "Edit,Bash(git commit *)". Test on 2–3 files, refine the prompt, then run at scale.

5.6 Automation & always-on Claude

• Routines: scheduled or event-triggered runs on Anthropic-managed cloud infra (works while your laptop sleeps); trigger on cron, API calls, or GitHub events. Create via /schedule, web, or Desktop.
• Desktop scheduled tasks: recurring runs on your machine with local file/tool access.
• Channels: push webhooks, CI results, chat messages into a running session via MCP so Claude reacts while you’re away.
• Deep links: claude-cli:// URLs in runbooks/alerts open Claude in the right repo with the right prompt.
• GitHub Code Review / /autofix-pr: automatic multi-agent review on every PR; auto-fix from terminal or cloud.
• Ultraplan: start a plan in the CLI, draft it on the web, execute remotely or locally.
• Computer use (CLI & Desktop): Claude opens apps, clicks, types, and sees your screen on macOS — test native apps and GUI-only tools.
• Advisor tool: pair your main model with a stronger advisor model consulted at key decision moments — Sonnet does the work, Opus/Fable advises.

PART 6 — THE COST MASTERY PLAYBOOK

6.1 Ground truth on billing

API/Console billing is per token. Subscription plans (Pro/Max/Team/Enterprise) include usage within rolling 5-hour and weekly windows shared across chat, Code, and Cowork; usage credits let you keep working past limits. Enterprise benchmark: ~$13 per developer per active day on average, $150–250/month, with 90% of users under $30/day. Budget more for a coding seat than a chat seat — one debugging session can outconsume a day of chat.

Track: /usage (session tokens, plan bars, and a breakdown attributing usage to skills, subagents, plugins, MCP servers — flagging long-context or cache-miss behavior at ≥10%), /context, a custom status line, the Console usage page, spend reports & Analytics APIs for orgs, OpenTelemetry export for real-time per-user metrics on any setup, and workspace/org/member spend limits to cap it.

6.2 Why usage silently climbs (the four traps)

1. Long context: every message resends the whole conversation — a one-liner in an all-day session pays for the whole session.
2. Cache misses: return after the cache lifetime (1 hour on subscription; 5 minutes on usage credits/API) and your next message reprocesses the entire context uncached.
3. Idle burners: scheduled /loop tasks and active agent teammates keep consuming while you’re away.
4. Compaction cost: /compact reads everything it summarizes — compacting a huge context is itself a huge request. When you don’t need continuity, /clear costs nothing.

6.3 The complete reduction checklist (highest impact first)

1. /clear between unrelated tasks. The single highest-impact habit. /rename first so you can /resume later.
2. Match the model to the job. Sonnet for most work; Opus only for hard problems; model: haiku in subagent configs; opusplan to plan expensive and execute cheap.
3. Tune thinking. Lower /effort for simple work, disable thinking in /config where allowed (not on Fable 5), or MAX_THINKING_TOKENS=8000 on fixed-budget models. Thinking bills as output tokens — the expensive kind.
4. Delegate verbose operations to subagents — test runs, doc fetches, log processing stay in the subagent’s context; only summaries return.
5. Prefer CLI tools over MCP; disable unused MCP servers (/mcp).
6. Preprocess with hooks. The official flagship example — a PreToolUse hook that rewrites test commands to return only failures, turning a 10,000-line log into a few hundred tokens:

#!/bin/bash
input=$(cat); cmd=$(echo "$input" | jq -r '.tool_input.command')
if [[ "$cmd" =~ ^(npm test|pytest|go test) ]]; then
  filtered="$cmd 2>&1 | grep -A 5 -E '(FAIL|ERROR|error:)' | head -100"
  echo "{\"hookSpecificOutput\":{\"hookEventName\":\"PreToolUse\",\"permissionDecision\":\"allow\",\"updatedInput\":{\"command\":\"$filtered\"}}}"
else echo "{}"; fi
Code language: PHP (php)

7. Move workflow instructions from CLAUDE.md into skills (on-demand loading). Keep CLAUDE.md under ~200 lines.
8. Install code intelligence plugins for typed languages — one go-to-definition replaces a grep plus several speculative file reads.
9. Write specific prompts. “Improve this codebase” triggers broad scanning; “add input validation to the login function in auth.ts” doesn’t.
10. Plan mode for complex work — wrong-direction rework is the most expensive token sink of all. Course-correct with Esc early; after two failed corrections, /clear and re-prompt with what you learned.
11. Custom compaction instructions (/compact Focus on the API changes) so summaries keep what matters.
12. /btw for side questions — answered in an overlay, never enters context.
13. On the raw API: prompt caching (~90% off cache hits) and the Batch API (50% off everything non-urgent).
14. Know the cache mechanics: model switches trigger one slow uncached turn; CLAUDE.md edits don’t apply mid-session; check your cache hit rate via the prompt-caching doc guidance.

PART 7 — CLAUDE COWORK: THE COMPLETE PICTURE

7.1 What it is

Cowork is Anthropic’s agentic workspace — the same architecture as Claude Code, aimed at knowledge work, no terminal required. Officially: describe a desired outcome, then return later to completed work — polished documents, organized files, synthesized research, and more. It launched as a research preview in January 2026 and is now generally available to all paying customers (Pro, Team, Enterprise) on Mac and Windows, with remote sessions (beta) making your sessions and files follow your account across desktop, web, and mobile. Chat and Cowork now share one home — delegating a task starts from the same message box as a conversation.

7.2 Key capabilities (official)

• Works directly on your computer — reads and writes local files, no manual uploads/downloads. Execution happens in an isolated virtual-machine environment for safety.
• Sub-agent coordination — complex work is split into parallel workstreams automatically.
• Professional outputs — Excel spreadsheets with working formulas (VLOOKUP, conditional formatting, multi-tab), PowerPoint decks, formatted Word documents, filled/merged/split PDFs — powered by built-in skills for xlsx, pptx, docx, and pdf.
• Claude in Chrome pairing — automate tasks on any website alongside file work.
• Long-running tasks — extended autonomous work without conversation timeouts.
• Scheduled tasks — on-demand or automatic on a schedule you set.
• Projects — persistent, self-contained workspaces with their own files, links, instructions, and memory.
• Extensibility — the same stack as everywhere else: Connectors (MCP), Skills, Plugins (official plugins include Asana, Canva, Cloudflare, Figma, GitHub, Google Drive, Jira, Linear, Notion, Sentry, Slack), and Monitoring for org-wide usage tracking.
• Enterprise controls (new at GA): role-based access controls, spend limits and use controls, analytics and visibility dashboards.
• Desktop-only for now: live artifacts and plugins that include local MCP servers.

7.3 Getting started & the golden rules

Enable via Settings → the Cowork/Code tab in Claude Desktop, then grant access to a folder. The community-converged best practice: start with a dedicated workspace folder (e.g., ~/Cowork-Workspace/{input,output}), not your entire Documents folder.

The mindset shift that unlocks Cowork — in Anthropic’s words, “it feels much less like a back-and-forth and much more like leaving messages for a coworker”:

1. Delegate outcomes, not steps. Define what “done” looks like before you prompt.
2. Give context and constraints — audience, format, tone, what to exclude.
3. Batch related work into one task to save usage.
4. Keep backups and monitor — it’s an agent touching real files; safety is your responsibility. Avoid pointing it at sensitive data while learning. Cowork respects your network egress permissions, but its agentic nature plus internet access carries real risk — review what it did.

7.4 A prompt template that consistently works in Cowork

Task: [outcome, not procedure — "a client-ready Word report", not "open the files"]
Source: [folder/files, e.g. ~/Cowork-Workspace/input/]
Done means: [format, sections, length, audience, naming, where to save]
Constraints: [exclude X, don't modify originals, cite sources, brand tone]
Code language: PHP (php)

Worked example (the pattern used in official-adjacent tutorials):

This folder contains our 2025 operating expenses. Analyze the data and
create a Word document report covering: total annual spending, breakdown
by category with percentages, the three largest expense categories, and
month-over-month trends. Save it to /output as expenses-report-2025.docx.
Code language: JavaScript (javascript)

7.5 High-leverage Cowork workflows

Files & admin: organize a Downloads folder by content (an invoice PDF goes to Accounting, an ebook PDF to Documentation — it reads, not just sorts by extension); drop receipts in a folder → formatted expense report; batch-rename, dedupe, archive by rule. Documents: research synthesis across 20+ mixed files (interviews, surveys, tickets) into themes and action items; meeting notes → minutes + task lists pushed to Asana/Linear via plugins; long-report assembly from scattered sources. Spreadsheets: real Excel models with formulas and formatting, not CSVs that need fixing; cross-file reconciliation; recurring weekly dashboards via scheduled tasks. Business ops: invoices, quotes, follow-up emails, prospect research — the documented sweet spot for small businesses. With Chrome: form filling, portal data extraction, web research feeding directly into local deliverables.

7.6 Claude Code vs. Cowork — which do I reach for?

They share plan usage limits, the MCP connector ecosystem, and the skills format — a skill you write once often serves both.

PART 8 — SECURITY, SAFETY & GOVERNANCE ESSENTIALS

Run agents least-privileged: scoped folders (Cowork) and permission rules/sandboxing (Code); --allowedTools for anything unattended; auto mode’s classifier plus hard deny rules for hands-off runs; the sandboxed Bash tool, dev containers, Docker, or VMs matched to your threat model. Treat hostile content (web pages, issue text, files) as a prompt-injection surface — auto mode explicitly screens for hostile-content-driven actions, and Cowork’s VM isolation plus network egress permissions exist for the same reason. For organizations: managed settings (device- or server-delivered), managed MCP allowlists, approved version ranges, gateways (Claude apps gateway or LiteLLM-style) for central credentials and per-user spend limits, OpenTelemetry for audit-grade visibility, and Zero Data Retention available for qualified Enterprise accounts. Anthropic does not train on Claude for Work data by default — see the data-usage doc for specifics per plan.

PART 9 — COMMON FAILURE PATTERNS (AND THE FIX)

PART 10 — CANONICAL RESOURCES

Claude Code: docs home code.claude.com/docs/en/overview · full index code.claude.com/docs/llms.txt · best practices /en/best-practices · costs /en/costs · changelog /en/changelog · weekly what’s-new /en/whats-new/ · prompt library /en/prompt-library · glossary /en/glossary Cowork: claude.com/docs/cowork/overview · Help Center: support.claude.com (“Get started with Claude Cowork”) Models & API: platform.claude.com/docs (models overview, what’s-new pages incl. Opus 5) · pricing: claude.com/pricing & platform.claude.com Product news: anthropic.com/news

Compiled July 28, 2026 from official Anthropic documentation and current pricing references. Plan-specific model availability and introductory pricing (notably Sonnet 5’s $2/$10 rate ending Aug 31, 2026, and Fable 5’s July 20 plan changes) are the details most likely to shift — verify on the official pages above before making budget commitments.

Rajesh Kumar

I’m Rajesh Kumar, a DevOps, SRE, DevSecOps, Cloud, and Platform Engineering expert passionate about sharing practical knowledge, real-world experiences, and industry best practices. I have worked at Cotocus and regularly write about technology, travel, investing, health, product reviews, and digital marketing through my various platforms.

I publish technical articles at DevOps School, travel stories at Holiday Landmark, stock market insights at Stocks Mantra, health and fitness guidance at My Medic Plus, product reviews at TrueReviewNow, and SEO and digital marketing strategies at Wizbrand.