{"id":77966,"date":"2026-07-28T05:00:02","date_gmt":"2026-07-28T05:00:02","guid":{"rendered":"https:\/\/www.devopsschool.com\/blog\/?p=77966"},"modified":"2026-07-28T05:00:05","modified_gmt":"2026-07-28T05:00:05","slug":"the-master-guide-to-claude-code-claude-cowork","status":"publish","type":"post","link":"https:\/\/www.devopsschool.com\/blog\/the-master-guide-to-claude-code-claude-cowork\/","title":{"rendered":"The Master Guide to Claude Code & Claude Cowork"},"content":{"rendered":"\n

Gold & Diamond Standard Edition \u2014 Verified against official docs as of July 28, 2026<\/h3>\n\n\n\n
\n

How this guide was built:<\/strong> 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 \u2014 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.<\/p>\n<\/blockquote>\n\n\n\n

\n\n\n\n

PART 0 \u2014 THE 30-SECOND MENTAL MODEL<\/h1>\n\n\n\n

Claude Code and Claude Cowork are the same agentic engine wearing two different outfits<\/strong>.<\/p>\n\n\n\n

    \n
  • Claude Code<\/strong>\u00a0= the engine pointed at\u00a0code<\/em>: terminal, IDE, desktop, web, CI. For developers.<\/li>\n\n\n\n
  • Claude Cowork<\/strong>\u00a0= the engine pointed at\u00a0knowledge work<\/em>: files, documents, spreadsheets, research, browsers. For everyone else (and for developers doing non-code work).<\/li>\n<\/ul>\n\n\n\n

    Both share one philosophy: you delegate outcomes, not keystrokes.<\/strong> 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<\/em>.<\/p>\n\n\n\n

    \n\n\n\n

    PART 1 \u2014 THE CLAUDE MODEL FAMILY (Deep Dive, July 2026)<\/h1>\n\n\n\n

    1.1 The current lineup at a glance<\/h2>\n\n\n\n
    Model<\/th>API string<\/th>Tier<\/th>Input \/ Output (per 1M tokens)<\/th>Context<\/th>Best for<\/th><\/tr><\/thead>
    Claude Fable 5<\/strong><\/td>claude-fable-5<\/code><\/td>Mythos-class frontier<\/td>$10 \/ $50<\/td>1M<\/td>Hardest reasoning & knowledge work<\/td><\/tr>
    Claude Mythos 5<\/strong><\/td>(restricted)<\/td>Mythos-class<\/td>$10 \/ $50<\/td>1M<\/td>Approved orgs only (no dual-use safeguards)<\/td><\/tr>
    Claude Opus 5<\/strong><\/td>claude-opus-5<\/code><\/td>Flagship (brand new)<\/td>$5 \/ $25<\/td>1M (default & max), 128K output<\/td>Deep reasoning, long-horizon agentic work<\/td><\/tr>
    Claude Opus 4.8<\/strong><\/td>claude-opus-4-8<\/code><\/td>Opus tier<\/td>$5 \/ $25<\/td>1M<\/td>The proven Claude Code workhorse<\/td><\/tr>
    Claude Sonnet 5<\/strong><\/td>claude-sonnet-5<\/code><\/td>Mid-tier flagship<\/td>$2 \/ $10 intro until Aug 31, 2026 \u2192 $3 \/ $15<\/td>1M<\/td>Everyday production, multi-agent, coding<\/td><\/tr>
    Claude Haiku 4.5<\/strong><\/td>claude-haiku-4-5-20251001<\/code><\/td>Fast\/cheap<\/td>$1 \/ $5<\/td>200K<\/td>High-volume, subagents, classification<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

    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.<\/p>\n\n\n\n

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

    1.2 Deep profile: each model<\/h2>\n\n\n\n

    Claude Fable 5 (released June 9, 2026)<\/h3>\n\n\n\n

    The first “Mythos-class” model \u2014 a new tier that sits above<\/em> Opus. The most intelligent generally available Claude. Fable 5 always uses extended thinking<\/strong> (it cannot be disabled), which is part of why its output is expensive. Its sibling Mythos 5<\/strong> 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 \u2014 check claude.com\/pricing for your plan’s exact terms.<\/p>\n\n\n\n

    Use Fable 5 when:<\/strong> the problem is genuinely at the frontier \u2014 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:<\/strong> routine coding, drafting, or anything Sonnet handles. At 5x Sonnet’s output price, habit-driven Fable use is the fastest way to burn budget.<\/p>\n\n\n\n

    Claude Opus 5 (released late July 2026 \u2014 days old)<\/h3>\n\n\n\n

    A step-change over Opus 4.8, with the largest gains in deep reasoning, agentic\/long-horizon tasks, and test-time compute scaling<\/strong>. Key specs: 1M-token context window (default and<\/em> maximum \u2014 no smaller variant), 128K max output, thinking on by default<\/strong>, and a breaking change to when thinking can be disabled. It supports mid-conversation tool changes<\/strong> (beta header mid-conversation-tool-changes-2026-07-01<\/code>) so agents can swap tools between turns while preserving the prompt cache. A Fast mode<\/strong> 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.<\/p>\n\n\n\n

    Use Opus 5 when:<\/strong> 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.<\/p>\n\n\n\n

    Claude Opus 4.8 (released late May 2026)<\/h3>\n\n\n\n

    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.<\/p>\n\n\n\n

    Claude Sonnet 5 (released June 30, 2026)<\/h3>\n\n\n\n

    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<\/strong> (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.<\/p>\n\n\n\n

    Claude Haiku 4.5<\/h3>\n\n\n\n

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

    How thinking\/effort works now<\/h3>\n\n\n\n

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

    1.3 The model-routing decision tree<\/h2>\n\n\n\n
      \n
    1. Is it high-volume, simple, or a subagent chore? \u2192\u00a0Haiku 4.5<\/strong><\/li>\n\n\n\n
    2. Is it normal coding, drafting, analysis, or agent work? \u2192\u00a0Sonnet 5<\/strong>\u00a0(near-free upgrade during intro pricing)<\/li>\n\n\n\n
    3. Is it a long autonomous run, hard refactor, or did Sonnet visibly struggle? \u2192\u00a0Opus 5<\/strong>\u00a0(or 4.8 for stability)<\/li>\n\n\n\n
    4. Did Opus fail, or is this frontier-difficulty knowledge work where quality is everything? \u2192\u00a0Fable 5<\/strong><\/li>\n\n\n\n
    5. Never route\u00a0up<\/em>\u00a0by default; route up on evidence. Never route\u00a0down<\/em>\u00a0mid-task if context continuity matters \u2014 a model switch invalidates the prompt cache and triggers one expensive uncached turn.<\/li>\n<\/ol>\n\n\n\n

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

      \n\n\n\n

      PART 2 \u2014 CLAUDE CODE: THE COMPLETE PICTURE<\/h1>\n\n\n\n

      2.1 What it is<\/h2>\n\n\n\n

      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<\/strong>: choose tool \u2192 execute \u2192 read result \u2192 decide next step \u2192 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<\/strong>.<\/p>\n\n\n\n

      2.2 Every surface (and when to use each)<\/h2>\n\n\n\n
      Surface<\/th>What it’s for<\/th><\/tr><\/thead>
      Terminal CLI<\/strong><\/td>Full-featured core. Scripting, piping, everything.<\/td><\/tr>
      VS Code \/ Cursor extension<\/strong><\/td>Inline diffs, @-mentions, plan review, conversation history in-editor.<\/td><\/tr>
      JetBrains plugin<\/strong><\/td>IntelliJ\/PyCharm\/WebStorm with interactive diff viewing.<\/td><\/tr>
      Desktop app<\/strong><\/td>Parallel sessions with git-worktree isolation, visual diff review, drag-and-drop panes, integrated terminal\/editor, scheduled tasks, computer use, Dispatch from phone, PR monitoring.<\/td><\/tr>
      Web (claude.ai\/code)<\/strong><\/td>Cloud sessions in isolated VMs, no local setup, long-running tasks, works from any browser.<\/td><\/tr>
      Mobile app<\/strong><\/td>Kick off and monitor cloud sessions; Remote Control of local sessions; push notifications when Claude needs you.<\/td><\/tr>
      Slack (@Claude)<\/strong><\/td>Route a bug report from chat, get a PR back.<\/td><\/tr>
      GitHub Actions \/ GitLab CI<\/strong><\/td>Automated PR review, issue triage, CI automation.<\/td><\/tr>
      Chrome (beta)<\/strong><\/td>Live web-app debugging, console logs, form automation, data extraction.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

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

      2.3 Installation (current official methods)<\/h2>\n\n\n\n

      Native install (recommended \u2014 auto-updates):<\/p>\n\n\n

      <em<\/span>><\/span># macOS \/ Linux \/ WSL<\/em<\/span>><\/span>\ncurl -fsSL https:\/\/claude.ai\/install.sh | bash\n<em<\/span>><\/span># Windows PowerShell<\/em<\/span>><\/span>\nirm https:\/\/claude.ai\/install.ps1 | iex\n<\/code><\/span>Code language:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
      Also available: brew install --cask claude-code<\/code> (or claude-code@latest<\/code> channel), winget install Anthropic.ClaudeCode<\/code>, and apt\/dnf\/apk on Linux. Homebrew and WinGet do not<\/strong> auto-update. On native Windows, install Git for Windows so Claude gets a Bash tool (otherwise it uses PowerShell). Then:<\/p>\n\n\n
      cd your-project && claude\n<\/code><\/span><\/pre>\n\n\n
      2.4 The one constraint that explains everything: the context window<\/h2>\n\n\n\n
      Nearly every best practice exists because of this: the context window holds your whole conversation \u2014 every message, every file read, every command output \u2014 and model performance degrades as it fills.<\/strong> 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<\/code>, and see Part 6 for the full reduction playbook.<\/p>\n\n\n\n
      2.5 Permission modes (Shift+Tab cycles them)<\/h2>\n\n\n\n
      Mode<\/th>Behavior<\/th><\/tr><\/thead>
      Default<\/strong><\/td>Asks before file writes, Bash, MCP tools. Safe but click-heavy.<\/td><\/tr>
      Plan mode<\/strong><\/td>Read-only exploration and planning. No changes. Ctrl+G<\/code> opens the plan in your editor.<\/td><\/tr>
      acceptEdits<\/strong><\/td>Auto-approves file edits (with a prompt before writing files that can run code).<\/td><\/tr>
      Auto mode<\/strong><\/td>A separate classifier model reviews every action and blocks only what looks risky \u2014 scope escalation, unknown infrastructure, hostile-content-driven actions. Hands-off execution with a safety net. Available on Pro+, works with Sonnet, on Bedrock\/Vertex\/Foundry too. Configure trusted repos\/domains with the auto-mode<\/code> CLI subcommands; supports hard deny rules.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
      Fine-grained control: \/permissions<\/code> allowlists specific commands (e.g., npm run lint<\/code>, git commit<\/code>), --allowedTools \"Edit,Bash(git commit *)\"<\/code> scopes headless runs, deny\/ask rules can match tool parameters<\/em>, and \/sandbox<\/code> enables the sandboxed Bash tool<\/strong> \u2014 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).<\/p>\n\n\n\n
      2.6 Sessions, checkpoints, and time travel<\/h2>\n\n\n\n
      Every prompt creates a checkpoint<\/strong>; Claude snapshots files before each change. Esc<\/code> stops Claude mid-action (context preserved). Esc Esc<\/code> or \/rewind<\/code> opens the rewind menu: restore conversation, code, or both, or summarize from\/up to<\/em> a point (partial compaction). Checkpoints persist across sessions \u2014 but they only track Claude’s changes; they’re not a git replacement.<\/p>\n\n\n\n
      Sessions are persistent: claude --continue<\/code> resumes the latest, claude --resume<\/code> shows a picker, \/rename<\/code> names a session (treat sessions like branches: oauth-migration<\/code>), --from-pr<\/code> finds the session that created a PR (you can even paste a PR URL into \/resume<\/code>), and \/rewind<\/code> can resume a conversation from before a \/clear<\/code>. Transcripts are stored locally and searchable across projects with Ctrl+R<\/code>.<\/p>\n\n\n\n
      \n\n\n\n
      PART 3 \u2014 THE EXTENSION SYSTEM (CLAUDE.md, Skills, Subagents, Hooks, MCP, Plugins)<\/h1>\n\n\n\n
      This is the customization hierarchy. Choosing the right<\/em> mechanism is the difference between a tuned instrument and a bloated mess.<\/p>\n\n\n\n
      Mechanism<\/th>Loads<\/th>Use for<\/th><\/tr><\/thead>
      CLAUDE.md<\/strong><\/td>Every session, always<\/td>Universal rules only: build commands, style deviations, repo etiquette<\/td><\/tr>
      Auto memory<\/strong><\/td>Automatic<\/td>Claude saves its own learnings (build quirks, debug insights) across sessions<\/td><\/tr>
      Skills<\/strong><\/td>On demand<\/td>Domain knowledge & repeatable workflows (\/review-pr<\/code>, \/deploy-staging<\/code>)<\/td><\/tr>
      Subagents<\/strong><\/td>When delegated<\/td>Isolated-context specialists (research, review) with their own tools\/model<\/td><\/tr>
      Hooks<\/strong><\/td>Deterministically, on events<\/td>Things that must happen every time<\/em>: format after edit, lint before commit, block writes to migrations\/<\/code><\/td><\/tr>
      MCP servers<\/strong><\/td>Configured per project\/user<\/td>External tools & data: Jira, Figma, databases, Slack, your own APIs<\/td><\/tr>
      Plugins<\/strong><\/td>Installed<\/td>Bundles of all of the above, shareable via marketplaces (\/plugin<\/code>)<\/td><\/tr>
      Output styles<\/strong><\/td>Selected<\/td>Repurpose Claude Code beyond engineering<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
      3.1 CLAUDE.md \u2014 write it like code<\/h2>\n\n\n\n
      Run \/init<\/code> to generate a starter from your codebase, then prune ruthlessly. The official test for every line: “Would removing this cause Claude to make mistakes?”<\/em> If not, cut it. Bloated CLAUDE.md files cause Claude to ignore your actual instructions.<\/strong> Aim for under ~200 lines.<\/p>\n\n\n\n
      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.<\/p>\n\n\n\n
      Power moves: add emphasis (“IMPORTANT”, “YOU MUST”) to rules Claude skips; import files with @path\/to\/file<\/code> syntax; add compaction instructions (# Compact instructions \u2014 always preserve modified-file list and test commands<\/code>); check it into git so it compounds.<\/p>\n\n\n\n
      Placement: ~\/.claude\/CLAUDE.md<\/code> (all sessions), .\/CLAUDE.md<\/code> (project, shared), .\/CLAUDE.local.md<\/code> (personal, gitignored), parent dirs (monorepo roots), child dirs (pulled in on demand \u2014 the key pattern for large codebases and monorepos).<\/p>\n\n\n\n
      3.2 Skills<\/h2>\n\n\n\n
      A directory with a SKILL.md<\/code> in .claude\/skills\/<\/code>. Claude applies them automatically when relevant, or you invoke directly as \/skill-name arguments<\/code>. Two flavors:<\/p>\n\n\n
      ---\nname: api-conventions\ndescription: REST API design conventions for<\/span> our services\n---\n# API Conventions<\/span>\n- kebab-case<\/span> URL paths, camelCase JSON, pagination on list<\/span> endpoints, \/v1\/ versioning\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n
      ---\nname: fix-issue\ndescription<\/span>: Fix a GitHub issue\ndisable-model-invocation: true<\/span>\n---\nAnalyze and fix GitHub issue: $ARGUMENTS.\n1.<\/span> `gh issue view`<\/span> for<\/span> details  2.<\/span> Understand  3.<\/span> Search codebase\n4.<\/span> Implement fix  5.<\/span> Write & run tests  6.<\/span> Lint\/typecheck  7.<\/span> Commit, push, PR\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      disable-model-invocation: true<\/code> = manual-only, for workflows with side effects (\/fix-issue 1234<\/code>). Key cost insight:<\/strong> skills load on demand, so moving specialized instructions out of CLAUDE.md into skills keeps every session’s base context small.<\/p>\n\n\n\n
      3.3 Subagents<\/h2>\n\n\n\n
      Markdown files in .claude\/agents\/<\/code> defining specialists with their own context window, tool allowlist, and model:<\/p>\n\n\n
      ---\nname: security-reviewer\ndescription: Reviews code for security vulnerabilities\ntools: Read, Grep, Glob, Bash\nmodel: opus\n---\nYou are a senior security engineer. Review for injection, authz flaws,\nsecrets in code, insecure data handling. Give line references and fixes.\n<\/code><\/span><\/pre>\n\n\n
      Invoke explicitly: “Use a subagent to review this code for security issues.”<\/em> Why subagents are the single most powerful context tool: research that would flood your main context happens in a separate context<\/strong>, and only a summary returns. Since June 2026, subagents can spawn their own subagents. Use model: haiku<\/code> for grunt work.<\/p>\n\n\n\n
      3.4 Hooks<\/h2>\n\n\n\n
      Deterministic scripts at lifecycle events (PreToolUse, PostToolUse, Stop, and more \u2014 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.”<\/em> Browse configured hooks with \/hooks<\/code>. A killer cost pattern appears in Part 6 (test-output filtering).<\/p>\n\n\n\n
      3.5 MCP<\/h2>\n\n\n\n
      claude mcp add<\/code> connects servers; claude mcp login<\/code> authenticates from the shell; \/mcp<\/code> lists and toggles them. MCP tool definitions are deferred by default<\/strong> \u2014 only names enter context until a tool is actually used (tool search handles thousand-tool fleets). Still, prefer CLI tools (gh<\/code>, aws<\/code>, gcloud<\/code>, sentry-cli<\/code>) when they exist<\/strong> \u2014 they add zero per-tool context. Claude learns unknown CLIs from --help<\/code>. Orgs can allowlist\/denylist servers via managed MCP configuration.<\/p>\n\n\n\n
      3.6 Plugins<\/h2>\n\n\n\n
      \/plugin<\/code> opens the marketplace; plugins bundle skills + hooks + subagents + MCP into one install, loadable even from .zip archives and URLs. Two standouts: code intelligence plugins<\/strong> for typed languages (precise symbol navigation, automatic type-error reporting after edits \u2014 a big token saver) and the security-guidance plugin<\/strong> (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.<\/p>\n\n\n\n
      \n\n\n\n
      PART 4 \u2014 COMMAND, FLAG & SHORTCUT REFERENCE<\/h1>\n\n\n\n
      4.1 Essential slash commands<\/h2>\n\n\n\n
      Command<\/th>What it does<\/th><\/tr><\/thead>
      \/init<\/code><\/td>Generate starter CLAUDE.md from your codebase<\/td><\/tr>
      \/clear<\/code><\/td>Wipe context \u2014 the most important habit in this guide<\/td><\/tr>
      \/compact [instructions]<\/code><\/td>Summarize history, optionally steering what to keep<\/td><\/tr>
      \/rewind<\/code><\/td>Restore conversation\/code to a checkpoint, or summarize a range<\/td><\/tr>
      \/model<\/code><\/td>Switch models mid-session (also lists gateway models)<\/td><\/tr>
      \/effort<\/code><\/td>Adjust thinking effort level (low \u2192 max)<\/td><\/tr>
      \/config<\/code><\/td>Set any setting from the prompt; defaults incl. model & thinking<\/td><\/tr>
      \/permissions<\/code><\/td>Manage allowlists (commands, domains)<\/td><\/tr>
      \/sandbox<\/code><\/td>Toggle OS-level sandboxed Bash<\/td><\/tr>
      \/usage<\/code><\/td>Token\/cost stats + plan limit bars + what’s driving usage (skills, MCP, cache misses)<\/td><\/tr>
      \/usage-credits<\/code><\/td>Manage or request extra usage beyond plan limits<\/td><\/tr>
      \/context<\/code><\/td>See exactly what’s consuming your context window<\/td><\/tr>
      \/doctor<\/code>, \/hooks<\/code>, \/mcp<\/code><\/td>Debug what actually loaded<\/td><\/tr>
      \/resume<\/code>, \/rename<\/code><\/td>Session management (paste a PR URL into \/resume!)<\/td><\/tr>
      \/goal<\/code><\/td>Set a completion condition; an evaluator keeps Claude working until it holds<\/td><\/tr>
      \/loop<\/code><\/td>Repeat a prompt within a session (polling, reminders)<\/td><\/tr>
      \/schedule<\/code><\/td>Create cloud Routines from the CLI<\/td><\/tr>
      \/code-review<\/code><\/td>Fresh-subagent diff review; \/code-review ultra<\/code> = deep multi-agent cloud review<\/td><\/tr>
      \/btw<\/code><\/td>Side question answered in an overlay that never enters context<\/td><\/tr>
      \/cd<\/code><\/td>Move the session to a new directory<\/td><\/tr>
      \/desktop<\/code><\/td>Continue this terminal session in the Desktop app<\/td><\/tr>
      \/team-onboarding<\/code><\/td>Package your setup for teammates<\/td><\/tr>
      \/plugin<\/code><\/td>Browse\/install plugins (\/plugin list<\/code> shows installed)<\/td><\/tr>
      !command<\/code><\/td>Shell mode; Claude responds to the output<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
      4.2 Essential CLI flags<\/h2>\n\n\n
      claude                       <em<\/span>><\/span># interactive session<\/em<\/span>><\/span>\nclaude -p \"prompt\"           <em<\/span>><\/span># headless\/non-interactive (CI, scripts, pipes)<\/em<\/span>><\/span>\nclaude -p \"...\" --output-format json          <em<\/span>><\/span># parseable output<\/em<\/span>><\/span>\nclaude -p \"...\" --output-format stream-json --verbose\nclaude --continue            <em<\/span>><\/span># resume most recent session<\/em<\/span>><\/span>\nclaude --resume              <em<\/span>><\/span># session picker<\/em<\/span>><\/span>\nclaude --worktree            <em<\/span>><\/span># isolated git worktree session<\/em<\/span>><\/span>\nclaude --cloud               <em<\/span>><\/span># push task to Claude Code on the web<\/em<\/span>><\/span>\nclaude --teleport            <em<\/span>><\/span># pull a web session into your terminal<\/em<\/span>><\/span>\nclaude --from-pr <pr<\/span>><\/span>        <em<\/span>><\/span># resume the session that made a PR<\/em<\/span>><\/span>\nclaude --permission-mode auto -p \"fix all lint errors\"\nclaude --allowedTools \"Edit,Bash(git commit *)\" -p \"...\"\nclaude --debug               <em<\/span>><\/span># verbose debugging incl. hook rewrites<\/em<\/span>><\/span>\nclaude mcp add \/ claude mcp login\nclaude project purge [path]  <em<\/span>><\/span># delete all local state for a project<\/em<\/span>><\/span>\ncat error.log | claude       <em<\/span>><\/span># pipe anything in<\/em<\/span>><\/span>\n<\/code><\/span>Code language:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
      4.3 Keyboard<\/h2>\n\n\n\n
      Esc<\/code> stop mid-action \u00b7 Esc Esc<\/code> rewind menu \u00b7 Shift+Tab<\/code> cycle permission modes \u00b7 Ctrl+G<\/code> edit plan in your editor \u00b7 Ctrl+R<\/code> search command history across projects \u00b7 @file<\/code> reference files \u00b7 paste\/drag images directly \u00b7 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.<\/p>\n\n\n\n
      \n\n\n\n
      PART 5 \u2014 GOLDEN WORKFLOWS & PROMPTING MASTERY<\/h1>\n\n\n\n
      5.1 The #1 principle: give Claude a way to verify its work<\/h2>\n\n\n\n
      \n
      Official guidance, verbatim spirit: give Claude a check it can run \u2014 tests, a build, a screenshot to compare. It’s the difference between a session you watch and one you walk away from.<\/em><\/p>\n<\/blockquote>\n\n\n\n
      Without a runnable check, “looks done” is Claude’s only signal and you<\/strong> become the verification loop. With one, Claude iterates until it passes. Four escalating ways to enforce it:<\/p>\n\n\n\n
        \n
      1. In the prompt:<\/strong>\u00a0“\u2026run the tests after implementing and fix failures.”<\/li>\n\n\n\n
      2. Across the session:<\/strong>\u00a0\/goal<\/code>\u00a0\u2014 an evaluator re-checks the condition after every turn.<\/li>\n\n\n\n
      3. Deterministic gate:<\/strong>\u00a0a Stop hook runs your check as a script and blocks the turn from ending until it passes (overridden after 8 consecutive blocks).<\/li>\n\n\n\n
      4. Second opinion:<\/strong>\u00a0a verification subagent or dynamic workflow where a fresh model tries to refute the result.<\/li>\n<\/ol>\n\n\n\n
        Always ask Claude to show evidence<\/strong> \u2014 test output, commands run, screenshots \u2014 rather than asserting success.<\/p>\n\n\n\n
        5.2 Explore \u2192 Plan \u2192 Code \u2192 Commit<\/h2>\n\n\n\n
        The canonical workflow for anything non-trivial:<\/p>\n\n\n\n
          \n
        1. Explore<\/strong>\u00a0(plan mode): “read \/src\/auth and understand how we handle sessions and login.”<\/li>\n\n\n\n
        2. Plan<\/strong>\u00a0(plan mode): “I want to add Google OAuth. What files change? What’s the session flow? Create a plan.” Then\u00a0Ctrl+G<\/code>\u00a0to edit the plan directly.<\/li>\n\n\n\n
        3. Implement<\/strong>\u00a0(default mode): “implement the OAuth flow from your plan. write tests for the callback handler, run the suite, fix failures.”<\/li>\n\n\n\n
        4. Commit:<\/strong>\u00a0“commit with a descriptive message and open a PR.”<\/li>\n<\/ol>\n\n\n\n
          Skip planning when you could describe the diff in one sentence \u2014 plan mode adds overhead for typo-fixes.<\/p>\n\n\n\n
          5.3 Prompt engineering: the before\/after patterns (official)<\/h2>\n\n\n\n
          Technique<\/th>Weak<\/th>Strong<\/th><\/tr><\/thead>
          Scope the task<\/td>“add tests for foo.py”<\/td>“write a test for foo.py covering the logged-out edge case. avoid mocks.”<\/td><\/tr>
          Point to sources<\/td>“why is this API weird?”<\/td>“look through ExecutionFactory’s git history and summarize how its API came to be”<\/td><\/tr>
          Reference patterns<\/td>“add a calendar widget”<\/td>“study how existing widgets work \u2014 HotDogWidget.php is a good example \u2014 and follow that pattern to build a calendar widget. no new libraries.”<\/td><\/tr>
          Describe the symptom<\/td>“fix the login bug”<\/td>“users report login fails after session timeout. check src\/auth\/, especially token refresh. write a failing test that reproduces it, then fix it.”<\/td><\/tr>
          Verification criteria<\/td>“implement email validation”<\/td>“write validateEmail. test cases: user@example.com\u2192true, invalid\u2192false, user@.com\u2192false. run tests after implementing.”<\/td><\/tr>
          Root cause<\/td>“the build is failing”<\/td>“build fails with [error]. fix it, verify the build succeeds, address the root cause \u2014 don’t suppress the error.”<\/td><\/tr>
          Visual work<\/td>“make the dashboard look better”<\/td>“[screenshot] implement this design. screenshot your result, compare, list differences, fix them.”<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
          Vague prompts are<\/em> right for exploration (“what would you improve in this file?”).<\/p>\n\n\n\n
          5.4 The most effective prompt prefixes & templates<\/h2>\n\n\n\n
          The Interview pattern<\/strong> (official \u2014 best for large features):<\/p>\n\n\n
          I want to build [brief description]. Interview me in detail using the\nAskUserQuestion tool. Ask about technical implementation, UI\/UX, edge\ncases, concerns, and<\/span> tradeoffs. Don't ask obvious questions \u2014 dig into\nthe hard parts I might not have considered. Keep interviewing until\nwe'<\/span>ve covered everything, then write a complete spec to SPEC.md.\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
          Then start a fresh session<\/strong> to execute the spec with clean context.<\/p>\n\n\n\n
          The Investigation delegate:<\/strong><\/p>\n\n\n
          Use<\/span> subagents<\/span> to<\/span> investigate<\/span> how<\/span> our<\/span> authentication<\/span> system<\/span> handles<\/span> token<\/span>\nrefresh<\/span>, and<\/span> whether<\/span> we<\/span> have<\/span> existing<\/span> OAuth<\/span> utilities<\/span> I<\/span> should<\/span> reuse<\/span>.\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
          The Adversarial reviewer:<\/strong><\/p>\n\n\n
          Use<\/span> a<\/span> subagent<\/span> to<\/span> review<\/span> the<\/span> rate<\/span> limiter<\/span> diff<\/span> against<\/span> PLAN<\/span>.md<\/span>. Check<\/span> that<\/span>\nevery<\/span> requirement<\/span> is<\/span> implemented<\/span>, listed<\/span> edge<\/span> cases<\/span> have<\/span> tests<\/span>, and<\/span> nothing<\/span>\noutside<\/span> scope<\/span> changed<\/span>. Report<\/span> gaps<\/span>, not<\/span> style<\/span> preferences<\/span>.\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
          (Warn the reviewer off nitpicks \u2014 reviewers asked to find gaps will find some even in sound work; only correctness findings matter.)<\/p>\n\n\n\n
          The CLI-learning prefix:<\/strong> Use 'foo-cli --help' to learn the tool, then use it to solve A, B, C.<\/code><\/p>\n\n\n\n
          The onboarding prompts<\/strong> (no special phrasing needed \u2014 ask like you’d ask a senior engineer): “How does logging work?” \u00b7 “How do I add a new API endpoint?” \u00b7 “What edge cases does CustomerOnboardingFlowImpl handle?”<\/p>\n\n\n\n
          5.5 Scaling: parallel Claudes<\/h2>\n\n\n\n
            \n
          • Worktrees<\/strong>\u00a0(--worktree<\/code>): parallel CLI sessions in isolated git checkouts.<\/li>\n\n\n\n
          • Desktop app:<\/strong>\u00a0parallel sessions visually, each in its own worktree.<\/li>\n\n\n\n
          • Web:<\/strong>\u00a0cloud sessions in isolated VMs; fire-and-forget from your phone.<\/li>\n\n\n\n
          • Agent view:<\/strong>\u00a0dispatch and monitor many sessions from one screen; see who needs input.<\/li>\n\n\n\n
          • Agent teams:<\/strong>\u00a0multiple coordinated instances with shared tasks, inter-agent messaging, and a lead. Experimental \u2014 enable with\u00a0CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1<\/code>. Costs ~7x a normal session; keep teams small, use Sonnet teammates, shut idle teammates down.<\/li>\n\n\n\n
          • Dynamic workflows:<\/strong>\u00a0Claude writes an orchestration script that fans subagents out over audits, migrations, and cross-checked research \u2014 rerunnable.<\/li>\n\n\n\n
          • Writer\/Reviewer pattern:<\/strong>\u00a0Session A implements; Session B (fresh context, unbiased) reviews; feed the review back to A. Same trick works as test-writer vs. implementer.<\/li>\n\n\n\n
          • Fan-out for migrations:<\/strong>\u00a0have Claude generate the file list, then loop\u00a0claude -p \"Migrate $file\u2026 Return OK or FAIL\" --allowedTools \"Edit,Bash(git commit *)\"<\/code>. Test on 2\u20133 files, refine the prompt, then run at scale.<\/li>\n<\/ul>\n\n\n\n
            5.6 Automation & always-on Claude<\/h2>\n\n\n\n
              \n
            • Routines:<\/strong>\u00a0scheduled or event-triggered runs on Anthropic-managed cloud infra (works while your laptop sleeps); trigger on cron, API calls, or GitHub events. Create via\u00a0\/schedule<\/code>, web, or Desktop.<\/li>\n\n\n\n
            • Desktop scheduled tasks:<\/strong>\u00a0recurring runs on\u00a0your<\/em>\u00a0machine with local file\/tool access.<\/li>\n\n\n\n
            • Channels:<\/strong>\u00a0push webhooks, CI results, chat messages\u00a0into<\/em>\u00a0a running session via MCP so Claude reacts while you’re away.<\/li>\n\n\n\n
            • Deep links:<\/strong>\u00a0claude-cli:\/\/<\/code>\u00a0URLs in runbooks\/alerts open Claude in the right repo with the right prompt.<\/li>\n\n\n\n
            • GitHub Code Review \/ \/autofix-pr:<\/strong>\u00a0automatic multi-agent review on every PR; auto-fix from terminal or cloud.<\/li>\n\n\n\n
            • Ultraplan:<\/strong>\u00a0start a plan in the CLI, draft it on the web, execute remotely or locally.<\/li>\n\n\n\n
            • Computer use (CLI & Desktop):<\/strong>\u00a0Claude opens apps, clicks, types, and sees your screen on macOS \u2014 test native apps and GUI-only tools.<\/li>\n\n\n\n
            • Advisor tool:<\/strong>\u00a0pair your main model with a stronger advisor model consulted at key decision moments \u2014 Sonnet does the work, Opus\/Fable advises.<\/li>\n<\/ul>\n\n\n\n
              \n\n\n\n
              PART 6 \u2014 THE COST MASTERY PLAYBOOK<\/h1>\n\n\n\n
              6.1 Ground truth on billing<\/h2>\n\n\n\n
              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<\/strong> let you keep working past limits. Enterprise benchmark: ~$13 per developer per active day on average, $150\u2013250\/month, with 90% of users under $30\/day.<\/strong> Budget more for a coding seat than a chat seat \u2014 one debugging session can outconsume a day of chat.<\/p>\n\n\n\n
              Track: \/usage<\/code> (session tokens, plan bars, and a breakdown attributing usage to skills, subagents, plugins, MCP servers \u2014 flagging long-context or cache-miss behavior at \u226510%), \/context<\/code>, 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.<\/p>\n\n\n\n
              6.2 Why usage silently climbs (the four traps)<\/h2>\n\n\n\n
                \n
              1. Long context:<\/strong>\u00a0every message resends the whole conversation \u2014 a one-liner in an all-day session pays for the whole session.<\/li>\n\n\n\n
              2. Cache misses:<\/strong>\u00a0return after the cache lifetime (1 hour on subscription; 5 minutes on usage credits\/API) and your next message reprocesses the entire context uncached.<\/li>\n\n\n\n
              3. Idle burners:<\/strong>\u00a0scheduled\u00a0\/loop<\/code>\u00a0tasks and active agent teammates keep consuming while you’re away.<\/li>\n\n\n\n
              4. Compaction cost:<\/strong>\u00a0\/compact<\/code>\u00a0reads<\/em>\u00a0everything it summarizes \u2014 compacting a huge context is itself a huge request.\u00a0When you don’t need continuity,\u00a0\/clear<\/code>\u00a0costs nothing.<\/strong><\/li>\n<\/ol>\n\n\n\n
                6.3 The complete reduction checklist (highest impact first)<\/h2>\n\n\n\n
                  \n
                1. \/clear<\/code>\u00a0between unrelated tasks.<\/strong>\u00a0The single highest-impact habit.\u00a0\/rename<\/code>\u00a0first so you can\u00a0\/resume<\/code>\u00a0later.<\/li>\n\n\n\n
                2. Match the model to the job.<\/strong>\u00a0Sonnet for most work; Opus only for hard problems;\u00a0model: haiku<\/code>\u00a0in subagent configs;\u00a0opusplan<\/code>\u00a0to plan expensive and execute cheap.<\/li>\n\n\n\n
                3. Tune thinking.<\/strong>\u00a0Lower\u00a0\/effort<\/code>\u00a0for simple work, disable thinking in\u00a0\/config<\/code>\u00a0where allowed (not on Fable 5), or\u00a0MAX_THINKING_TOKENS=8000<\/code>\u00a0on fixed-budget models. Thinking bills as output tokens \u2014 the expensive kind.<\/li>\n\n\n\n
                4. Delegate verbose operations to subagents<\/strong>\u00a0\u2014 test runs, doc fetches, log processing stay in the subagent’s context; only summaries return.<\/li>\n\n\n\n
                5. Prefer CLI tools over MCP; disable unused MCP servers<\/strong>\u00a0(\/mcp<\/code>).<\/li>\n\n\n\n
                6. Preprocess with hooks.<\/strong>\u00a0The official flagship example \u2014 a PreToolUse hook that rewrites test commands to return only failures, turning a 10,000-line log into a few hundred tokens:<\/li>\n<\/ol>\n\n\n
                  #!\/bin\/bash<\/span>\ninput=$(cat); cmd=$(echo<\/span> \"$input\"<\/span> | jq -r '.tool_input.command'<\/span>)\nif<\/span> [[ \"$cmd\"<\/span> =~ ^(npm test|pytest|go test) ]]; then\n  filtered=\"$cmd 2>&1 | grep -A 5 -E '(FAIL|ERROR|error:)' | head -100\"<\/span>\n  echo<\/span> \"{\\\"hookSpecificOutput\\\":{\\\"hookEventName\\\":\\\"PreToolUse\\\",\\\"permissionDecision\\\":\\\"allow\\\",\\\"updatedInput\\\":{\\\"command\\\":\\\"$filtered\\\"}}}\"<\/span>\nelse<\/span> echo<\/span> \"{}\"<\/span>; fi\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
                    \n
                  1. Move workflow instructions from CLAUDE.md into skills<\/strong>\u00a0(on-demand loading). Keep CLAUDE.md under ~200 lines.<\/li>\n\n\n\n
                  2. Install code intelligence plugins<\/strong>\u00a0for typed languages \u2014 one go-to-definition replaces a grep plus several speculative file reads.<\/li>\n\n\n\n
                  3. Write specific prompts.<\/strong>\u00a0“Improve this codebase” triggers broad scanning; “add input validation to the login function in auth.ts” doesn’t.<\/li>\n\n\n\n
                  4. Plan mode for complex work<\/strong>\u00a0\u2014 wrong-direction rework is the most expensive token sink of all. Course-correct with\u00a0Esc<\/code>\u00a0early; after two failed corrections,\u00a0\/clear<\/code>\u00a0and re-prompt with what you learned.<\/li>\n\n\n\n
                  5. Custom compaction instructions<\/strong>\u00a0(\/compact Focus on the API changes<\/code>) so summaries keep what matters.<\/li>\n\n\n\n
                  6. \/btw<\/code>\u00a0for side questions<\/strong>\u00a0\u2014 answered in an overlay, never enters context.<\/li>\n\n\n\n
                  7. On the raw API:<\/strong>\u00a0prompt caching (~90% off cache hits) and the Batch API (50% off everything non-urgent).<\/li>\n\n\n\n
                  8. Know the cache mechanics:<\/strong>\u00a0model 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.<\/li>\n<\/ol>\n\n\n\n
                    \n\n\n\n
                    PART 7 \u2014 CLAUDE COWORK: THE COMPLETE PICTURE<\/h1>\n\n\n\n
                    7.1 What it is<\/h2>\n\n\n\n
                    Cowork is Anthropic’s agentic workspace<\/strong> \u2014 the same architecture as Claude Code, aimed at knowledge work, no terminal required. Officially: describe a desired outcome, then return later to completed work \u2014 polished documents, organized files, synthesized research, and more.<\/em> 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<\/strong>, with remote sessions (beta) making your sessions and files follow your account across desktop, web, and mobile. Chat and Cowork now share one home \u2014 delegating a task starts from the same message box as a conversation.<\/p>\n\n\n\n
                    7.2 Key capabilities (official)<\/h2>\n\n\n\n
                      \n
                    • Works directly on your computer<\/strong>\u00a0\u2014 reads and writes local files, no manual uploads\/downloads. Execution happens in an isolated virtual-machine environment for safety.<\/li>\n\n\n\n
                    • Sub-agent coordination<\/strong>\u00a0\u2014 complex work is split into parallel workstreams automatically.<\/li>\n\n\n\n
                    • Professional outputs<\/strong>\u00a0\u2014 Excel spreadsheets with\u00a0working formulas<\/em>\u00a0(VLOOKUP, conditional formatting, multi-tab), PowerPoint decks, formatted Word documents, filled\/merged\/split PDFs \u2014 powered by built-in skills for xlsx, pptx, docx, and pdf.<\/li>\n\n\n\n
                    • Claude in Chrome pairing<\/strong>\u00a0\u2014 automate tasks on any website alongside file work.<\/li>\n\n\n\n
                    • Long-running tasks<\/strong>\u00a0\u2014 extended autonomous work without conversation timeouts.<\/li>\n\n\n\n
                    • Scheduled tasks<\/strong>\u00a0\u2014 on-demand or automatic on a schedule you set.<\/li>\n\n\n\n
                    • Projects<\/strong>\u00a0\u2014 persistent, self-contained workspaces with their own files, links, instructions, and memory.<\/li>\n\n\n\n
                    • Extensibility<\/strong>\u00a0\u2014 the same stack as everywhere else:\u00a0Connectors (MCP)<\/strong>,\u00a0Skills<\/strong>,\u00a0Plugins<\/strong>\u00a0(official plugins include Asana, Canva, Cloudflare, Figma, GitHub, Google Drive, Jira, Linear, Notion, Sentry, Slack), and\u00a0Monitoring<\/strong>\u00a0for org-wide usage tracking.<\/li>\n\n\n\n
                    • Enterprise controls (new at GA):<\/strong>\u00a0role-based access controls, spend limits and use controls, analytics and visibility dashboards.<\/li>\n\n\n\n
                    • Desktop-only for now: live artifacts and plugins that include\u00a0local<\/em>\u00a0MCP servers.<\/li>\n<\/ul>\n\n\n\n
                      7.3 Getting started & the golden rules<\/h2>\n\n\n\n
                      Enable via Settings \u2192 the Cowork\/Code tab in Claude Desktop, then grant access to a folder. The community-converged best practice: start with a dedicated workspace folder<\/strong> (e.g., ~\/Cowork-Workspace\/{input,output}<\/code>), not your entire Documents folder.<\/p>\n\n\n\n
                      The mindset shift that unlocks Cowork \u2014 in Anthropic’s words, “it feels much less like a back-and-forth and much more like leaving messages for a coworker”<\/em>:<\/p>\n\n\n\n
                        \n
                      1. Delegate outcomes, not steps.<\/strong>\u00a0Define what “done” looks like before you prompt.<\/li>\n\n\n\n
                      2. Give context and constraints<\/strong>\u00a0\u2014 audience, format, tone, what to exclude.<\/li>\n\n\n\n
                      3. Batch related work<\/strong>\u00a0into one task to save usage.<\/li>\n\n\n\n
                      4. Keep backups and monitor<\/strong>\u00a0\u2014 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 \u2014 review what it did.<\/li>\n<\/ol>\n\n\n\n
                        7.4 A prompt template that consistently works in Cowork<\/h2>\n\n\n
                        Task: [outcome, not procedure \u2014 \"a client-ready Word report\"<\/span>, not \"open the files\"<\/span>]\nSource: [folder\/files, e.g. ~\/Cowork-Workspace\/input\/]\nDone means: [format, sections, length, audience, naming, where to save]\nConstraints: [exclude X, don't modify originals, cite sources, brand tone]\n<\/span><\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
                        Worked example (the pattern used in official-adjacent tutorials):<\/p>\n\n\n
                        This folder contains our 2025<\/span> operating expenses. Analyze the data and\ncreate a Word document<\/span> report covering: total annual spending, breakdown\nby category with<\/span> percentages, the three largest expense categories, and\nmonth-over-month trends. Save it to \/output as<\/span> expenses-report-2025.<\/span>docx.\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                        7.5 High-leverage Cowork workflows<\/h2>\n\n\n\n
                        Files & admin:<\/strong> organize a Downloads folder by content<\/em> (an invoice PDF goes to Accounting, an ebook PDF to Documentation \u2014 it reads, not just sorts by extension); drop receipts in a folder \u2192 formatted expense report; batch-rename, dedupe, archive by rule. Documents:<\/strong> research synthesis across 20+ mixed files (interviews, surveys, tickets) into themes and action items; meeting notes \u2192 minutes + task lists pushed to Asana\/Linear via plugins; long-report assembly from scattered sources. Spreadsheets:<\/strong> real Excel models with formulas and formatting, not CSVs that need fixing; cross-file reconciliation; recurring weekly dashboards via scheduled tasks. Business ops:<\/strong> invoices, quotes, follow-up emails, prospect research \u2014 the documented sweet spot for small businesses. With Chrome:<\/strong> form filling, portal data extraction, web research feeding directly into local deliverables.<\/p>\n\n\n\n
                        7.6 Claude Code vs. Cowork \u2014 which do I reach for?<\/h2>\n\n\n\n
                        Situation<\/th>Use<\/th><\/tr><\/thead>
                        Anything in a codebase: features, bugs, tests, refactors, PRs, CI<\/td>Claude Code<\/strong><\/td><\/tr>
                        Documents, spreadsheets, decks, file organization, research synthesis<\/td>Cowork<\/strong><\/td><\/tr>
                        You live in the terminal \/ need scripting, headless, hooks-level control<\/td>Claude Code<\/strong><\/td><\/tr>
                        You never want to see a terminal<\/td>Cowork<\/strong><\/td><\/tr>
                        Browser automation with file deliverables<\/td>Cowork + Chrome<\/strong><\/td><\/tr>
                        Team chat delegation<\/td>Claude Code via @Claude in Slack<\/strong> (code) \/ Claude Tag<\/strong> (general)<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
                        They share plan usage limits, the MCP connector ecosystem, and the skills format \u2014 a skill you write once often serves both.<\/p>\n\n\n\n
                        \n\n\n\n
                        PART 8 \u2014 SECURITY, SAFETY & GOVERNANCE ESSENTIALS<\/h1>\n\n\n\n
                        Run agents least-privileged: scoped folders (Cowork) and permission rules\/sandboxing (Code); --allowedTools<\/code> 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 \u2014 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 \u2014 see the data-usage doc for specifics per plan.<\/p>\n\n\n\n
                        \n\n\n\n
                        PART 9 \u2014 COMMON FAILURE PATTERNS (AND THE FIX)<\/h1>\n\n\n\n
                        Pattern<\/th>Symptom<\/th>Fix<\/th><\/tr><\/thead>
                        Kitchen-sink session<\/td>One session, five unrelated tasks, degrading quality<\/td>\/clear<\/code> between tasks, always<\/td><\/tr>
                        Correction spiral<\/td>Wrong \u2192 correct \u2192 still wrong \u2192 correct\u2026<\/td>After two failed corrections, \/clear<\/code> and write a better first prompt using what you learned<\/td><\/tr>
                        Bloated CLAUDE.md<\/td>Claude ignores your rules<\/td>Prune ruthlessly; convert must-happen rules to hooks; move niche knowledge to skills<\/td><\/tr>
                        Trust-then-verify gap<\/td>Plausible code, broken edge cases<\/td>Never prompt without a verification target; demand evidence<\/td><\/tr>
                        Infinite exploration<\/td>“Investigate X” \u2192 300 file reads \u2192 full context<\/td>Scope narrowly or delegate to subagents<\/td><\/tr>
                        Opus-by-default<\/td>Mysteriously high bill<\/td>Sonnet default, escalate on evidence<\/td><\/tr>
                        Chatbot-mode Cowork<\/td>Micro-managed back-and-forth, 10% of value<\/td>Delegate outcomes; define “done”; step away<\/td><\/tr>
                        Reviewer worship<\/td>Over-engineering from chasing every review nit<\/td>Instruct reviewers: correctness gaps only<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
                        \n\n\n\n
                        PART 10 \u2014 CANONICAL RESOURCES<\/h1>\n\n\n\n
                        Claude Code:<\/strong> docs home code.claude.com\/docs\/en\/overview \u00b7 full index code.claude.com\/docs\/llms.txt \u00b7 best practices \/en\/best-practices<\/code> \u00b7 costs \/en\/costs<\/code> \u00b7 changelog \/en\/changelog<\/code> \u00b7 weekly what’s-new \/en\/whats-new\/<\/code> \u00b7 prompt library \/en\/prompt-library<\/code> \u00b7 glossary \/en\/glossary<\/code> Cowork:<\/strong> claude.com\/docs\/cowork\/overview \u00b7 Help Center: support.claude.com (“Get started with Claude Cowork”) Models & API:<\/strong> platform.claude.com\/docs (models overview, what’s-new pages incl. Opus 5) \u00b7 pricing: claude.com\/pricing & platform.claude.com Product news:<\/strong> anthropic.com\/news<\/p>\n\n\n\n
                        \n\n\n\n
                        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 \u2014 verify on the official pages above before making budget commitments.<\/em><\/p>\n","protected":false},"excerpt":{"rendered":"
                        Gold & Diamond Standard Edition \u2014 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),… <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_joinchat":[],"footnotes":""},"categories":[11138],"tags":[],"class_list":["post-77966","post","type-post","status-publish","format-standard","hentry","category-best-tools"],"_links":{"self":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/77966","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/comments?post=77966"}],"version-history":[{"count":1,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/77966\/revisions"}],"predecessor-version":[{"id":77967,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/77966\/revisions\/77967"}],"wp:attachment":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/media?parent=77966"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/categories?post=77966"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/tags?post=77966"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}