The Claude Code Workflow

The agentic loop — gather, act, verify, repeat

One line: Every task runs the same cycle — Claude gathers context, takes an action with a tool, reads the result, and repeats until no more tool calls are needed.

Picture a capable colleague at your keyboard who narrates as they go. You say "fix the failing tests." Claude runs the tests to see what broke → reads the error → searches for the relevant file → reads it → edits it → re-runs the tests to check. Each result tells it what to do next. Mechanically it's a simple rule: keep calling tools until the answer needs no more tools (engineers describe it as a while(tool_use) loop). A small fix might loop 8–12 times in under a minute; a big refactor chains dozens of steps and course-corrects along the way.

The three phases (they blend together)

• Gather context — search and read files, pull git state, fetch docs from the web, load CLAUDE.md, ask you a question if something's missing.
• Take action — edit files, run shell commands, start servers, use git, call external tools via MCP.
• Verify results — run tests, check type errors, compare against a screenshot, then decide whether to loop again.

Powered by two things

• Models that reason — Sonnet handles most coding; Opus for harder architectural reasoning. Swap mid-session with /model.
• Tools that act — five built-in families: file ops, search, execution, web, code intelligence. Without tools the model can only talk; tools are what make it agentic.

What Claude can see and touch — the working environment

One line: Run claude in a directory and it gains scoped access to your project, terminal, git state, and any extensions you've configured.

Unlike an inline assistant that only sees the file you're staring at, Claude Code sees the whole project — so when you say "fix the auth bug" it can search across files, read several to understand how they connect, make coordinated edits, run the tests, and commit. It works inside your real environment using your real tools, rather than in some opaque backend.

What it gets access to

• Your project — files in the directory + subdirectories (others only with permission).
• Your terminal — anything you could run: build tools, git, package managers, scripts.
• Your git state — current branch, uncommitted changes, recent commit history.
• CLAUDE.md + auto memory — your standing instructions, plus learnings it saved itself (see B1).
• Extensions — MCP servers, skills, subagents, and browser control, when you configure them.

CLAUDE.md and memory — persistent project context

One line: A markdown file in your project root that Claude reads at the start of every session — the highest-leverage thing you can set up.

Think of it as the onboarding doc you'd hand a new hire. Coding standards, architecture decisions, preferred libraries, the commands to build and test, a review checklist. Because Claude re-reads it each session, a good CLAUDE.md dramatically cuts how many back-and-forth iterations a task needs. There's also auto memory: Claude quietly saves learnings (like build commands and debugging insights) to a MEMORY.md as it works, and reloads them next time — so the project gets easier to work in over time.

• Generate a starter with /init; put rules you never want lost here, not in the chat (chat history can get compacted away).
• Scopes stack: organization-wide → project → personal, so teams can share standards.

Permission modes and checkpoints — the safety layer

One line: Claude asks before risky actions, you pick how much autonomy to grant, and every file edit is reversible.

A dial between "ask me everything" and "just go." Tap Shift+Tab to cycle modes. Before editing any file Claude takes a snapshot, so Esc Esc rewinds you to an earlier state — like a local undo separate from git. Actions that hit the outside world (databases, deploys, APIs) can't be checkpointed, which is exactly why Claude always asks before those.

The four permission modes

• Default — asks before file edits and shell commands.
• Auto-accept edits — edits + safe filesystem commands run without asking; still asks for the rest. Good for rapid prototyping loops.
• Plan mode — read-only; produces a plan you approve before any change. Best for production code.
• Auto mode — evaluates every action with background safety checks (research preview).

Skills · MCP · Hooks · Subagents — the extension layer

One line: Four ways to extend the core loop — add knowledge, connect tools, automate guardrails, and parallelize work.

If the loop is the engine, these are the bolt-ons. Skills are reusable playbooks ("how we review a PR") packaged as files Claude loads only when relevant. MCP is a universal adapter that lets Claude read a Jira ticket, a Google Doc, or a Slack thread as if they were built-in tools. Hooks are automatic triggers — "run the formatter after every edit," "lint before every commit." Subagents are disposable helpers with their own context window that go do one scoped job and hand back a summary, so deep digging doesn't clog the main conversation.

Context management — keeping the agent sharp

One line: The context window holds everything Claude is "thinking about"; as it fills, Claude prunes and compacts automatically — but early instructions can get lost.

The context window is the agent's desk — limited surface area. It holds the conversation, file contents, command outputs, CLAUDE.md, and loaded skills. When the desk fills, Claude first clears old tool outputs, then summarizes the conversation if needed (compaction). Your requests and key code survive; fine-grained instructions from early on may not — which is why durable rules belong in CLAUDE.md. Run /context to see what's eating space.

• Compaction is automatic near the limit; steer it with a "Compact Instructions" section in CLAUDE.md or /compact focus on the API changes.
• Skills stay out of context until used; subagents keep their digging in a separate window — both are context-saving levers.
• MCP tool definitions are deferred (loaded on demand via tool search), so only tool names cost context until called.

Sessions, resume and fork — continuity and parallelism

One line: Conversations are saved locally so you can resume, fork, or run several in parallel — each tied to a directory.

Every session is written to a local logbook (a plaintext file under ~/.claude/). That's what lets you resume tomorrow exactly where you stopped, or fork — branch off to try a different approach without disturbing the original thread. To run multiple Claudes at once without their edits colliding, give each its own folder via git worktrees. Sessions are independent: a new one starts fresh, which is why persistent rules live in CLAUDE.md, not chat history.

• claude --continue / --resume picks up the same session; --fork-session branches with a new ID.
• Worktrees = isolated git checkouts for true parallel sessions; the Desktop app and web manage these visually.

Explore → Plan → Code → Commit — the canonical workflow

One line: The most reliable results come from separating research from writing code — explore first, plan, then implement, then commit.

1. Explore — Ask Claude to read the relevant code and understand it, without writing any code yet. Use plan mode (read-only).
2. Plan — Have it produce a plan for the change. Review and refine it through conversation before approving.
3. Code — Let it implement against the agreed plan, ideally with a test or screenshot to verify against.
4. Commit — It stages changes, writes the commit message, and can open a PR with a structured description.

The habits that make it work

• Be specific upfront — name files, constraints, and example patterns; specific prompts often succeed on the first try.
• Give it something to verify against — test cases, expected output, a screenshot of the target UI. Self-checking sharply improves results.
• Delegate, don't dictate — give context and direction like you would a capable colleague; let Claude figure out which files to read.
• Interrupt and steer — if it goes down the wrong path, just type a correction; no need to wait or restart.
• Non-interactive mode (claude -p "…") pipes Claude into CI, pre-commit hooks, and scripts, with --output-format json for parsing.

Surfaces and execution environments — one engine, many doors

One line: The same agentic loop runs everywhere; what changes is where the code executes and how you interact. Your CLAUDE.md, settings, and MCP servers carry across all of them.

One brain, many doors into it. The terminal is the full-featured home base; the IDE extension (VS Code, JetBrains) adds inline diffs; the Desktop app runs several sessions side-by-side; the web and iOS app let you kick off long tasks and check back later. You can even start on the web and pull the task into your terminal with --teleport, or hand a terminal session to Desktop for visual diff review.

Automation and team entry points

• CI/CD — GitHub Actions / GitLab CI for automated code review and issue triage; @-mention Claude in Slack with a bug report and get a PR back.
• Routines — scheduled recurring work (morning PR reviews, overnight CI-failure analysis, weekly dependency audits) on managed infra, so they run even when your machine is off.
• Agent SDK — embed the same loop in your own apps with full control over tools, permissions, and orchestration.

Enterprise use cases — real deployments and results

One line: The same loop powers fintech, e-commerce, dev tools, supply chain, telecom, and finance — at scales from dozens to tens of thousands of developers.

Ramp · Fintech

Org-wide adoption beyond engineering. A grassroots rollout where data teams query the Snowflake warehouse in natural language, and non-technical staff in sales, risk, finance, and recruiting pull insights without writing SQL.

• 1M+ lines of AI-suggested code in 30 days
• 50% weekly active usage across engineering
• ~80% faster incident investigation

Rakuten · E-commerce, 70+ businesses

Long autonomous runs on complex refactors. Used Claude Code to automate coding tasks across thousands of developers while holding enterprise-grade quality and security.

• 7 hrs sustained autonomous coding on one refactor
• 79% faster time-to-market (24 days → 5)
• 99.9% accuracy on complex code modifications

cubic · Dev tools

AI-native code review. Built review workflows on Claude to catch issues before merge, compressing development cycles.

• 60× faster code shipping
• 28% faster development cycles

Altana · Supply-chain AI

Building sophisticated AI/ML systems faster. Uses Claude Code to accelerate development of large-scale knowledge graphs for global supply chains.

• 2–10× faster development velocity

Other patterns worth knowing

• Behavox (compliance/security) — rolled out to hundreds of developers as their "go-to pair programmer," reporting it outperformed other coding agents.
• TELUS (telecom/health) — Claude powers the internal "Fuel iX" platform for 57,000 employees; developers use Claude Code in VS Code and GitHub for real-time refactoring.
• Bridgewater (asset management) — Claude as an "investment analyst assistant" that writes Python for analysis, handles errors, and outputs charts — freeing analysts for strategy.
• Anthropic internal — even the legal team built a "phone-tree" tool prototype with Claude Code; engineers use auto-accept mode for autonomous test-and-iterate loops.

How to think about enterprise value

• Velocity — features ship faster; long refactors run autonomously (Ramp, Rakuten).
• Quality and risk — automated review and incident response; permission/checkpoint model makes it safe on production code (cubic, Ramp).
• Democratization — non-engineers build tools and query data in natural language (Ramp, Anthropic legal).
• Onboarding and knowledge — point it at an unfamiliar codebase for an architecture walkthrough and auto-generated docs.
• Governance — org-down permission policies, audit, and admin controls make org-wide rollout viable.