Claude Code Best Practices: Context, Tests and Workflow

Learn Claude Code best practices for managing context, planning changes, writing tests and reviewing results, with the workflow guidance explained.

TL;DR

  • The biggest Claude Code mistake isn’t a bad prompt, it’s a missing system. Anthropic’s own docs trace most best practices back to one constraint: the context window fills fast, and performance degrades as it fills.
  • Boris Cherny, who created Claude Code at Anthropic, puts giving Claude a way to verify its work at the top of his list, and says it can deliver “2-3x the quality of the final result.”
  • The teams getting the most out of it treat it like a new hire: they give it memory (CLAUDE.md), structure (plans and specs) and a way to check its own work (tests, hooks and goals).
  • This October 2026 update adds context management, a verification ladder, hooks, a skills-versus-subagents-versus-MCP guide, permissions and auto mode, spec interviews, parallel and headless runs, and a current Claude Code vs Codex comparison.
Dario Amodei at TechCrunch Disrupt in 2023 with the headline Claude Code: Keep Context Under Control.
Dario Amodei at TechCrunch Disrupt in 2023. Photo: Kimberly White/Getty Images for TechCrunch, CC BY 2.0, via Wikimedia Commons. File photos, cropped and adapted with AI assistance by AI Tech Safar; not a new event photograph or app screenshot.

Reviewed by Imran Khan Pathan, Editor at AI Tech Safar. This guide was re-checked on October 7, 2026 against Anthropic’s Claude Code documentation (best practices, memory, hooks, model configuration and costs), Anthropic’s prompting best practices, Boris Cherny’s public threads as reported by InfoQ and others, and current Claude Code vs Codex comparisons. When a tip comes from Cherny or the Claude Code team instead of the docs, we say so.

Last updated: October 7, 2026

What changed since the earlier version

  • New sections: context management, a verification ladder, hooks, choosing between skills, subagents and MCP, permissions and auto mode, spec interviews, parallel and headless runs, adversarial review and cost control.
  • Corrections: plan mode is entered by pressing Shift+Tab until the status bar says so, /batch fans out to 5 to 30 subagents (not “dozens”), Cherny uses multiple git checkouts while most of the team prefers worktrees, and “Compounding Engineering” was removed because we couldn’t trace it to Cherny.
  • Updated: the old Claude Code vs ChatGPT table (Opus 4.6 against GPT-5.4) is now Claude Code vs OpenAI Codex on current models.

What Makes Claude Code Different From Other AI Coding Tools

Claude Code isn’t just “Claude in a terminal.” It’s an agentic coding environment: it reads your files, runs commands, edits code, works with git, spawns subagents, and reaches outside tools through CLI utilities and MCP servers. Anthropic’s docs describe the shift plainly. Instead of writing code yourself and asking Claude to review it, you describe what you want and Claude explores, plans and implements.

Most chat-based coding help is stateless: you paste code, get a suggestion and move on. Claude Code carries state between sessions through CLAUDE.md files, auto memory and saved sessions, and it can keep working while you watch, redirect or step away. But it doesn’t hold your whole repo in mind. Its context window is large and finite, and that single fact explains most of the advice in this guide.

That power cuts both ways. Give it a weak prompt and it can confidently go in the wrong direction for 20 minutes. Give it a precise one, with a way to check itself, and it can handle refactors you’d normally spend hours on. Three things separate it from a chat window:

  • Long-context reasoning across files. It can read many files and keep a coherent picture, as long as you manage the window.
  • Agentic tool use. It runs your tests, checks the browser, queries data through CLI tools or MCP, and posts to Slack when you’ve connected it.
  • Verification loops. Give it a check it can run and it iterates until the check passes, which is the single biggest quality lever.

The #1 Claude Code Mistake (And Why It Kills Your Results)

Cherny made the point in a January 2026 thread, and it’s the line worth remembering from this whole guide: the most important thing is to give Claude a way to verify its work. With that feedback loop in place, he says, you get 2-3x the quality of the final result.

Anthropic’s docs explain why. Claude stops when the work looks done, and without a check it can run, “looks done” is the only signal it has. That makes you the verification loop: every mistake waits for you to spot it. Give it something that produces a pass or fail and the loop closes on its own.

A second mistake comes before verification: starting without context. Most people open Claude Code and type something like “Fix the auth bug.” Claude doesn’t know which auth system you use, what the bug looks like or what “fixed” means. It guesses, and guesses compound.

Cherny’s team does the opposite. They keep one shared CLAUDE.md checked into git, and whenever Claude does something wrong, they add a rule so it doesn’t happen again. That’s how a project file turns into compounding knowledge about your codebase, not just your current conversation. Treat Claude Code like a search box you’ll forget by tomorrow, and you’ll keep re-explaining the same things.


Context Is the Real Constraint

If you remember one idea from Anthropic’s best-practices page, make it this one. The context window holds everything: every message, every file Claude reads and every command output. A single debugging session can eat tens of thousands of tokens, and as the window fills, Claude may start forgetting earlier instructions or making more mistakes.

The practical habits that follow:

  • Watch it. Run /context to see what’s loaded, and set up a status line to show context usage continuously.
  • Reset between unrelated tasks. /clear wipes the window. The “kitchen sink session,” where you bounce between unrelated jobs, is one of the failure patterns Anthropic names.
  • Compact with instructions. Claude Code compacts automatically near the limit. For control, run /compact Focus on the API changes, or add a line to CLAUDE.md such as “When compacting, always preserve the full list of modified files and any test commands.”
  • Compact part of a session. Press Esc twice (or run /rewind), pick a message and choose Summarize from here or Summarize up to here.
  • Ask side questions for free. /btw answers a question without adding it to your conversation history.
  • Push research into subagents. They explore in their own window and send back a summary.

Claude Code Best Practices – The Full Framework

1. Give Claude a Way to Verify Its Work

The check can be anything that returns a signal Claude can read: a test suite, a build exit code, a linter, a script that diffs output against a fixture, or a browser screenshot compared with a design. Here’s how Anthropic’s docs phrase the before and after:

Instead ofTry
“implement a function that validates email addresses”“write a validateEmail function. example test cases: user@example.com is true, invalid is false, user@.com is false. run the tests after implementing”
“make the dashboard look better”“[paste screenshot] implement this design. take a screenshot of the result and compare it to the original. list differences and fix them”
“the build is failing”“the build fails with this error: [paste error]. fix it and verify the build succeeds. address the root cause, don’t suppress the error”

Once the check exists, decide how hard it gates the stop. There’s a ladder:

LevelHowBest for
1. In the promptAsk Claude to run the check and iterate in the same messageAny task, today, with no setup
2. Across a sessionSet the check as a /goal condition; a separate evaluator re-checks it after every turnLonger tasks you want to walk away from
3. As a hard gateA Stop hook runs your check as a script and blocks the turn from ending until it passesUnattended runs where “looks done” isn’t enough
4. By a second opinionA verification subagent reviews the result in a fresh contextWork where the author shouldn’t grade itself

Ask for evidence, not assertions: the test output, the command it ran and what it returned, or a screenshot. Reviewing evidence is faster than redoing the verification, and it works for sessions you weren’t watching. After Claude’s own check passes, you can run /verify yourself to confirm the change against the running app.

2. Explore First, Then Plan, Then Code

For multi-file or unfamiliar work, separate exploration from execution. Enter plan mode by pressing Shift+Tab until the status bar shows plan mode on (Cherny describes it as pressing twice, but the exact count depends on your current mode), or start with claude --permission-mode plan. Anthropic’s recommended flow has four phases:

  1. Explore – Claude reads files and answers questions without changing anything
  2. Plan – ask for a detailed implementation plan, and press Ctrl+G to edit it in your text editor
  3. Implement – approve the plan or leave plan mode, then let Claude code and verify against the plan
  4. Commit – ask for a descriptive commit message and a PR

Cherny shared one team habit worth stealing: one engineer has a Claude write the plan, then spins up a second Claude to review it as a staff engineer before implementation starts. Plan mode isn’t free, though. If you could describe the diff in one sentence, such as fixing a typo or renaming a variable, skip it and ask Claude to do it directly.

3. Always Provide Rich Context Upfront

Claude Code is brilliant but new to your project. Think of onboarding a senior engineer on day one: they’re capable, but they need your stack, conventions and constraints before they touch anything.

  • Create a CLAUDE.md in your repo root with build and test commands, coding conventions and non-negotiables (“never use enums – use string literal unions”)
  • Reference files with @ instead of describing where code lives, paste screenshots straight in, and pipe in data with cat error.log | claude -p "explain this error"
  • Point Claude at existing patterns in your codebase, and tell it where the answer lives (“look through the git history of ExecutionFactory and summarize how its API came to be”)
  • Describe the symptom, the likely location and what “fixed” looks like, and state the why, not just the what

4. Write a CLAUDE.md That Actually Works

Run /init to generate a starter file from your project, then refine it. Cherny’s thread shows the shape: development workflow rules first, then the commands.

# Development Workflow **Always use `bun`, not `npm`.** # Commands bun run typecheck # fast type check bun run test # full test suite bun run lint # lint before committing

That’s a trimmed version. In his thread the file runs a little longer, but the shape is the same: commands, conventions and gotchas, with no essays. InfoQ reported the team’s file at around 2.5k tokens.

Anthropic’s guidance on keeping it useful:

  • Apply the pruning test. For each line, ask “Would removing this cause Claude to make mistakes?” If not, cut it. Bloated files make Claude ignore your actual instructions.
  • Include what Claude can’t guess. Bash commands, style rules that differ from defaults, test runners, branch and PR conventions, environment quirks and gotchas. Skip anything it can learn by reading the code, plus standard conventions and long tutorials.
  • Move situational knowledge elsewhere. Use skills for workflows that apply sometimes, and path-scoped rules in .claude/rules/ for one part of the codebase. Note that splitting a big file into @path imports tidies it but still loads everything at launch, according to community guides, so only path-scoped rules actually cut what’s loaded.
  • Check it loaded. Run /context, and run /doctor on a checked-in file so Claude proposes cuts.
  • Emphasize one line, not ten. If Claude keeps skipping a rule, add “IMPORTANT” to that line alone. If everything is emphasized, nothing stands out.
  • Prune as models improve. Anthropic’s prompting guide warns that older instructions can be too prescriptive for newer models, and Cherny has reportedly said his own file keeps shrinking. Re-read yours whenever you switch models.

Claude also keeps its own notes. Auto memory records learnings from your corrections and preferences, loading a MEMORY.md index at startup and topic files on demand, so CLAUDE.md is for rules you write and auto memory is for what Claude picks up.

5. Use XML Tags to Structure Complex Prompts

Anthropic’s prompting guidance recommends XML tags for separating instructions, context and examples in a complex prompt, and Claude parses them well. You don’t need them for a small request, but they help when a prompt mixes several kinds of material.

<instructions> Refactor the token refresh logic in src/auth/refresh.ts. Do not change the public API. Do not add new dependencies. </instructions> <context> The current implementation uses setTimeout which causes race conditions under high load. See the failing test in auth.test.ts line 47. </context> <constraints> – Keep the public function signature identical – Pass all existing tests: run `bun test auth` – Do not touch src/auth/login.ts </constraints>

This isn’t bureaucratic overhead. It’s the difference between Claude reading your intent correctly the first time and needing three rounds of corrections.

6. Tell Claude What NOT to Do

Negative constraints are underused. Add lines like these to your prompts or CLAUDE.md:

  • Do not add new dependencies
  • Do not modify public APIs
  • Do not touch files outside src/auth/
  • Do not add docstrings to code you didn't change
  • Do not create helper scripts - use the standard tools directly

The last one matters. Anthropic’s prompting guide notes that Claude can lean on workarounds like helper scripts for complex refactors instead of using standard tools, and its suggested language is a line such as “Do not create helper scripts or workarounds to accomplish the task more efficiently.” The same guide also warns about over-engineering and about solutions that only work for specific test inputs, so “don’t hard-code values to pass the tests” is worth adding where it applies.

7. Course-Correct Early, With Feedback Instead of Rewrites

When Claude produces a mediocre result, most people rewrite the whole prompt. Targeted feedback is usually faster. Cherny’s team shared phrasings worth borrowing:

  • “Knowing everything you know now, scrap this and implement the elegant solution.”
  • “Grill me on these changes and don’t make a PR until I pass your test.”
  • “Prove to me this works – diff the behavior between main and this branch.”

These push Claude out of “just finish the task” mode and into checking its own work. And you have tools for stopping a bad run: Esc halts mid-action with context preserved, Esc + Esc or /rewind restores earlier conversation and code state, and “undo that” asks Claude to revert. If you’ve corrected the same problem twice and it’s still wrong, the context is cluttered with failed attempts. Run /clear and restart with a better prompt, which almost always beats a long session full of corrections.

One limit to remember: checkpoints only capture changes made through Claude’s file-editing tools, not bash commands or outside processes. They aren’t a replacement for git, so commit before big changes.

8. Let Claude Interview You Before Big Features

For larger work, start with a minimal prompt and have Claude question you. Anthropic suggests using the AskUserQuestion tool:

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

When the spec is done, start a fresh session to execute it. The new session has clean context focused on implementation, and you have a written reference. The best specs are self-contained: they name the files and interfaces involved, state what’s out of scope, and end with a verification step that proves the feature works end to end.

9. Use Hooks for Rules That Must Always Hold

CLAUDE.md instructions are advisory. Hooks are deterministic: they run your script at a fixed point in Claude’s workflow, so the action happens every time. You can even ask Claude to write one (“write a hook that runs eslint after every file edit”), then run /hooks to see what’s configured. Three patterns cover most needs:

  • PostToolUse for cleanup. Cherny’s team runs bun run format || true after edits, which fixes the last bit of formatting before CI would complain. PostToolUse runs after the action, so it can’t undo anything.
  • PreToolUse for blocking. A script that exits with code 2 blocks the tool call and shows your message to Claude. Exit code 1 doesn’t block on most events, so a policy hook must use 2.
  • Stop for “keep going.” A Stop hook can block Claude from ending a turn until a check passes, or nudge it to verify its work.

Hooks live in .claude/settings.json for the project, ~/.claude/settings.json for you, or .claude/settings.local.json for local overrides you don’t commit.

10. Pick the Right Extension: Skills, Subagents, MCP or Plugins

Claude Code has several ways to extend it, and using the wrong one is a common source of bloat. Here’s how Anthropic’s docs split them:

FeatureWhat it is forRemember
CLAUDE.mdFacts and rules that apply to nearly every task: commands, style, repo etiquetteAdvisory, and loaded every session, so keep it lean
.claude/rules/Instructions for one part of the codebasePath-scoped rules load only when Claude touches matching files
Skills (SKILL.md)Domain knowledge and repeatable workflows, loaded on demandInvoke with /skill-name; add disable-model-invocation: true for workflows with side effects
HooksActions that must happen every time with no exceptionsDeterministic, unlike CLAUDE.md
Subagents (.claude/agents/)Investigation and review in a separate context with its own tool listReport back summaries, which keeps your main context clean
MCP serversConnect outside tools such as Notion, Figma or a databaseclaude mcp add; CLI tools like gh are more context-efficient where they exist
PluginsBundles of skills, hooks, subagents and MCP serversBrowse with /plugin

A minimal skill is just a folder with a SKILL.md that carries a short front-matter block (name and description) and the instructions. A custom subagent is a markdown file in .claude/agents/ with its own allowed tools and, optionally, its own model. Tell Claude explicitly to use one: “Use a subagent to review this code for security issues.”

11. Set Permissions Sensibly

Constant approval prompts train you to click without reading. Anthropic’s answer has layers:

  • Auto mode. A separate classifier model reviews most actions and blocks only what looks risky, such as scope escalation, unknown infrastructure or actions driven by hostile content. From Claude Code v2.1.283, it’s the built-in starting mode for interactive terminal and VS Code sessions.
  • Allowlists. Pre-approve tools you trust, like npm run lint or git commit, with /permissions.
  • Sandboxing. /sandbox adds OS-level limits on filesystem and network access so Claude can work more freely inside a boundary.
  • Manual mode. Switch back when you want to approve every edit and command yourself.
  • Skipping permissions entirely with --dangerously-skip-permissions is something Cherny says he almost never does.

Before/After Prompt Examples (Real Comparisons)

Example 1: Bug Fix

❌ Before (weak prompt):

Fix the auth bug

✅ After (rich context prompt):

<instructions> Fix the race condition in the token refresh logic. Plan first, do not edit files yet. </instructions> <context> Read CLAUDE.md and src/auth/refresh.ts. The failing test is auth.test.ts line 47 – it fails under concurrent requests. </context> <constraints> – Keep the public API unchanged – No new dependencies – Run `bun test auth` after each change and fix failures before moving on </constraints>

Example 2: Code Refactor

❌ Before:

Refactor the CLI module to be cleaner

✅ After:

<instructions> Refactor cli.tsx for readability. Plan the changes first. After I approve the plan, implement in phases. </instructions> <context> Read src/cli/cli.tsx and the patterns in src/utils/ that I want you to follow. The goal is consistency with the rest of the codebase. </context> <constraints> – Do not change any public exports – Do not add abstractions for one-time operations – Run `bun run typecheck` after each phase – Do not touch unrelated files </constraints>

The difference isn’t just length. It’s specificity of constraints and a built-in verification step. That’s what makes Claude’s output usable on the first pass.


Claude Code vs OpenAI Codex – How the Techniques Compare

An earlier version of this section compared Claude Code with ChatGPT’s chat window and called the gap large. That’s out of date: the real comparison is now Claude Code against OpenAI’s Codex agent, and the two have converged. Both read a project instruction file, support skills, subagents and hooks, and run remotely or headless. Here’s where they stand:

DimensionClaude CodeOpenAI Codex
Project instructionsCLAUDE.md hierarchy with @imports, plus .claude/rules/ and auto memoryAGENTS.md hierarchy; closest file wins
Skills.claude/skills/ with SKILL.md.agents/skills/ with SKILL.md
Subagents.claude/agents/*.md with per-agent tool listsSubagents now available, configured in .codex/
HooksGranular events such as PreToolUse, PostToolUse and StopLifecycle hooks in .codex/hooks.json, reportedly less granular
Plan modeBuilt in (Shift+Tab, or --permission-mode plan)A /plan command
Worktreesclaude --worktree and a desktop optionBuilt in
Parallel workSubagents, /batch, agent view (preview), agent teams (experimental)Managed cloud tasks and subagents
Terminal-Bench 4.0 (vendor-reported)Opus 5.5: 66.4%GPT-6 Astra: 57.9%

The benchmark row needs a caveat. Anthropic reports Opus 5.5 at 66.4% on Terminal-Bench 4.0 against Astra’s 57.9%, but those are vendor figures, and OpenAI points to GPT-6.1 Sol matching Astra on DeepSWE v1.1 at a fraction of the price. For model comparisons, see our Claude vs ChatGPT breakdown.

Bottom line: Claude Code has the deeper, more granular harness, with finer hook events and the most mature memory system. Codex counters with managed cloud parallelism, and AGENTS.md has become the shared standard many tools read. Many teams run both, which is why the FAQ below covers writing one instruction file for both.


Advanced Claude AI Prompt Engineering Tips for 2026

These are the techniques that separate good Claude Code users from great ones. Claude AI prompt engineering in 2026 has moved well beyond “write a clear prompt.”

Run parallel sessions. Cherny runs several Claude sessions at once, personally in separate git checkouts, while most of the Claude Code team prefers worktrees. Use claude --worktree or the Desktop app’s worktree option so edits don’t collide. The agent view (claude agents, a research preview) lets you dispatch background sessions and watch them from one screen, and agent teams, which are experimental and off by default, coordinate multiple sessions with shared tasks.

Use a Writer/Reviewer pair. A fresh context improves review, because Claude isn’t biased toward code it just wrote. Have Session A implement a rate limiter, then ask Session B to review it for edge cases and race conditions, and feed the feedback back to A. The same works for tests: one Claude writes tests, another writes code to pass them.

Add an adversarial review step. Before you count unattended work as done, have a subagent review the diff against the plan in a fresh context. The bundled /code-review skill reviews the current diff for bugs. A caution from Anthropic: a reviewer told to find gaps will usually find some, even in sound work, so tell it to flag only gaps that affect correctness or the stated requirements, or you’ll end up over-engineering.

Use subagents for investigation. Append “use subagents to investigate X” when exploring, so file reading doesn’t eat your main window. For large migrations, /batch <instruction> splits the change across 5 to 30 subagents, each in its own worktree.

Run it headless. claude -p "prompt" runs non-interactively, which is how you plug Claude into CI, pre-commit hooks and scripts. Output can be text, JSON or streaming JSON. For unattended loops, pre-approve what’s needed and deny the rest:

for file in $(cat files.txt); do claude -p "Migrate $file from Python 2 to Python 3. Return OK or FAIL." \ –allowedTools "Edit,Bash(git commit *)" \ –permission-mode dontAsk done

Test the prompt on two or three files first, and refine it before running on the full list.

Use voice dictation. You speak faster than you type. Cherny’s team uses macOS dictation (press fn twice) for prompts, and reports that prompts get more detailed as a result.

Keep an eye on usage. Use /usage to check where you are, show it continuously in the status line, and remember that MCP servers add overhead to every session. Resume a long-idle session sparingly, since it re-reads the whole history.

Name and resume sessions. /rename sessions like branches (oauth-migration), then use claude --continue or claude --resume to pick up where you left off.


Common Claude Code Mistakes – Full Checklist

Run through this before your next session:

  • No CLAUDE.md – Claude has no memory of your conventions between sessions
  • An over-stuffed CLAUDE.md – important rules get lost, so prune it or convert rules into hooks
  • Vague task description – “fix the bug” instead of naming the bug, the file and what “fixed” means
  • No negative constraints – Claude adds dependencies, touches unrelated files, creates helper scripts
  • No verification step – the trust-then-verify gap: a plausible implementation that misses edge cases
  • The kitchen-sink session – mixing unrelated tasks in one long conversation degrades context quality
  • Correcting over and over – after two failed corrections, /clear and restart with a better prompt
  • Rewriting prompts instead of giving feedback – slower and less effective than targeted correction
  • The infinite exploration – an unscoped “investigate” that reads hundreds of files; scope it or use subagents
  • Skipping plan mode on multi-file work – jumping straight to implementation when the approach is uncertain
  • Not committing before major changes – checkpoints aren’t a substitute for git
  • Accepting the first solution – push back with “implement the elegant solution” before approving
  • No parallel sessions – doing sequential work that could run simultaneously

FAQ – Claude Code Best Practices

Should I write AGENTS.md or CLAUDE.md if my team also uses Codex?

Keep the shared rules in AGENTS.md, which Codex reads, and add a short CLAUDE.md for Claude Code that imports it with an @AGENTS.md line. Claude Code’s memory docs list AGENTS.md among the instruction files it can load, and community setups commonly use this import pattern. Put Claude-only items, such as hooks and subagent notes, in CLAUDE.md or in .claude/ so the shared file stays vendor-neutral.

How long should my CLAUDE.md be?

Shorter than you think. Anthropic’s test is whether removing a line would cause Claude to make a mistake; if not, cut it. For scale, InfoQ reported that the Claude Code team’s own CLAUDE.md was about 2.5k tokens, and community guides suggest 50 to 100 lines in the root file, moving the rest into path-scoped rules. Run /doctor on a checked-in file and Claude proposes cuts.

How do I stop Claude Code from reading my .env or other secrets?

Use a PreToolUse hook that matches the file tools (Read, Edit and Write) and exits with code 2 when the path matches .env or similar. Exit code 2 blocks the call and sends your message back to Claude, whereas exit code 1 only logs an error and lets the tool run. Pair it with permission rules from /permissions and, for bash commands, sandboxing via /sandbox. Don’t paste real secrets into CLAUDE.md, since it’s checked into git.

Where else can I run Claude Code besides the terminal?

There’s a desktop app, VS Code and JetBrains extensions, and Claude Code on the web at claude.ai/code, which runs sessions on Anthropic-managed infrastructure. Boris Cherny has also said the Claude mobile app has a Code tab, and a /remote-control command is listed by community trackers for driving a local session remotely. Check that a feature exists in your version before relying on it, since some of these are marked beta or research preview.

Is Claude Code included in the $20 Claude plan?

Yes, with usage limits. Claude Pro at $20 a month ($17 on annual billing) includes Claude Code, and the free plan does not. Anthropic’s docs note that Claude Code is billed by API token consumption if you use it through the Console, and recommend /usage to check where you stand. If you keep hitting limits on Pro, that’s the point to consider a Max plan or API billing.

Which model should I pick for Claude Code right now?

Run /model to see your default. Since September 22 the opus alias points to Opus 5.5 on recent versions (v2.1.280 or later), and Opus 5.5 defaults to medium effort, one step below earlier Opus models. Sonnet 5.5 is the cost-efficient choice, /model fable gives you Fable 5.1 for the hardest long-running work (v2.1.257 or later), and the opusplan alias uses Opus while planning and Sonnet while executing.


Related Reading on AI Tech Safar


Useful Sources

For the broader context and related reading, explore our AI Tools 2026: Free Options, Categories and Companies.

Related AI Articles

Leave a Reply

Your email address will not be published. Required fields are marked *