A current, sourced guide to the Claude Code features worth learning: what they do, when to use them, when not to, and one practice rep to make each one stick.
If you already know the map, start here. This is the dated layer for meaningful changes since the guide was first published.
/effort ultracode is not just "try harder." It is the mode where Claude can stop working turn-by-turn and write a Dynamic Workflow: an orchestration script that runs agent phases, passes results forward, and keeps the main session cleaner.
Auto mode is now available on Bedrock, Vertex, and Foundry for Opus 4.7 and Opus 4.8 when enabled with CLAUDE_CODE_ENABLE_AUTO_MODE=1. That matters for teams whose real work runs through enterprise providers.
Plugins in .claude/skills auto-load, claude plugin init <name> scaffolds local plugins, and plugin autocomplete improved. This makes repo-local team tooling feel less like publishing infrastructure.
Agent View can run attachable shell commands with ! command, worktrees can be entered mid-session, /chrome lets you pick the connected browser, /simplify is now a cleanup pass, and workflow keyword triggers can be disabled.
Current changelog wording puts Opus 4.8 Fast Mode at about 2.5x the speed for 2x the standard rate. It is useful for live pairing and debugging, not a quality upgrade.
You are not supposed to read this front to back. Open the thing you need, read only as much as helps, try the rep on real work, and check it off only when it actually helped.
Need a different entry point? Use the beginner path, Practice Dojo, Codex guide, prompt library, or sources.
A Skill is a SKILL.md file — markdown instructions plus YAML frontmatter — that loads when you type /name or when Claude matches its description. The whole game is progressive disclosure: only descriptions cost context at startup, bodies load on use, reference files load only when read.
| Thing | Runs in | Context cost | Best for |
|---|---|---|---|
| Skill | Your conversation (or forks) | Description always; body on invoke | Repeatable procedures, on-demand reference |
| Subagent | Isolated window | Only the summary returns | Verbose work you don't want in context |
| CLAUDE.md rule | Every turn | Every request, forever | Facts always true (stack, style, env) |
If a CLAUDE.md section became a multi-step procedure instead of a fact, it should be a skill. If you keep pasting the same instructions, that's the signal.
--- name: fix-issue description: Fix a GitHub issue. Use when user says "fix issue", "resolve #N"... disable-model-invocation: true # side effects -> you fire it, not Claude allowed-tools: Read Edit Bash(gh *) Bash(git *) --- # Fix Issue $ARGUMENTS !`gh issue view $ARGUMENTS` # runs BEFORE Claude sees it, output injected inline 1. Read above. 2. Grep code. 3. Fix. 4. Test. 5. git commit -m "fix (#$ARGUMENTS)"
description is the trigger — capped 1,536 chars, matched first. Put the phrases people actually type into when_to_use (it shares that budget) so the skill fires when you mean it to.!`cmd` = render-time shell injection (preprocessing, not Claude executing). Great for grounding in live data.SKILL.md under 500 lines; put deep docs in references/, scripts in scripts/ (Claude runs them, doesn't read them).user-invocable: false only hides a skill from the / menu — Claude can still call it. To block Claude from auto-firing a destructive skill, use disable-model-invocation: true.A plugin bundles skills + commands + agents + hooks + MCP servers + bin/ executables, shipped through a marketplace (a git repo with a marketplace.json). You get namespacing (/my-plugin:review), one-command install, and versioning for teammates. There's no built-in skill-creator — you author skills with Claude: have it write the SKILL.md, then test on fresh instances and refine.
Type /plugin, select a plugin to see its context cost, then /skills to toggle a noisy one to name-only.
Three primitives people conflate: subagents (isolated, return a summary), background agents (full sessions that survive your terminal closing), and agent teams (peers that message each other). Plus the claude agents dashboard to drive them all.
A fresh Claude session with its own context, restricted tools, and chosen model. It can read 50 files and only the answer lands back in your context. Defined in .claude/agents/*.md. Use model: haiku for search, isolation: worktree to keep it from colliding, memory: project to persist learnings across sessions.
Run claude agents for a full-screen dashboard of every running, blocked, and finished session — peek with Space, background any session with ←. Agent teams let a lead spawn teammates that talk to each other via a shared task list, not just back to the lead. Fire-and-forget with claude --bg "..." and keep working.
Run claude agents, then claude --bg "summarize this repo in 5 bullets", and hit Space on the row to peek. The whole background loop in 30 seconds.
CLAUDE.md loads every session, every request — so every line is a recurring token tax. Anthropic's own docs put it bluntly: "Bloated CLAUDE.md files cause Claude to ignore your actual instructions." Target under 200 lines.
AGENTS.md, with global/project/nested discovery and a documented byte budget. See AGENTS.md →For every line: "Would removing this cause a mistake?" If not, cut it. Keep commands Claude can't guess, style that differs from defaults, repo etiquette, env quirks. Drop standard conventions, "write clean code," and API docs (link them instead).
Files concatenate root-down: managed → ~/.claude/CLAUDE.md → project → CLAUDE.local.md. Nested package files load on demand. Use @imports for shared conventions and .claude/rules/ with paths: for file-scoped rules. Separately, Auto Memory (on by default) lets Claude write its own MEMORY.md per repo. Auto Dream, which consolidates those notes, is still experimental and rolling out — don't count on having it yet.
Run /memory to see exactly what's loaded this session — and which files Claude is quietly writing to its own memory.
The enforcement layer. CLAUDE.md is a request; a hook is a deterministic gate you still review like code. MCP plugs in external tools. Sandbox and permissions decide what any of it can touch.
Shell commands that fire at lifecycle events (~30 of them). The daily ones: PostToolUse to auto-format on edit, PreToolUse to block edits to .env, Stop to run a test-gate that feeds failures back, Notification to ping you when Claude's idle. The new if field scopes a hook to specific calls.
Add servers with claude mcp add (http/stdio), three scopes, OAuth via /mcp. In current Claude Code builds, Tool Search defers tool definitions, so a big MCP roster is less likely to drown your context; check live docs if this behavior changes. A good starting set: GitHub + Context7 + Playwright.
OS-level sandboxing (Seatbelt / bubblewrap), paired with explicit deny rules for sensitive paths, can stop injected commands from reaching places like ~/.ssh. Pair it with autoAllowBashIfSandboxed to cut approval fatigue. Permission modes cycle with Shift+Tab; /fewer-permission-prompts builds you a safe allowlist from your own transcripts.
Run /sandbox for your isolation status, then /fewer-permission-prompts to auto-generate an allowlist and cut the interruptions.
In four months Claude Code grew a cloud execution surface, scheduled agents, self-driving loops, and phone access. The ones actually worth knowing:
/effort ultracode + Dynamic Workflows — Claude can create an orchestration script and run a subagent graph for large parallelizable work. This is the jump from "Claude as worker" to "Claude as workflow runner." Use it deliberately: current docs list up to 16 concurrent agents and 1,000 total agents per run.claude plugin init, project .claude/skills loading, ! cmd in Agent View, claude --bg --exec, EnterWorktree, /simplify, workflow-trigger control, /chrome browser selection, and Opus 4.8 Fast Mode at 2x cost for about 2.5x speed./goal — set a completion condition and Claude auto-loops turns until it holds. /loop — self-pacing scheduled tasks. /powerup — in-terminal interactive lessons./ultrareview — plan and bug-hunt in the cloud. /autofix-pr — Claude watches CI and pushes fixes until green.Subagents delegate work. Dynamic Workflows delegate the orchestration itself. Reach for /effort ultracode when the task needs independent lanes, cross-checking, or repeatable phases. Drop back to /effort high when the work is routine, sequential, or same-file.
Run /powerup — Anthropic's own in-terminal lessons. It exists because the tool ships weekly. It's the catch-up button.
The move is not "ask two AIs the same vague thing." The move is independent attempts, adversarial review, and one synthesis pass against the same acceptance criteria. Two strong agents are useful when they disagree for good reasons.
| Pattern | How to run it | Why it works |
|---|---|---|
| Alternative reviews | Claude writes, Codex reviews. Then flip it. | Different failure modes. The reviewer is not emotionally attached to the diff. |
| Head-to-head build | Give both the same task in separate worktrees or branches. | You get two concrete solutions instead of one confident guess. |
| Competition framing | Tell each one who it is competing against, then judge by evidence. | It often raises effort, but it is a framing trick — tests and acceptance criteria still decide. |
| Synthesis pass | A fresh agent compares both outputs and chooses, merges, or rejects. | Prevents "average the two answers" compromise mush. |
Use this when Claude Code and Codex are each working in separate worktrees or branches.
You are competing against <competitor name>. Build the best solution to this exact task. Task: <paste the task> Acceptance criteria: <paste the checklist> Rules: - Same repo, same constraints, no shortcuts. - Optimize for correctness, smallest safe diff, clear product fit, and verification evidence. - Do not imitate the competitor. Beat them by being more precise. - Done means: changed files listed, tests/checks run, risks named, and any manual verification described.
Use this when one tool produced a diff and the other gets a clean review pass.
Review this work as if <competitor name> already approved it and your job is to find what they missed. Focus on: - correctness and hidden edge cases - security, data loss, privacy, and permission mistakes - missing tests or weak verification - unnecessary scope creep - mobile/browser/product regressions Give file/line evidence. Rank findings by severity. If there are no real issues, say that clearly and name the residual risk.
Use this after two implementations or two reviews. Do not let it average both answers just to sound fair.
Compare Solution A and Solution B. Pick the winner or merge the best parts. Judge by: - correctness - maintainability - smallest safe diff - test and browser evidence - product fit - risk of hidden follow-up work Do not compromise by averaging. Make a decision, explain it, and give the next concrete action.
Type / in any session to see yours. The ones worth memorizing:
| Command | Does | Command | Does |
|---|---|---|---|
/goal | Auto-loop until a condition's met | /agents | Manage subagents |
/loop | Recurring scheduled task | /mcp | Manage MCP servers |
/powerup | Interactive lessons | /memory | Audit loaded context |
/usage | What's driving your limits | /sandbox | Isolation status |
/doctor | Diagnose config/budget | /theme | Custom colors |
/rewind | Roll back / summarize | /fewer-permission-prompts | Auto-allowlist |
CLI: claude agents · claude --bg "..." · claude --worktree x · claude --agent X · claude mcp add · claude plugin validate.