Tag: AI Tools

Published: May 25, 2026 | Last fact-check: May 25, 2026 against Anthropic docs and Claude Code v2.1+ behavior

Plan Mode (sometimes called “planning mode”) is one of the more underused features in Claude Code in 2026. It changes how the agent works in a specific, measurable way: before Claude Code edits files, runs commands, or modifies state, it produces a plan and waits for your approval. You see what it intends to do, you say yes or no, and only then does it act.

For the right kind of task, Plan Mode is the difference between a clean execution and a regrettable one. For the wrong kind of task, it is friction that slows you down. This guide separates the two.

Claude Code Plan Mode vs Auto Mode: When to Use Each

What Plan Mode Actually Does

In default mode, Claude Code is allowed to take actions as it reasons. It can read files, write files, run bash, edit code, all in one conversational flow. This is the strength of Claude Code as an agent — it gets work done without asking permission for every step.

In Plan Mode, Claude Code’s behavior changes:

1. You describe the task.
2. Claude Code investigates the codebase (read-only operations are still allowed).
3. Claude Code drafts a plan listing every file it intends to change, every command it intends to run, and every decision point.
4. You read the plan. You approve it, modify it, or reject it.
5. Only after approval does Claude Code start writing files or running commands.

The plan is presented in the terminal as a structured outline. You can ask Claude Code to revise the plan, add steps, remove steps, or change the order. Iterating on the plan is fast because no actions have been taken yet.

How to Enable Plan Mode

There are four ways to activate Plan Mode in Claude Code:

1. Shift+Tab pressed twice. Each press of Shift+Tab cycles through the three permission modes: Default → Auto-Accept → Plan → Default. Two presses lands on Plan Mode. The status bar shows ⏸ plan mode on when active.
2. The /plan slash command. Type /plan at the start of any prompt to enter Plan Mode for that turn only. Useful for one-off plans without flipping the whole session.
3. The –permission-mode plan flag at startup. Start the session in Plan Mode from the command line.
4. Headless mode for scripts and CI. claude --print --permission-mode plan "your task" for automation that should never edit files.

# Start session in Plan Mode
claude --permission-mode plan

# Or mid-session — press Shift+Tab TWICE
# (first press = Auto-Accept Mode, second press = Plan Mode)

# Or one-shot Plan Mode for next prompt only
/plan

Plan Mode is persistent within a session — it stays on until you cycle out with another Shift+Tab. Close and reopen Claude Code and it defaults back to off. Toggle it on for risky work, leave it on for the whole session if you are doing higher-risk work end-to-end.

Important: Plan Mode is a hard read-only sandbox enforced at the tool level. Claude Code physically cannot edit files, run commands, or modify state while Plan Mode is active. This is not a suggestion or a soft check — the write tools are unavailable.

When Plan Mode Pays Off

Plan Mode is worth the friction in these situations:

• Multi-file refactors. When the agent will touch 5+ files, you want to see the list before it starts editing. A small confusion about which files to change becomes a big mess fast.
• Database migrations or schema changes. Anything that touches durable state and is hard to undo benefits from a confirmed plan.
• Production code paths. If a session affects code that ships to users, the plan checkpoint is cheap insurance.
• Ambiguous instructions. When you are not sure how the agent will interpret your request, Plan Mode surfaces the interpretation before any work happens.
• New repository onboarding. When you do not yet know the codebase well, Plan Mode lets the agent show you what it learned during investigation before it acts.
• Long-running batch jobs. Approving a plan for 200 file edits and then walking away is safer than launching 200 edits blind.

When Plan Mode Gets In the Way

Plan Mode is not free. The friction it adds is a real cost for certain workflows:

• Single-file tweaks. Asking Claude Code to fix a typo or rename a variable does not need a plan. The plan takes longer than the fix.
• Tight feedback loops. When you are iterating quickly — try a change, see the result, adjust — Plan Mode slows the loop. Default mode wins here.
• Read-only investigation. If you are asking questions about the codebase (“how does this auth flow work”), there is nothing to plan. Plan Mode is irrelevant.
• Work in a sandbox. If you are working in a throwaway directory or branch where mistakes are cheap, the safety net of Plan Mode is overkill.

The decision is not “is Plan Mode good.” It is “is the cost of approval less than the cost of an unintended action.” For risky multi-step work, yes. For cheap iteration, no.

Working Inside the Plan

Once Claude Code presents a plan, you have several options:

1. Approve as-is. Tell Claude Code to proceed. It executes the plan in order.
2. Approve with modifications. Tell Claude Code to remove specific steps, reorder them, or add additional steps. It revises the plan and re-presents.
3. Ask questions. Drill into specific steps. “Why are you editing file X?” Claude Code explains the reasoning.
4. Reject and restart. If the plan is wrong-shape, tell Claude Code so. It will rebuild the plan from a corrected understanding.
5. Cancel. Exit Plan Mode entirely if you’ve decided this is not the right task or session for it.

The plan is conversational. You are not stuck with the first draft. Iterating on the plan is much cheaper than iterating after the work is done.

What Plan Mode Does Not Protect Against

Plan Mode is not a sandbox. The plan, once approved, executes for real. Plan Mode does not:

• Prevent you from approving a bad plan
• Catch logic errors inside individual file edits
• Prevent destructive bash commands if you approved them in the plan
• Replace tests or code review

It is a thinking checkpoint, not a safety net. The human still owns the decision.

Plan Mode vs Other Safety Patterns

Plan Mode is one of several safety patterns Claude Code supports:

• Read-only sessions: Restrict the agent to read operations only.
• Per-tool permissions: Approve each tool use individually as it happens.
• Plan Mode: Approve a batch of intended actions before execution begins.
• Auto-accept mode: The opposite — accept all tool uses without asking. Fast and risky.

Per-tool permission is more granular but slower. Plan Mode is bulkier but faster once approved. Use the right tool for the situation; do not assume one is always correct.

A Working Habit

The habit that has worked across hundreds of Claude Code sessions: default mode on, Shift+Tab twice into Plan Mode before any session that will (a) touch production state, (b) edit more than 5 files, or (c) run commands that are hard to undo. Shift+Tab again to cycle back to default for everything else.

The shortcut becomes muscle memory in a week. Once it is muscle memory, the cost of Plan Mode drops to nearly zero, and you can use it liberally on anything that even smells risky.

Related on Tygart Media: Claude Code getting started · Claude Code Router · Claude Code tutorial.

Frequently Asked Questions

What is Plan Mode in Claude Code?

Plan Mode is a Claude Code setting that forces the agent to produce a written plan and wait for your approval before making changes. It surfaces what the agent intends to do so you can adjust it before any work happens.

How do I enable Plan Mode in Claude Code?

Press Shift+Tab twice in the terminal (the first press cycles to Auto-Accept; the second lands on Plan Mode), type /plan as a slash command, or start the session with –permission-mode plan. The status bar shows ⏸ plan mode on when active.

When should I use Plan Mode?

For multi-file refactors, database migrations, production code paths, ambiguous instructions, new repositories you don’t know yet, and long-running batch jobs. Skip Plan Mode for single-file tweaks, tight iteration loops, and read-only investigation.

Does Plan Mode make Claude Code slower?

Yes, for short tasks — the plan adds latency that is not worth it on quick edits. For long or risky tasks, the plan is faster than fixing mistakes afterward.

Can I edit the plan before approving it?

Yes. Tell Claude Code to revise the plan — add steps, remove steps, reorder. Iterating on the plan is much cheaper than iterating after execution.

Is Plan Mode the same as a sandbox?

Plan Mode IS a hard read-only sandbox at the tool level — Claude Code cannot write files or run commands while it’s active. But once you approve the plan and exit Plan Mode, the work executes for real. Plan Mode prevents accidental writes during planning; it does not prevent you from approving a bad plan.

What’s the difference between Plan Mode and per-tool permissions?

Per-tool permissions ask you to approve each tool use individually as it happens (more granular, slower). Plan Mode batches all intended actions into one plan you approve up front (bulkier, faster once approved).

The Bottom Line

Plan Mode is leverage for risky work and friction for everything else. Make Shift+Tab+Shift+Tab muscle memory. Use Plan Mode whenever the cost of an unintended action exceeds the cost of approval — multi-file refactors, production changes, ambiguous specs. Skip it on cheap iteration. That single rule will save you more headaches than any other Claude Code habit.

Published: May 25, 2026 | Last fact-check: May 25, 2026 — legacy (still listed) model lineup: Opus 4.7, Sonnet 4.6 (legacy — still listed), Haiku 4.5

Lineup currency (Sept 2026): Current API list (Sept 2026, verified): Sonnet 5 $2/$10, Opus 5.5 $4/$20, Haiku 4.5 $1/$5, Fable 5.1 $10/$50. Legacy (still listed on Anthropic’s card): Opus 4.8 $5/$25, Sonnet 4.6 $3/$15.

“Claude Code router” is a phrase that means different things to different people in 2026, and the differences matter for what you should actually build or buy.

It can mean (1) Anthropic’s built-in logic that picks a model when you do not specify one, (2) third-party tools that route between Anthropic models and other LLMs through one Claude Code interface, or (3) custom routing rules you build yourself to match models to tasks. This guide walks through each, when each makes sense, and the trade-offs.

Why Routing Matters in the First Place

Claude is not one model. It is a family. As of 2026 the production tiers are roughly:

• Claude Opus 4.7 — $5/$25 per million tokens. Current flagship. Best for hard, ambiguous, multi-step reasoning and agentic coding.
• Claude Sonnet 4.6 (legacy — still listed) — $3/$15 per million tokens. The workhorse. Within ~1 point of Opus on coding benchmarks at 40% less cost. Right answer for 80% of daily work.
• Claude Haiku 4.5 — $1/$5 per million tokens. Fast and cheap. Right answer for high-volume formulaic tasks: classification, extraction, formatting, routing, simple Q&A.

Output costs 5x input across all three tiers. Prompt caching cuts cached input costs by ~90%. Batch API cuts everything by 50% if you can wait up to 24 hours.

Lineup currency (Sept 2026): Current API list (Sept 2026, verified): Sonnet 5 $2/$10, Opus 5.5 $4/$20, Haiku 4.5 $1/$5, Fable 5.1 $10/$50. Legacy (still listed on Anthropic’s card): Opus 4.8 $5/$25, Sonnet 4.6 $3/$15.

Using Opus for everything is wasteful. Using Haiku for everything is sloppy. Routing — matching the model to the task — is how you get the best output for the lowest cost. For someone running Claude Code several hours a day, intelligent routing is the difference between a $100/month Max bill and a $1,000/month API bill for the same work.

Anthropic’s Built-In Claude Code Routing

When you launch Claude Code without specifying a model, it picks a default. As of 2026 the default for most users is Sonnet, with Opus accessible via flags or settings, and Haiku used internally for some sub-tasks like tool selection and simple file operations.

You can override the default at session start:

# Start Claude Code with Opus for a tough refactor
claude --model claude-opus-4-7   # current flagship

# Or set it in your settings.json
{
  "model": "claude-sonnet-4-6"  // current workhorse
}

Anthropic also routes internally: when Claude Code uses sub-agents for parallel work, it can route those sub-agents to lighter models automatically. This routing is opaque to you and generally well-tuned. You usually do not need to think about it.

Manual Model Selection: The 80/20 Approach

For most users, manual routing beats automatic routing. The rule:

• Sonnet by default. Daily work, content drafts, code edits, file operations, debugging.
• Opus when you hit a wall. Architectural decisions, hard refactors, ambiguous specs, anything that requires real reasoning.
• Haiku for batch. Classification, taxonomy assignment, metadata generation, SEO meta descriptions, anything formulaic at volume.

This 80/20 split is achievable with two or three commands and zero infrastructure. It is the right starting point.

Third-Party Claude Code Routers

A small ecosystem has emerged around third-party routers that sit between Claude Code and the model layer. The two most common patterns:

OpenRouter and Multi-Provider Routers

OpenRouter is the most widely used third-party router. You point Claude Code at OpenRouter as the API endpoint, and OpenRouter routes your requests to Claude (or to GPT, Gemini, DeepSeek, Llama, etc.). Why use it:

• You want fallback when Anthropic has an outage.
• You want to mix Claude with other models on a per-task basis.
• You want a single billing surface across providers.
• You want BYOK (bring your own key) routing where you mix your own provider keys.

The trade-off: latency adds a few hundred milliseconds per call, and some Anthropic-specific features (prompt caching, certain beta tools) work less smoothly through the proxy.

Custom In-House Routers

Larger teams build their own routing layer. A typical pattern: a small Python or TypeScript service that inspects the incoming request, applies routing rules (length thresholds, task type detection, cost ceilings), picks a model, and forwards the call to Anthropic.

This is overkill for most individuals. It pays off when you have:

• Strict cost controls that need enforcement, not suggestion
• Multi-tenant usage where different customers get different models
• Compliance requirements that need request inspection and logging
• A real engineering team that can maintain the service

Routing Rules That Actually Work

If you are going to invest in any routing logic, these are the rules that pay back:

1. By task type. Code review → Opus. New code generation → Sonnet. Format conversion → Haiku.
2. By input length. Long context (40K+ tokens) where you need careful reasoning → Opus. Long context where you need extraction → Sonnet with prompt caching.
3. By cost ceiling. Anything over a threshold token count gets a hard cap or downgrade.
4. By time of day. Overnight batch jobs route to cheaper models. Interactive daytime work routes to your preferred quality tier.
5. By failure recovery. If a Sonnet call returns a low-confidence or refused response, retry once with Opus before giving up.

Most of these rules are five lines of code each. The discipline is more about deciding the rules than implementing them.

What Anthropic Does Not Yet Ship

As of writing, Anthropic does not ship a built-in “route this query to the right model” intelligence layer in Claude Code. The model you set is the model you get for the session, with the exception of internal sub-agent routing.

This is likely to change. The shape of where Claude Code is going — more autonomy, longer sessions, more parallel agents — implies more sophisticated internal routing. For now, the routing decisions worth making are the ones you make yourself.

Costs: What Routing Actually Saves

Concrete example. An operator running a Claude Code content pipeline that:

• Drafts articles (Sonnet): 8,000 input + 4,000 output tokens per article
• Generates SEO meta and FAQ (Haiku): 2,000 + 500 tokens
• Reviews and edits (Opus): 10,000 + 2,000 tokens for trickier articles

Running everything on Opus would roughly triple the cost. Running everything on Sonnet would save vs Opus but produce noticeably weaker meta-generation than Haiku at similar quality. Routing by task type saves real money — often 40-60% versus a single-model approach — without sacrificing output quality.

When Not to Build a Router

Routing is leverage when you operate at volume. If you run Claude Code casually — a couple of hours a day, one task at a time — you do not need a router. You need to learn the three models well enough to pick the right one by feel. Build a router only when (a) cost is a real line item in your budget, (b) you are running multiple workflows that have genuinely different model needs, or (c) you want fallback infrastructure for resilience.

Related on Tygart Media: Claude Code Plan Mode · Claude Code getting started · Claude Code vs Cursor.

Frequently Asked Questions

What is a Claude Code router?

A Claude Code router is any layer — Anthropic’s built-in defaults, a third-party tool like OpenRouter, or custom code — that decides which Claude model handles a given request.

Does Claude Code have built-in routing?

Partial. Claude Code picks a default model (Sonnet) and routes internal sub-agent tasks to lighter models. It does not automatically promote your main session to Opus when a task gets hard.

What’s the difference between OpenRouter and a custom router?

OpenRouter is a hosted multi-provider gateway with billing and fallback built in. A custom router is something you build to enforce your own rules. OpenRouter is right for most teams. Custom routers are right for teams with strict requirements.

Should I use OpenRouter with Claude Code?

Useful if you want fallback, multi-provider mixing, or unified billing. Less useful if you only use Claude and want Anthropic-specific features like prompt caching to work optimally.

How do I pick the right Claude model for a task?

Default Sonnet. Opus for hard reasoning, architectural decisions, ambiguous specs. Haiku for high-volume formulaic tasks (classification, formatting, metadata).

How much can routing save me?

For volume users, 40-60% versus running everything on Opus, with no measurable drop in output quality if the routing rules are sensible.

Is there a cost to routing through OpenRouter?

OpenRouter adds a small markup on token pricing in exchange for the routing and aggregation features. For most users this is acceptable; for very high volume, going direct to Anthropic is cheaper.

The Bottom Line

Claude Code routing is leverage when you operate at volume and a distraction when you do not. Start by learning the three Claude models by feel and picking manually. Add OpenRouter if you want fallback. Build a custom router only when cost or compliance actually justifies the engineering. The router is not the goal; the right model on the right task is the goal.

Published: May 25, 2026 | Last verified: June 28, 2026 (Pacific Time)

An Anthropic API key is the credential that lets your application, script, or tool call Claude programmatically. Whether you are wiring Claude into Claude Code, building an internal agent, or integrating Claude into a SaaS product, the API key is the first step. This is the complete reference for that key — pricing, billing, security, rotation, and organization controls. If you just need to create your first key, our step-by-step guide to getting an Anthropic API key walks through it in about five minutes; this page is what you read next.

Anthropic API Pricing Tiers (June 2026)

All models support 50% Batch API discount for non-real-time requests. Fable 5 is free on Pro/Max/Team through June 22, 2026. Prices verified June 12, 2026.

What an Anthropic API Key Is (and Isn’t)

The Anthropic API key authenticates requests to the Anthropic Messages API. It identifies which workspace and organization is making the call, what model permissions it has, and where to bill the token usage.

What an API key is not: a login. You cannot use an API key to sign into claude.ai. The web interface and the API are separate billing surfaces. Your Pro or Max subscription does not grant API credit by default; API usage requires its own billing setup.

Creating a key (the short version)

Create a key at console.anthropic.com → API Keys → Create Key; it starts with sk-ant-, is shown once, and will not work until billing is added. For the full walkthrough — including the no-key OAuth option and the four errors that trip people up on the first request — see our step-by-step guide to getting an Anthropic API key. The rest of this page is the reference you will want once the key exists.

Adding Billing Before You Can Use the Key

A common surprise: a freshly created API key cannot make calls until you add a payment method and credits to your Anthropic account. The key exists, but every request returns a billing error.

To add billing:

1. In the Claude Console, click “Billing” or “Plans & Billing” in the left sidebar.
2. Add a payment method (credit card; Anthropic also supports invoicing for enterprise).
3. Either pre-purchase API credits or enable auto-recharge. Most users enable auto-recharge with a low threshold to avoid hitting empty mid-job.
4. Set a monthly usage limit if you want a safety cap.

Once billing is set up, your API key works.

Anthropic API Key Format

An Anthropic API key starts with the prefix sk-ant- followed by a long alphanumeric string. The full key is roughly 100 characters. If your key does not start with sk-ant-, you have copied something incomplete.

Different key types exist:

• Live keys (sk-ant-api...): Production calls, real billing.
• Admin keys (sk-ant-admin...): Workspace admin operations, not for inference calls.

Most developers only need a live key.

Which Claude Models the API Key Works With

A standard live API key gives you access to the current generation of Claude models:

• Claude Fable 5 (claude-fable-5) — current top tier, released June 9 2026. $10/$50 per million tokens. Anthropic’s first Mythos-class model. Note: carries a mandatory 30-day data retention requirement (no zero data retention option). Full breakdown here.
• Claude Opus 4.8 (legacy — still listed) (claude-opus-4-8) — second tier, released April 16 2026. $5/$25

  Lineup currency (Sept 2026): Current API list (Sept 2026, verified): Sonnet 5 $2/$10, Opus 5.5 $4/$20, Haiku 4.5 $1/$5, Fable 5.1 $10/$50. Legacy (still listed on Anthropic’s card): Opus 4.8 $5/$25, Sonnet 4.6 $3/$15.

• Claude Haiku 4.5 (claude-haiku-4-5) — released October 15 2025. $1/$5 per million tokens. Fast and cheap for high-volume work.

Earlier model versions (Sonnet 4, Opus 4.6, Haiku 3.5, etc.) are still callable by their specific snapshot IDs until Anthropic announces deprecation. Check the deprecation timeline in the Claude Console for any model you depend on in production.

How to Use the API Key

You pass the key in the x-api-key header on every request to the Messages API:

curl https://api.anthropic.com/v1/messages \
  --header "x-api-key: $ANTHROPIC_API_KEY" \
  --header "anthropic-version: 2023-06-01" \
  --header "content-type: application/json" \
  --data '{
    "model": "claude-opus-4-8",
    // Other current options: claude-sonnet-4-6, claude-haiku-4-5
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Hello"}]
  }'

In Python or Node.js, the official SDKs read ANTHROPIC_API_KEY from your environment automatically. You should never hardcode the key in source code.

Security: How to Not Leak Your Key

Anthropic API keys leak constantly. Most leaks happen the same way:

1. Committing the key to a public GitHub repo. The single most common leak. GitHub scans for known credential patterns and notifies Anthropic; your key gets auto-revoked within minutes. You will know because your calls suddenly start failing.
2. Pasting the key into a shared chat or document. Anyone with access becomes a credential holder.
3. Putting the key in client-side JavaScript. A browser app shipping its API key to users is giving the key away. Always proxy through a backend.
4. Logging the key. Any logging system that captures HTTP headers can leak the key. Mask sensitive headers in your logger config.

The good rule: treat your API key like a credit card number, because that’s what it functions as.

Rotating an Anthropic API Key

You should rotate keys quarterly at minimum, and immediately if a key is suspected compromised. Rotation in the Claude Console:

1. Go to API Keys.
2. Create a new key with a fresh name (e.g., “Claude Code Laptop 2026 Q3”).
3. Update your application’s environment variable or secret manager to use the new key.
4. Verify the new key works.
5. Revoke the old key.

The five-minute rotation is far cheaper than dealing with a leaked key that was used by an attacker for hours before you noticed.

Workspace and Organization Keys

Anthropic accounts are organized as: Organization → Workspaces → API Keys. Most individuals only use one of each. Teams use multiple workspaces to separate environments (production, staging, dev) or projects.

Each key belongs to one workspace. Billing rolls up to the organization. If you need separate billing visibility per project, separate workspaces are the lever.

Monitoring API Key Usage

The Claude Console shows per-key usage in the “Usage” section. You can see:

• Token spend per key per day
• Model breakdown (Opus, Sonnet, Haiku usage)
• Input vs output token split
• Cache usage (if you have prompt caching enabled)

Set up usage alerts in Billing. The Anthropic console can email you when daily or monthly spend crosses a threshold. This is the cheapest insurance against a runaway loop or compromised key.

Frequently Asked Questions

How do I get an Anthropic API key?

Sign in to console.anthropic.com, open API Keys in the sidebar, click Create Key, name it, and copy the key immediately. You cannot retrieve the full key after closing the creation modal.

Is the Anthropic API key free?

The key itself is free to generate. Using it costs money — Anthropic bills per token at the API pricing in effect. You must add billing credits before the key works.

Does my Claude Pro or Max subscription include API credits?

No. Pro and Max subscriptions cover the chat interface and Claude Code (with usage caps). API usage is billed separately against your Anthropic account.

What does an Anthropic API key start with?

Live API keys start with sk-ant-api. Admin keys start with sk-ant-admin. The key is roughly 100 characters long.

What happens if my Anthropic API key gets leaked?

Anyone with the key can use it to make API calls billed to your account until the key is revoked. If you suspect a leak, revoke immediately in the Claude Console and check Usage for any suspicious activity.

Can I use the same API key for Claude Code and my own app?

You can, but you should not. Use separate keys per environment (Claude Code Laptop, Production Backend, Local Dev). Separate keys make revocation surgical instead of catastrophic.

Where should I store my Anthropic API key?

In a password manager (1Password, Bitwarden) for personal use, or in a secret manager (AWS Secrets Manager, GCP Secret Manager, HashiCorp Vault) for production. Never commit it to a repo or hardcode it in source.

How do I rotate an Anthropic API key?

Create a new key in the Claude Console, update your application to use the new key, verify it works, then revoke the old key. Rotate quarterly as a baseline.

Get alerted when Claude pricing or limits change

We track Anthropic’s models, pricing, and limits daily and send a short note when something changes that affects what you pay or build. Occasional, no spam.

The Bottom Line

Getting an Anthropic API key is a three-minute process. Keeping it safe is a discipline. Use a password manager, rotate quarterly, never put the key in client-side code, and set usage alerts in the Claude Console. Treat the key as production infrastructure, not a developer toy, and it will serve you for years without incident.

Frequently Asked Questions