# Claude Code: Everything You Need to Know 
**From first prompt to agent teams β one guide.**
[](https://github.com/hesreallyhim/awesome-claude-code)
[](https://github.com/wesammustafa/Claude-Code-Everything-You-Need-to-Know)
[](https://github.com/wesammustafa/Claude-Code-Everything-You-Need-to-Know/commits/main)
[](LICENSE)
A practical guide to Claude Code β from your first prompt to multi-agent automation, hooks, MCP, and team workflows. Built around clear mental models and real examples, not marketing.
```bash
npm install -g @anthropic-ai/claude-code
```
**Who this is for:** Developers using (or about to use) Claude Code. Beginners get a guided path; power users get depth on Skills, Hooks, MCP, and Agent Teams.
---
## π§ Choose your path
| You are⦠| Start here | Time |
|---|---|---|
| π **New to Claude Code** | [Setup](#claude-code-setup) β [Prompt Engineering](#prompt-engineering-deep-dive) β [Your First Skill](#claude-skills) | ~15 min |
| β‘ **Already using it, want depth** | [Skills](#claude-skills) Β· [Hooks](#hooks) Β· [MCP](#model-context-protocol-mcp) | ~30 min each |
| π§ **Building teams or automation** | [Dynamic Workflows](#dynamic-workflows) Β· [Agent Teams](#agent-teams-experimental) Β· [BMAD](#the-bmad-method--ai-agent-framework) | varies |
---
## π§ When to use what
The five extension points in Claude Code, side by side:
| Tool | Use when⦠| Skip if⦠| Lives in |
|---|---|---|---|
| **[Skills](#claude-skills)** *(slash commands)* | You repeat the same prompt or workflow β₯3 times | One-off task | `.claude/commands/*.md` |
| **[Hooks](#hooks)** | You want code to run *automatically* on tool use, session start, etc. | You only want manual triggers | `.claude/settings.json` |
| **[Subagents](#ai-agents)** | A subtask is big enough to need its own isolated context | The task fits in your main session | `.claude/agents/*.md` |
| **[Workflows](#dynamic-workflows)** | The job needs more agents than one conversation can coordinate | A couple of subagents would do | `.claude/workflows/*.js` |
| **[MCP servers](#model-context-protocol-mcp)** | You need Claude to use *external* tools (browsers, DBs, APIs) | All your data is in local files | Configured per project |
> π‘ These five compose. Most polished setups combine 2β3.
---
## π What's inside
**Fundamentals** β [What is Claude Code?](#what-is-claude-code) Β· [Setup](#claude-code-setup) Β· [Prompt Engineering](#prompt-engineering-deep-dive)
**Workflow extensions** β [Slash Commands](#claude-commands) Β· [Skills](#claude-skills) Β· [Hooks](#hooks)
**Multi-agent & integration** β [Subagents](#ai-agents) Β· [Dynamic Workflows](#dynamic-workflows) Β· [Agent Teams](#agent-teams-experimental) Β· [Automation surface](#beyond-one-terminal--the-2026-automation-surface) Β· [MCP](#model-context-protocol-mcp)
**Productivity & frameworks** β [Effort levels](#effort-levels) Β· [Fast Mode](#fast-mode) Β· [Super Claude](#super-claude-framework) Β· [BMAD Method](#the-bmad-method--ai-agent-framework)
**Reference** β [Slash Command Cheatsheet](#built-in-slash-commands) Β· [Effort levels](docs/reference/effort-levels.md) Β· [Workflows](docs/workflows.md) Β· [Agent Teams](docs/agent-teams.md) Β· [Skills](docs/skills.md) Β· [FAQ](#faq) Β· [Updates & Deprecations](#updates--deprecations) Β· [Further Reading](#references)
### What is Claude Code?
Claude Code is Anthropic's official CLI for working with Claude from your terminal. You point it at a project; it reads the code, plans, edits files, runs commands, and commits β all from the prompt line.
**Three things it does that a chat UI can't:**
- **Reads your actual repo** β not pasted snippets. Claude sees your file tree, runs `grep`, follows imports, and grounds answers in real context.
- **Edits in place and runs your tests** β diff-aware edits, then `pytest`/`vitest`/`go test` on the spot to verify the change.
- **Composes with the rest of your stack** β slash commands, hooks, sub-agents, MCP servers, and your normal git/shell workflow.
If you've used Copilot or Cursor, think of Claude Code as their "agent in your terminal" peer β same idea, different surface, no editor lock-in.
```bash
claude # start a session in the current repo
> explain what this codebase does
> fix the failing test in src/api.test.ts
> open a PR with the changes
```
---
### The Claude 5 era: today's model lineup
Three launches landed in quick succession this summer: **Claude Opus 4.8** (May 28, 2026) took over as the Opus-tier flagship, **Claude Fable 5** and its restricted sibling **Claude Mythos 5** (June 9, 2026) opened a new *Mythos-class* tier above Opus, and **Claude Sonnet 5** (June 30, 2026) became Claude Code's default model. 1M-token context is now standard across current Opus, Sonnet, and Fable models β no beta flag, no long-context surcharge β with 128K max output.
**Choosing a model β quick guide:**
| Model | Reach for it when⦠|
|---|---|
| **Sonnet 5** *(default)* | Everyday coding β most tasks live here. Intro pricing $2/$10 per MTok through Aug 31, 2026 (then $3/$15) |
| **Opus 4.8** | Complex reasoning, large refactors, orchestrating agents β $5/$25, unchanged from 4.7 |
| **Fable 5** | Genuinely hard problems β Mythos-class capability above Opus at $10/$50 |
| **Haiku 4.5** | Fast, lightweight tasks β quick questions, doc updates ($1/$5, 200K context) |
> Opus 4.7 / 4.6 and Sonnet 4.6 are now *legacy models* (still available via API and `/model`); Opus 4.1 retires August 5, 2026. **Mythos 5** is the same underlying model as Fable 5 with fewer safeguards β invitation-only for approved organizations via Project Glasswing.
>
> *[β Full specs, capabilities, and pricing in `docs/reference/models.md`](docs/reference/models.md)*
---
### Claude Code Setup
> β±οΈ **5-minute setup.** Get from zero to your first AI-assisted commit.
#### 1. Install
```bash
npm install -g @anthropic-ai/claude-code
```
> Requires Node.js 18+. For other install methods (Homebrew, curl, native binary), see the [official install guide](https://code.claude.com/docs/en/setup).
#### 2. Authenticate
```bash
claude
```
On first run, Claude Code opens a browser to sign in with your Anthropic account (Pro, Max, or API key all work). After that, you can re-authenticate any time with `/login` (and sign out with `/logout`) inside a session, or `claude auth login|status|logout` from your shell.
#### 3. Run your first prompt
From any project directory:
```bash
cd ~/your-project
claude
```
Once Claude Code is running, try one of these:
- `explain what this codebase does` β Claude reads your repo and summarizes.
- `add a README section about installation` β generates content based on your project.
- `find and fix the failing test in src/api.test.ts` β diagnoses and edits in place.
#### 4. (Optional) Generate a `CLAUDE.md`
```
/init
```
Creates a project-level instruction file that Claude reads on every session β your project's "house rules." More on this in [Prompt Engineering Deep Dive](#prompt-engineering-deep-dive).
#### 5. (Bonus) Steal this repo's setup
This repo's [`.claude/`](.claude/) directory is a **working, runnable** Claude Code project β one of each extension point, not screenshots of one. Every path below is something you can copy into your own project today:
| Path | What you get | Copy it when⦠|
|---|---|---|
| [`.claude/commands/`](.claude/commands) | 7 slash skills β `/pr`, `/review`, `/tdd`, `/test`, `/five`, `/ux`, `/todo` | You want PR hygiene and review rigor without writing the prompts |
| [`.claude/skills/`](.claude/skills) | An Agent Skill β `/claude-md-review` audits a `CLAUDE.md` for vagueness, dead paths, and bloat | You want a worked example of the [frontmatter contract](docs/skills.md#frontmatter-reference) |
| [`.claude/agents/`](.claude/agents) | 5 subagents, plus [10 more role prompts](#3-specialized-subagents--drop-in-role-prompts) in `specialized-agents/` | You want specialists without authoring role prompts β they double as [Agent Teams](#agent-teams-experimental) teammates |
| [`.claude/workflows/`](.claude/workflows) | A [dynamic workflow](#dynamic-workflows) β `/stale-docs-audit` fans agents across your docs, then refutes its own findings | You want a real script to read before writing your own |
| [`.claude/hooks/`](.claude/hooks) | Python hooks β `post_tool_use.py`, `notification.py`, `stop.py`, `subagent_stop.py` | You want [lifecycle automation](#hooks) (needs [`uv`](https://docs.astral.sh/uv/getting-started/installation/)) |
| [`.claude/settings.json`](.claude/settings.json) | Permissions + hook wiring | You're copying the hooks β swap the hardcoded `uv` path for `$(which uv)` |
```bash
git clone --depth 1 https://github.com/wesammustafa/Claude-Code-Everything-You-Need-to-Know /tmp/cc-guide
cp -r /tmp/cc-guide/.claude/commands/pr.md your-project/.claude/commands/ # take what you want
```
> β οΈ **Read before you copy.** Skills, hooks, agents, and workflows are executable instructions that run with your permissions β including from *this* repo. Copy file by file and read each one, the same way you'd review a shell script before sourcing it. Don't `cp -r` a whole `.claude/` you haven't opened.
> π‘ **Next:** [Claude Skills](#claude-skills) to build your own in 3 minutes.
---
### Prompt Engineering Deep Dive
> **π Claude Initialization**
> Run the `/init` command to automatically generate a `CLAUDE.md` file.
> Your `CLAUDE.md` files become part of Claude's prompts, so they should be refined like any frequently used prompt. A common mistake is adding extensive content without iterating on its effectiveness. Take time to experiment and determine what produces the best instruction following from the model.
#### 1. Explore β Plan β Code β Commit
> Versatile workflow for complex problems.
- **Explore:** Read relevant files/images/URLs; use subagents for verification. Do **not code yet**.
- **Plan:** Ask Claude to make a plan. Use `"think"`, `"think hard"`, `"think harder"`, or `"ultrathink"` to nudge depth in the prompt β see [Effort levels](#effort-levels) for the full reasoning dial. Optionally save the plan for future reference.
- **Code:** Implement the solution; verify reasonableness as you go.
- **Commit:** Commit results, create pull requests, update READMEs/changelogs.
- Claude has two default modes: `Plan Mode` and `Accept Edits Mode`. You can toggle between them using the `Shift + Tab` keys.
- 
- 
> **π‘ Pro Tip:** Research & planning first significantly improves performance for complex tasks.
---
#### 2. Test-Driven Workflow (Write Tests β Code β Commit)
> Ideal for changes verifiable with unit/integration tests.
- **Write Tests:** Create tests based on expected inputs/outputs; mark as TDD.
- **Run & Fail Tests:** Confirm they fail; no implementation yet.
- **Commit Tests:** Commit once satisfied.
- **Write Code:** Implement code to pass tests; iterate with verification via subagents.
- **Commit Code:** Final commit after all tests pass.
> πΉ Clear targets (tests, mocks) improve iteration efficiency.
---
#### 3. Visual Iteration (Code β Screenshot β Iterate β Commit)
- Provide screenshots or visual mocks.
- Implement code, take screenshots, iterate until outputs match mock.
- Commit once satisfied.
> πΉ Iteration significantly improves output quality (2-3 rounds usually enough).
---
#### 4. Effort levels β how hard Claude thinks
*[β Full guide in `docs/reference/effort-levels.md`](docs/reference/effort-levels.md)*
> **Mental model:** Effort is a **behavioural dial**, not a token budget β it shifts thinking depth, tool-call appetite, response length, and how persistently Claude pushes through multi-step work. Higher β smarter; context quality often matters more.
**The API knows 5 levels** (`low` β `max`, default `high`); **Claude Code adds a sixth:**
| Level | Reach for it when⦠|
|---|---|
| `low` | Fast interactive queries you're steering β file renames, simple greps |
| `medium` | General coding, small refactors, autonomous sessions where the plan is clear |
| `high` | Multi-file refactors, complex debugging β the default on current models |
| `xhigh` | Long autonomous agentic sessions (Fable 5, Mythos 5, Opus 4.8/4.7, Sonnet 5) |
| `max` | Architecture, subtle bugs, security review β genuinely hard problems only. Session-only |
| `ultracode` *(Claude Code only)* | `xhigh` reasoning **plus** automatic multi-agent [workflow orchestration](https://code.claude.com/docs/en/workflows). Session-only |
**Current defaults (July 2026):** Opus 4.8 β `high` on all surfaces; Sonnet 5 β `high` on API and Claude Code. Check yours with `/effort`. *(Historical footnote: Claude Code v2.1.117, April 2026, first standardized Pro/Max defaults to `high` after the March "nerfed medium" episode.)*
**Setting it, in order of persistence:**
```bash
# This turn only β adds an in-context cue (does not change API effort)
> ultrathink β design the migration strategy
# This session β slider with no args, level name with arg
/effort xhigh
/effort ultracode # xhigh + automatic multi-agent workflows
/effort auto # reset to model default
# All sessions (low/medium/high/xhigh) β add this key to .claude/settings.json:
# "effortLevel": "high"
# max and ultracode are session-only by design and can't be persisted.
```
> β οΈ **Two gotchas worth knowing:**
> - **`max` shows diminishing returns on routine work** and is more prone to overthinking β Anthropic's own guidance. Don't default to it.
> - **Context quality often beats more effort.** If you're reaching for max on a task that shouldn't need it, ~80% of the time the fix is upstream β sharper `CLAUDE.md`, atomic plan, named files. [Full breakdown β](docs/reference/effort-levels.md#effort--intelligence--the-context-quality-trap)
> π‘ **Pattern: plan-with-Opus / execute-with-Sonnet.** Plan in Opus 4.8 (or Fable 5) at xhigh or max; hand the atomic, zero-ambiguity plan to Sonnet 5 at lower effort to execute. Sonnet follows clear plans without drift, so the cheap execution is reliable when the plan is sharp.
---
### Claude Commands
Claude Code ships dozens of built-in slash commands ([official reference](https://code.claude.com/docs/en/commands)) plus the ability to define your own as **skills** (markdown files in `.claude/commands/`). The two work together β built-ins for common operations, custom skills for your team's workflows.
#### Day-1 essentials
| Command | Purpose |
|---|---|
| `/init` | Generate a `CLAUDE.md` for your project β your "house rules" Claude reads every session |
| `/help` | List all available commands |
| `/clear` | Reset conversation history when you want a clean slate |
| `/usage` | Track token and plan usage (merged `/cost` + `/stats` as of v2.1.118) |
| `/model` | Switch models β your pick persists as the default for new sessions (press `s` for session-only) |
> *[β Curated slash-command cheatsheet in `docs/reference/commands.md`](docs/reference/commands.md)* (including `/fast`, `/hooks`, `/mcp`, `/teleport`, `/workflows`, `/rewind`, β¦)
#### Custom slash commands
Define a frequently-used prompt once as a markdown file, invoke it forever with `/skill-name`:
```bash
mkdir -p .claude/commands
echo "Analyze this code for performance issues and suggest optimizations:" \
> .claude/commands/optimize.md
```
> π‘ **Next level:** custom slash commands and Skills are the same thing. Head to [Claude Skills](#claude-skills) for the deep dive β built-in skills, the 7 custom skills in this repo, workflow recipes, and how to write your own.
---
### Claude Skills
*~3 min read Β· [Full guide in `docs/skills.md` β](docs/skills.md)*
> **Mental model:** Skills package a workflow into a markdown file. Two equivalent formats β officially one system now:
> - **Slash skills** β `.claude/commands/.md`, you invoke them with `/`
> - **Agent Skills** β `.claude/skills//SKILL.md` with YAML frontmatter; Claude can also auto-invoke these when the description matches the task
>
> `.claude/commands/deploy.md` and `.claude/skills/deploy/SKILL.md` both create `/deploy`. Skills follow the open [agentskills.io](https://agentskills.io) standard, adopted by ~40 products beyond Claude Code (Codex, Copilot, Cursor, Gemini CLI, β¦).
> β οΈ **Security:** Skills are executable instructions running with your shell permissions. Read every third-party skill before adding it β exactly like reviewing a shell script before sourcing it.
Project beats user beats built-in β which is how this repo's custom `/review` deliberately shadows the built-in one. Slash skills load on `/` autocomplete; Agent Skills preload only their metadata and read the body on demand. [Full lookup table β](docs/skills.md#where-claude-looks)
#### Your first skill in 3 minutes
```bash
mkdir -p .claude/commands
cat > .claude/commands/analyze.md << 'EOF'
# Code Analysis
Analyze the current code for:
- Potential bugs and edge cases
- Performance optimizations
- Code quality improvements
- Security vulnerabilities
Provide specific, actionable recommendations.
EOF
claude # then type: /analyze
```
That's it β a working slash skill. Promote it to an Agent Skill later by moving it to `.claude/skills/analyze/SKILL.md` and adding `name`/`description` frontmatter.
#### Want more depth?
The [full Skills guide in `docs/skills.md`](docs/skills.md) covers:
- The 8 skills shipped here: `/pr`, `/review`, `/tdd`, `/test`, `/five`, `/ux`, `/todo`, plus the Agent Skill [`/claude-md-review`](.claude/skills/claude-md-review/SKILL.md)
- Bundled built-in skills (e.g. `/dataviz`, `/debug`, `/keybindings-help`)
- Slash skills vs Agent Skills, and the [full frontmatter reference](docs/skills.md#frontmatter-reference) β including why `allowed-tools` **grants** permission rather than restricting it
- Workflow recipes β feature dev with TDD + PR, bug investigation, UX-first dev
- How to write your own skills (file format, scope, examples)
- Skills FAQ, troubleshooting, and best practices
#### Beyond your own skills β the ecosystem
The community has built an enormous catalog of Agent Skills. Three places to start browsing:
| Resource | What it offers |
|---|---|
| [**anthropics/skills**](https://github.com/anthropics/skills) | Anthropic's official skills β PDF, slides, brand guidelines, document creation (158k+ β) |
| [**SkillHub**](https://www.skillhub.club/) Β· [**SkillsMP**](https://skillsmp.com/) Β· [**Smithery**](https://smithery.ai/skills) Β· [**skills.sh**](https://skills.sh/) | Searchable marketplaces β community Agent Skills indexed from GitHub at massive scale |
| [`travisvn/awesome-claude-skills`](https://github.com/travisvn/awesome-claude-skills) Β· [`ComposioHQ/awesome-claude-skills`](https://github.com/ComposioHQ/awesome-claude-skills) | Curated lists for high-signal picks |
Notable community skills: `skill-creator`, `skill-installer`, `mcp-builder`, `systematic-debugging`, `pair-programming`, `github-code-review`, `pptx`, `react`, `frontend-design`, `prompt-engineering-patterns`, `superpowers`, `brainstorming`, `market-research-reports`, `senior-data-engineer`, and many more β see [the full ecosystem section in `docs/skills.md`](docs/skills.md#the-skills-ecosystem) for categorized tables and install paths.
---
### Hooks
> **Mental model:** Hooks are programmable checkpoints on Claude Code's lifecycle (before/after a tool call, session start, prompt submit, etc.). Your script inspects the proposed action and returns *allow* / *deny* / *modify*.
**Three cases that win most teams over:**
| Use case | What the hook does |
|---|---|
| Auto-format on save | Runs `prettier` / `ruff` / `gofmt` after every Edit so Claude's output matches your style |
| Block sensitive paths | Refuses changes to `.env`, `secrets/`, `infra/prod/` regardless of what Claude tries |
| Action audit log | Records every tool call to a file β paper trail of what Claude did and when |
If none of those resonate, skip ahead.
#### Setting up hooks
Hooks live in settings files at four scopes (later overrides earlier):
| Scope | Path |
|---|---|
| User-wide | `~/.claude/settings.json` |
| Project (committed) | `.claude/settings.json` |
| Project (local, gitignored) | `.claude/settings.local.json` |
| Enterprise managed policy | platform-specific |
**Quickest setup** β use the interactive menu:
```bash
/hooks # browse, enable, configure hooks without touching JSON
```
**Manual setup** β for the hook scripts in this repo:
1. Copy `.claude/hooks/` into your project's `.claude/` folder.
2. Delete the hook scripts you don't need; keep the rest.
3. Install [`uv`](https://docs.astral.sh/uv/getting-started/installation/) (required to run the Python hook scripts).
4. Copy `.claude/settings.json` into your project's `.claude/` folder.
5. In `settings.json`, replace any hardcoded `uv` path with the output of `$(which uv)`.
```text
project-root/
βββ .claude/
βββ hooks/
β βββ notification.py
β βββ post_tool_use.py
β βββ ...
βββ settings.json
```
#### Hook Events
Hooks run in response to various events within Claude Code's lifecycle:
[examples](https://github.com/disler/claude-code-hooks-mastery)
- **`PreToolUse`**: Runs **after Claude creates tool parameters but before processing the tool call**.
- **`PostToolUse`**: Runs **immediately after a tool completes successfully**.
- **`Notification`**: Runs when Claude Code sends notifications, such as when permission is needed to use a tool or when prompt input has been idle.
- **`UserPromptSubmit`**: Runs when the user submits a prompt, **before Claude processes it**.
- **`Stop`**: Runs when the main Claude Code agent has finished responding (does not run if stopped by user interrupt).
- **`SubagentStop`**: Runs when a Claude Code subagent (Task tool call) has finished responding.
- **`SessionEnd`**: Runs when a Claude Code session ends.
- **`PreCompact`**: Runs before Claude Code is about to run a compact operation.
- **`SessionStart`**: Runs when Claude Code starts a new session or resumes an existing session.
- **`TeammateIdle`**: Runs when an agent teammate becomes idle (Agent Teams) β exit code 2 sends the teammate back to work.
- **`TaskCompleted`**: Runs when a task is marked as completed β exit code 2 blocks the completion.
> These are the most-used events. The full catalog is **30 events** (SubagentStart, PermissionRequest, FileChanged, WorktreeCreate, PostCompact, β¦) β see the [official hooks reference](https://code.claude.com/docs/en/hooks).
#### Hook input
Hooks receive **JSON via stdin**. Every event includes `session_id`, `transcript_path`, and `cwd`. Event-specific fields:
| Hook Event | Event-specific fields |
|---|---|
| `PreToolUse` | `tool_name`, `tool_input` |
| `PostToolUse` | `tool_name`, `tool_input`, `tool_response` |
| `Notification` | `message` |
| `UserPromptSubmit` | `prompt` |
| `Stop` / `SubagentStop` | `stop_hook_active` |
| `PreCompact` | `trigger`, `custom_instructions` |
| `SessionStart` | `source` |
| `SessionEnd` | `reason` |
| `TeammateIdle` | `teammate_id`, `last_activity` |
| `TaskCompleted` | `task_id`, `task_name`, `completion_time` |
> βΉοΈ The `team_name` field in `TaskCreated` / `TaskCompleted` / `TeammateIdle` payloads is deprecated since v2.1.178 (one implicit team per session).
#### Hook output
Two ways to communicate back: **exit codes** for simple control, **JSON in stdout** for fine-grained behavior.
| Exit code | Effect |
|---|---|
| `0` (success) | `stdout` shown in transcript mode (CTRL-R). For `UserPromptSubmit` / `SessionStart`, `stdout` is added to Claude's context. |
| `2` (blocking) | `stderr` fed back to Claude (or shown to user) to block the action. Stops tool calls in `PreToolUse`; stops prompt processing in `UserPromptSubmit`. |
| Other | `stderr` shown; execution continues. |
**Advanced: structured JSON in stdout.** Per-event decision fields:
| Event | JSON output |
|---|---|
| `PreToolUse` | `permissionDecision`: `"allow"` / `"deny"` / `"ask"`; `updatedInput` to modify tool parameters |
| `PostToolUse` | `decision`: `"block"` or `undefined`; `additionalContext` can be returned |
| `UserPromptSubmit` | `decision`: `"block"` or `undefined`; `additionalContext` can be returned |
| `Stop` / `SubagentStop` | `decision`: `"block"` or `undefined` |
| `SessionStart` | `additionalContext` |
#### Security considerations
Hooks run **arbitrary shell commands automatically** with your user permissions β they can read, modify, or delete any file you can. Anthropic provides no warranty for what your hooks do.
**Best practices:**
- Validate and sanitize all inputs from stdin JSON
- Quote shell variables (`"$var"`, not `$var`)
- Block path traversal (`..`, absolute paths outside the project)
- Use absolute paths for invoked scripts so PATH attacks don't redirect
- Explicitly skip sensitive files (`.env`, `.git/`, `secrets/`)
Claude Code snapshots your hook configuration at session start and warns if hooks change mid-session β review before applying.
#### Execution & debugging
- **Timeout** β defaults vary by hook type: 600s for `command`/`http`/`mcp_tool` hooks, 30s for `prompt` hooks, 60s for `agent` hooks (some events lower these β e.g. `UserPromptSubmit` command hooks get 30s). Configurable per hook.
- **Parallelization** β all matching hooks run in parallel; identical handlers are deduplicated automatically.
- **Environment** β hooks run in the current dir with Claude Code's env; `CLAUDE_PROJECT_DIR` is available.
- **Debug** β `/hooks` shows current config; `claude --debug` shows hook execution logs; test scripts manually with the JSON payload piped to stdin.
---
### Subagents & running agents in parallel
Claude Code has **four** ways to run agents at once. They're easy to confuse, so start here β the question that separates them is **who coordinates the work**:
| Surface | Who coordinates | Reach for it when⦠|
|---|---|---|
| **Subagents** *(below)* | Claude, turn by turn, inside one session | A side task would flood your main conversation with search results, logs, or file contents you'll never reference again |
| **Agent view** β `claude agents` *(research preview)* | **You** β hand off, check back later | You have several independent tasks and want to dispatch them, glance at status, and step in only when one needs you. Each dispatched session gets **its own worktree automatically** |
| **[Agent Teams](#agent-teams-experimental)** *(experimental)* | A lead agent supervising peer sessions | Workers need to **talk to each other** β share findings, challenge each other, self-claim from a shared task list |
| **[Dynamic Workflows](#dynamic-workflows)** | **A script**, not Claude's judgement | The job outgrows a handful of subagents, or you want findings cross-checked against each other: codebase-wide audits, 500-file migrations |
Two supporting tools that aren't a coordination style of their own:
- **[Git worktrees](#1-git-worktrees--parallel-branches-parallel-sessions)** β separate checkouts so parallel sessions never touch the same files.
- **`/batch`** β a bundled skill that researches the codebase, splits one large change into **5β30 independent units**, and spawns a background subagent per unit **in its own worktree, each opening a PR**. It's a packaged use of subagents + worktrees, and the fastest way to feel this whole category.
> π‘ **Checking on running work** depends on what you started: `/tasks` for anything backgrounded in the current session, `claude agents` for background sessions, `/workflows` for workflow runs. Note `/agents` (removed as a wizard in v2.1.198) is a different thing entirely from `claude agents`.
#### 1. Git worktrees β parallel branches, parallel sessions
[Git worktrees](https://git-scm.com/docs/git-worktree) let one repo have multiple branches checked out at the same time, each in its own folder. Pair them with one Claude Code session per worktree to run independent streams of work.
```bash
git worktree add -b feature-a ../feature-a # create the worktree
cd ../feature-a && claude # start Claude in it
# Repeat in another terminal for feature-b. Each session is independent.
git worktree remove ../feature-a # clean up when done
```
> π‘ Use [tmux](https://github.com/tmux/tmux/wiki/Installing) to keep each worktree's session attached even when you close the terminal.
>
> π‘ Prefer not to manage them by hand? `claude agents` (agent view) puts **each dispatched session in its own worktree automatically**, and `/batch` does the same per unit of work.
#### 2. General-purpose subagents β when one Claude isn't enough
From your main session, ask Claude to spawn subagents for a parallel sub-task. Each subagent runs in its own context window and reports a summary back, so the main session stays focused.
```markdown
Analyze the implementation of the payment feature.
Spawn 5 subagents to accelerate the work.
Ultrathink.
```
#### 3. Specialized subagents β drop-in role prompts
Specialized agents are pre-written role prompts you drop into `.claude/agents/`. Each one carries its own focus and tooling, so a `security-reviewer` agent stays focused on threats instead of also opining on code style.
An agent is just a markdown file with YAML frontmatter β create `.claude/agents/security-reviewer.md` (or ask Claude to write it; the old `/agents` wizard was removed in v2.1.198):
```markdown
---
name: security-reviewer
description: Use after changes touching auth, input handling, or secrets β reviews diffs for vulnerabilities.
tools: Read, Grep, Glob
---
You are a security engineer. Review the changes for injection risks,
secrets in code, authZ/authN gaps, and unsafe input handling. Report
findings by severity with concrete fixes.
```
The `description` is what the main session uses to decide when to delegate β keep it to a couple of sentences of when-to-use criteria; the body below the frontmatter is the agent's system prompt. This repo's [`.claude/agents/`](.claude/agents) holds five working examples.
**This repo ships 10 production-ready specialist prompts** you can drop into `.claude/agents/`:
| Role | System prompt | Role description |
|---|---|---|
| Backend Engineer | [prompt](specialized-agents/system-prompts/backend-engineer-prompt.md) | [description](specialized-agents/Descriptions/backend-engineer-description.md) |
| Frontend Engineer | [prompt](specialized-agents/system-prompts/frontend-engineer-prompt.md) | [description](specialized-agents/Descriptions/frontend-engineer-description.md) |
| Database Engineer | [prompt](specialized-agents/system-prompts/database-engineer-prompt.md) | [description](specialized-agents/Descriptions/database-engineer-description.md) |
| Tech Lead | [prompt](specialized-agents/system-prompts/tech-lead-prompt.md) | [description](specialized-agents/Descriptions/tech-lead-description.md) |
| Code Reviewer | [prompt](specialized-agents/system-prompts/code-reviewer-prompt.md) | [description](specialized-agents/Descriptions/code-reviewer-description.md) |
| Security Reviewer | [prompt](specialized-agents/system-prompts/security-reviewer-prompt.md) | [description](specialized-agents/Descriptions/security-reviewer-description.md) |
| UX Engineer | [prompt](specialized-agents/system-prompts/ux-engineer-prompt.md) | [description](specialized-agents/Descriptions/ux-engineer-description.md) |
| Design Reviewer | [prompt](specialized-agents/system-prompts/design-reviewer.md) | β |
| Project Manager | [prompt](specialized-agents/system-prompts/project-manager-prompt.md) | [description](specialized-agents/Descriptions/project-manager-description.md) |
| Business Analyst | [prompt](specialized-agents/system-prompts/business-analyst-prompt.md) | [description](specialized-agents/Descriptions/business-analyst-description.md) |
#### Orchestrating specialists from the main session
Once you have specialized agents, the main session orchestrates them by name:
```markdown
Have backend-engineer suggest UI improvements; have frontend-engineer
implement them; have code-reviewer review the changes; have
frontend-engineer address the review feedback.
```
> π That board is [`specialized-agents/agent-orchestration-workflow.canvas`](specialized-agents/agent-orchestration-workflow.canvas) β open it in [Obsidian](https://obsidian.md/) or any canvas-compatible viewer to read the full prompts side by side.
>
> π‘ The same prompts work as **Agent Teams teammates** β see [Agent Teams](#agent-teams-experimental).
---
### Agent Teams (Experimental)
**Agent Teams** is an experimental feature that lets a single Claude Code session coordinate **multiple specialist agents** through a shared task list. The main session acts as the team lead; teammates work on their tasks (sometimes in parallel), report progress, and update the shared list. Reach for it on full-stack features, large refactors, or anything where multiple perspectives genuinely help. Skip it for single-file edits and quick fixes.
#### Enable it
```bash
export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 # add to ~/.zshrc to persist
claude
```
Or, more durably, in `settings.json`:
```json
{ "env": { "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1" } }
```
#### The example that justifies the cost
Most "spawn N teammates" prompts would work just as well with subagents. This one wouldn't β it needs teammates to **talk to each other**:
```text
Users report the app exits after one message instead of staying connected.
Spawn 5 agent teammates to investigate different hypotheses. Have them talk to
each other to try to disprove each other's theories, like a scientific
debate. Update the findings doc with whatever consensus emerges.
```
The debate structure *is* the mechanism. Sequential investigation anchors: once one theory gets explored, everything after is biased toward it. With independent investigators actively trying to disprove each other, the theory that survives is far more likely to be the real root cause.
#### Staff a team with the role prompts you already have
A teammate can be spawned **from a subagent definition** β so this repo's [`.claude/agents/`](.claude/agents) and [10 specialist prompts](#3-specialized-subagents--drop-in-role-prompts) work as teammates, not just as subagents:
```text
Spawn a teammate using the security-reviewer agent type to audit the auth module.
```
It honors that definition's `tools` allowlist and `model`, and the body is *appended* to the teammate's system prompt. (`skills` and `mcpServers` frontmatter is **not** applied to teammates.)
#### Three things that catch people out
- **Teammates don't inherit the lead's `/model`.** Set **Default teammate model** in `/config` (pick *Default (leader's model)* to follow the lead), or name the model per spawn. They *do* inherit the lead's effort level. Model and fast mode are fixed at spawn β `/model` and `/fast` only ever change the lead.
- **Teammates don't get the lead's conversation history.** They load `CLAUDE.md`, MCP servers, and skills like any session, but everything task-specific has to be in the spawn prompt.
- **No worktree isolation.** Unlike agent view, teams don't isolate teammates β two teammates editing one file is a straight overwrite. Partition the files yourself.
#### Monitoring, and the naming trap
Teammates appear in the **agent panel** below your prompt input: `β`/`β` to select, `Enter` to open a transcript and message that teammate directly, `Esc` to interrupt, `Ctrl+T` for the task list. An idle row that vanished is **hidden, not stopped** β it returns on the teammate's next turn.
> β οΈ `claude agents` opens **agent view**, a *different* surface for background sessions β not your team monitor. And subagents show up in the same agent panel as teammates, so seeing rows there doesn't prove a team actually formed.
#### Best practices
| β
Do | β Don't |
|---|---|
| Start with **3β5 teammates**, ~5β6 tasks each | Scale up before the work needs it β three focused beat five scattered |
| Give each teammate a distinct, non-overlapping slice of files | Let two teammates edit the same file |
| Put task specifics in the spawn prompt | Assume teammates saw your conversation |
| Name teammates descriptively so you can address them later | Use `agent1`, `agent2` |
| Start with **research and review** while learning | Start with parallel implementation |
| Gate "done" with a `TaskCompleted` hook (exit 2 blocks) | Let a teammate declare victory on a red test suite |
> π **[Full guide in `docs/agent-teams.md` β](docs/agent-teams.md)** β display modes, plan approval, the mailbox architecture, permissions, hooks, troubleshooting, and the honest limitations list. Authoritative reference: [code.claude.com/docs/en/agent-teams](https://code.claude.com/docs/en/agent-teams).
---
### Dynamic Workflows
*~3 min read Β· [Full guide in `docs/workflows.md` β](docs/workflows.md)*
> **Mental model:** A dynamic workflow is a **JavaScript script that orchestrates subagents**. Claude writes the script for the task you describe; a runtime executes it in the background while your session stays responsive. Everything else on this page has Claude deciding what runs next, turn by turn β here, **the script holds the plan**.
Two consequences make this more than "more agents":
- **Your context stays clean.** Intermediate results live in script variables, not Claude's context window. That's why a workflow can coordinate 200 agents when a conversation can't coordinate 10.
- **Quality patterns become repeatable.** A script can make independent agents *adversarially refute each other's findings* before anything is reported, or draft a plan from several angles and weigh them. Same structure every run.
#### Try it in 2 minutes β no script required
```text
/deep-research What changed in the Node.js permission model between v20 and v22?
```
`/deep-research` is bundled. It fans searches across several angles, cross-checks the sources, votes on each claim, and returns a cited report with the claims that failed cross-checking already filtered out. Approve the run, then `/workflows` to watch phases, agent counts, and live token spend.
#### Starting your own
| Scope | How |
|---|---|
| **One task** | Say `ultracode` β or just "use a workflow" β in your prompt |
| **Whole session** | `/effort ultracode` (or `claude --effort ultracode`) β Claude plans a workflow for every substantive task |
| **Forever** | Run `/workflows`, select a run, press `s` to save its script to `.claude/workflows/` β it becomes `/` for everyone who clones the repo |
Three phrases that reliably improve the script Claude writes: **"adversarially verify each finding"** (skeptic agents that try to refute results), **"in its own isolated copy"** (each agent gets a git worktree, so parallel edits can't conflict), and **"until two rounds in a row find nothing new"** (a convergence condition instead of a guessed count).
> π **This repo ships a working one:** [`.claude/workflows/stale-docs-audit.js`](.claude/workflows/stale-docs-audit.js) β one reader agent per doc file, then independent skeptics that try to refute each finding before it's reported. Clone and run `/stale-docs-audit`.
> β οΈ **Two things that surprise people.** The subagents a workflow spawns **always run in `acceptEdits`** regardless of your session's permission mode β file edits are auto-approved. And an agent still running when you stop a run isn't cached, so **many small agents preserve far more progress on resume** than a few long ones. [Details β](docs/workflows.md#permissions)
Limits: **16 concurrent agents**, **1,000 per run**, no mid-run user input, resume only within the same session. Cost control lives in `/config` (**Dynamic workflow size**, default `medium` β under 15 agents) β and the cheapest habit is running on one directory before the whole repo.
---
### Beyond one terminal β the 2026 automation surface
Claude Code grew a set of orchestration features in mid-2026 that compose with everything above:
| Feature | What it does | Docs |
|---|---|---|
| **Cloud code review** | `/code-review ultra` runs a multi-agent review in the cloud (alias `/ultrareview` β 3 free runs on Pro/Max, then usage credits); `claude ultrareview` runs it non-interactively for CI | [commands](https://code.claude.com/docs/en/commands) |
| **Routines** | `/schedule` (alias `/routines`) runs scheduled agents on Anthropic-managed cloud infrastructure; `/loop` and the Cron tools cover local scheduling | [scheduled tasks](https://code.claude.com/docs/en/scheduled-tasks) |
| **Artifacts** *(beta)* | Publish live, shareable web pages to claude.ai straight from the CLI β Pro/Max/Team/Enterprise, CSP-sandboxed, 16 MiB limit | [artifacts](https://code.claude.com/docs/en/artifacts) |
| **Auto memory** | On by default β Claude keeps per-project memory in `~/.claude/projects//memory/` with a `MEMORY.md` index; manage with `/memory` | [memory](https://code.claude.com/docs/en/memory) |
| **Claude in Chrome** | Browser-driving agent, GA since v2.1.198 (July 1, 2026) | β |
Subagents got sharper too: they run **in the background by default** (v2.1.198), can nest **5 levels deep** (v2.1.172), and `claude agents` opens a live multi-agent dashboard (Research Preview). The `/agents` setup wizard is gone β define agents by editing `.claude/agents/` directly, or ask Claude to do it.
---
### Model Context Protocol (MCP)
> **Mental model:** MCP is a universal translator that lets any AI tool talk to any data source through one open protocol β USB-C for AI integrations.
#### Featured MCP servers
Full setup walkthroughs in [`mcp-servers/`](./mcp-servers/). New to MCP? [`mcp-servers/playwright.md`](./mcp-servers/playwright.md) has a working three-line setup.
| Server | What it adds | Walkthrough |
|---|---|---|
| **Serena** | Symbol-level code navigation and editing across many languages | [serena.md](./mcp-servers/serena.md) |
| **Sequential Thinking** | Step-by-step reasoning that breaks complex problems into manageable steps | [sequential-thinking.md](./mcp-servers/sequential-thinking.md) |
| **Memory** | Persistent context across sessions | [memory.md](./mcp-servers/memory.md) |
| **Playwright** | Browser automation β interaction, scraping, testing, accessibility | [playwright.md](./mcp-servers/playwright.md) |
See [`mcp-servers/README.md`](./mcp-servers/README.md) for the comparison matrix, install commands, and troubleshooting.
#### More MCP servers worth knowing
Install from the [registry](https://registry.modelcontextprotocol.io/) or follow the source link. No walkthrough yet β source READMEs cover setup.
**General-purpose:**
| Server | What it adds | Source |
|---|---|---|
| **Context7** | Live, version-pinned library docs piped into the prompt β grounds answers in current API surfaces instead of training-cutoff guesses | [upstash/context7](https://github.com/upstash/context7) |
| **Tavily** | Web search, page extraction, and research designed for AI agents | [tavily-ai/tavily-mcp](https://github.com/tavily-ai/tavily-mcp) |
| **Chrome DevTools** | Drives a real Chrome instance β DOM inspection, network logs, console, performance traces, screenshots | [ChromeDevTools/chrome-devtools-mcp](https://github.com/ChromeDevTools/chrome-devtools-mcp) |
| **mem0** | Hosted long-term memory with semantic recall across sessions and projects (richer than the local-only Memory server above) | [mem0ai/mem0](https://github.com/mem0ai/mem0) |
**Specialized β reach for these when the workflow fits:**
| Server | What it adds | When to reach for it | Source |
|---|---|---|---|
| **context-mode** | Curates and ships project context (rules, files, conventions) on demand | Multi-repo setups wanting consistent context without hand-rolled CLAUDE.md plumbing | [mksglu/context-mode](https://github.com/mksglu/context-mode) |
| **Shadcn** | Pulls shadcn/ui component source into the session for accurate scaffolding | Frontend work in a shadcn/ui codebase | [ui.shadcn.com/docs/mcp](https://ui.shadcn.com/docs/mcp) |
| **LangSmith** | Trace, evaluate, and debug LLM apps from inside Claude Code | Building on LangChain / LangGraph and want observability without leaving the terminal | [langchain-ai/langsmith-mcp-server](https://github.com/langchain-ai/langsmith-mcp-server) |
| **TrustGraph** | Knowledge-graph-backed RAG with multi-source ingestion and graph-aware retrieval | Advanced RAG where flat vector search isn't enough β entity-rich corpora, agentic retrieval | [trustgraph-ai/trustgraph](https://github.com/trustgraph-ai/trustgraph) |
#### The NΓM problem MCP solves
Before MCP, every AI app needed a custom integration for every tool: `n` apps Γ `m` tools = `n Γ m` brittle one-off connections. Teams inside the same company would reinvent the same Slack/GitHub/Postgres integration over and over.
MCP collapses this to **N + M**: each app implements MCP once, each tool exposes MCP once, and any combination works together. Same pattern Web APIs gave us for app-to-server and LSP gave us for editor-to-language tooling.
#### Three pillars
Each pillar makes ownership explicit, so it's always clear who's driving:
| Pillar | Controlled by | Purpose |
|---|---|---|
| **Tools** | The model | Lets the AI take actions β query a DB, call an API, write a file |
| **Resources** | The application | Feeds the AI structured context β files, error logs, JSON objects |
| **Prompts** | The user | Slash-command shortcuts that kick off multi-step workflows |
#### The MCP Registry & self-discovering agents
The [official MCP Registry](https://registry.modelcontextprotocol.io/) (public preview since September 2025) is the app-store-equivalent for MCP servers. An agent that needs to check Grafana logs but doesn't have a Grafana tool wired up can ping the registry, find the verified server, install it, and continue β teaching itself a new capability on the fly.
#### The MCP ecosystem today
- **Vendor-neutral governance** β MCP was donated to the [Agentic AI Foundation](https://www.anthropic.com/news/donating-the-model-context-protocol-and-establishing-of-the-agentic-ai-foundation) (a Linux Foundation directed fund) in December 2025, alongside Block's goose and OpenAI's AGENTS.md.
- **Registry** β search official and community servers at [registry.modelcontextprotocol.io](https://registry.modelcontextprotocol.io/) (still officially in preview).
- **MCP Apps** β the first official MCP extension (January 2026): servers can ship interactive UI components in sandboxed iframes, not just text tools.
- **Spec cadence** β current ratified spec is 2025-11-25; the [2026-07-28 release candidate](https://blog.modelcontextprotocol.io/posts/2026-07-28-release-candidate/) (stateless core, official extensions) is the largest revision since launch.
- **Scale** β 97M+ monthly SDK downloads and ~10,000 active servers as of December 2025.
```bash
claude mcp add npx '@@latest' # install a server
claude mcp login # OAuth sign-in (v2.1.186+)
/mcp # list connected servers
```
π References: [MCP roadmap](https://modelcontextprotocol.io/development/roadmap) Β· [Official servers](https://github.com/modelcontextprotocol/servers).
---
### Fast Mode β―
`/fast` toggles fast mode β up to **2.5Γ faster output at 2Γ the price**, running on **Opus 4.8** (the default fast-mode model since v2.1.154). CLI-only, requires v2.1.36+. The **β―** indicator confirms it's on. On subscription plans, fast mode draws from usage credits rather than plan limits.
| | Standard Opus 4.8 | Fast Mode (Opus 4.8) |
|---|---|---|
| Input (per MTok) | $5 | $10 (2Γ) |
| Output (per MTok) | $25 | $50 (2Γ) |
> β οΈ **Fast mode on older Opus models is going away.** Opus 4.7 fast ($30/$150) was deprecated June 25 and is **removed on July 24, 2026**; Opus 4.6 has silently run at standard speed since June 29. Don't build workflows on either.
```bash
/fast # toggle on (β― appears)
> fix the auth bug in src/login.ts # faster output
/fast # toggle off when done
```
**Decision rule:** use it when latency matters (live debugging, demo prep, time-pressured fixes). At 2Γ cost it's a much easier call than the old 6Γ β but background work still doesn't need it. Use `/usage` to monitor.
---
### Super Claude Framework
> An open-source framework that bolts pre-built personas, commands, and workflows on top of Claude Code.
**What it is.** [Super Claude](https://github.com/SuperClaude-Org/SuperClaude_Framework) ships 15+ ready-made specialist agents (architect, security, performance, frontend, etc.) plus a library of structured slash commands (`/sc:analyze`, `/sc:improve`, `/sc:design`) and behavioral flags. It installs into `~/.claude/` as a drop-in extension to Claude Code.
**Why pair it with Claude Code.** Skips the "write your own role prompts" phase. You get a curated library of expert personas and commands the community has already iterated on β useful as both a daily tool and a reference for how to write your own skills.
**When to reach for it.** You want pre-built specialist agents without building them yourself, or you're learning prompt patterns by reading well-crafted examples.
β [Source on GitHub](https://github.com/SuperClaude-Org/SuperClaude_Framework)
---
### The BMAD METHOD β AI Agent Framework
> A multi-agent framework that walks a project from idea to working software using a team of Claude agents in defined roles.
**What it is.** [BMAD](https://github.com/bmad-code-org/BMAD-METHOD) (Breakthrough Method of Agile AI-driven Development) coordinates specialist agents β analyst, PM, architect, developer, QA, scrum master β through a full SDLC. Each role produces specific artifacts (PRD, architecture doc, story file) that the next role consumes. Works as a Claude Code extension via skills and agents.
**Why pair it with Claude Code.** Gives you a documented, repeatable workflow for greenfield builds. Instead of asking Claude "build me an app," you walk through analyst β PM β architect β developer β QA, each agent producing structured output the next one consumes.
**When to reach for it.** Greenfield projects, large feature builds, or any time you want planning rigor before code. Overkill for a quick fix or a one-file refactor.
β [Source on GitHub](https://github.com/bmad-code-org/BMAD-METHOD)
---
### FAQ
*[β Full FAQ in `docs/reference/faq.md`](docs/reference/faq.md)* β covers models, pricing, tokens, plans, Fast Mode, worktrees, and Pro-plan optimization.
A few of the most-asked questions:
**How many messages do I get on the Pro plan?**
Anthropic no longer publishes exact counts β third-party estimates put Pro at roughly ~45 messages per 5-hour window, and Claude Code's five-hour rate limits were **doubled on May 6, 2026** ([announcement](https://www.anthropic.com/news/higher-limits-spacex)). [Details β](docs/reference/faq.md#q-how-many-messages-do-i-get-on-the-pro-plan)
**What's the difference between Pro, Max 5x, and Max 20x?**
Pro $20/mo, Max 5x from $100/mo (5Γ usage), Max 20x $200/mo (20Γ usage). All paid tiers include Claude Code and the current lineup β Fable 5 draws usage credits rather than plan limits. [Pricing details β](docs/reference/faq.md#q-what-are-the-claude-subscription-plans)
**Should I use Fast Mode?**
It now runs on Opus 4.8 at 2Γ price for up to 2.5Γ output speed β an easy call when latency matters. [More β](docs/reference/faq.md#q-what-is-fast-mode-and-when-should-i-use-it)
**What's the difference between custom slash commands and skills?**
Officially one system now β `.claude/commands/deploy.md` and `.claude/skills/deploy/SKILL.md` both create `/deploy`. See [Skills FAQ in `docs/skills.md`](docs/skills.md#skills-faq).
**Can I use the 1M-token context window?**
Yes β 1M context is standard on Sonnet 5, Opus 4.8, and Fable 5, with no long-context surcharge. [More β](docs/reference/faq.md#q-can-i-use-the-1m-context-window)
---
### Updates & Deprecations (as of July 2026)
*[β Full changelog in `docs/reference/changelog.md`](docs/reference/changelog.md)* β major changes, new features, and deprecations through early July 2026 (Claude Code v2.1.201).
**Recent highlights:**
- π **Claude Sonnet 5** *(June 30, 2026)* β Claude Code's new default model; 1M-token context standard.
- π **Claude Opus 4.8** *(May 28, 2026)* β Opus flagship at unchanged pricing; **Claude Fable 5 / Mythos 5** *(June 9, 2026)* opened the Mythos-class tier above Opus.
- π **Dynamic workflows + `ultracode`** β Claude orchestrates tens to hundreds of background subagents; watch with `/workflows`.
- π **Artifacts** *(beta)* β publish live web pages to claude.ai from the CLI.
- π **v2.1.198** *(July 1, 2026)* β Claude in Chrome GA, subagents run in the background by default, `/agents` wizard removed.
- π **Renames** β `/cost` + `/stats` β `/usage`; `/extra-usage` β `/usage-credits`; permission mode "default" β "Manual" (v2.1.200); `/simplify` β `/code-review` (then reintroduced as a cleanup-only review).
- π **Limits** β five-hour rate limits doubled for Pro/Max/Team on May 6, 2026.
- β **Deprecations** β Opus 4.1 retires Aug 5, 2026; Opus 4.7 fast mode removed July 24, 2026.
> π‘ For Anthropic's authoritative release notes, see the [Claude Code CHANGELOG](https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md) and the [weekly "What's new" digests](https://code.claude.com/docs/en/whats-new/).
---
### π Reading tips
- **Reading on GitHub?** The in-page anchor links work natively. Tap the table-of-contents button (top-left of the file view) for fast jumping.
- **Want a richer markdown view?** This repo plays well with [Obsidian](https://obsidian.md/) β handy if you also want to open the `specialized-agents/agent-orchestration-workflow.canvas` flowchart.
- **On a phone?** Stick to the [Choose your path](#-choose-your-path) section at the top; the wider tables read best on desktop.
---
### References
*[β Full reading list in `docs/reference/further-reading.md`](docs/reference/further-reading.md)*
A curated set of pointers β official Anthropic docs, MCP resources, hooks examples, workflow tutorials, pricing references, and adjacent tooling.
**Most-clicked starting points:**
- [Claude Code overview (official)](https://code.claude.com/docs/en/overview)
- [Claude Code best practices (official)](https://code.claude.com/docs/en/best-practices)
- [Building effective agents (Anthropic engineering)](https://www.anthropic.com/engineering/building-effective-agents)
- [Official MCP Registry](https://registry.modelcontextprotocol.io/)
- [Hooks reference (official)](https://code.claude.com/docs/en/hooks)
---
> Features, pricing, and availability change frequently. Always check the [official Claude Code documentation](https://code.claude.com/docs/en/overview) for the most current information.
*Last reviewed July 2026 Β· Spotted something stale? [Open an issue](https://github.com/wesammustafa/Claude-Code-Everything-You-Need-to-Know/issues) or send a PR β see [`CONTRIBUTING.md`](CONTRIBUTING.md).*