Reference
Claude Code cheatsheet
Integrations, commands, menu surfaces, and orchestration — one page. Not Omarchy-specific, but it's the terminal agent doing most of the work on this machine, so it earns a spot in the docs. Audited against Claude Code v2.1.22x, Aug 2026.
Mental model
Four words, four jobs: a Skill is instructions Claude reads and follows. MCP is a live wire to an external system. A Hook is a script that fires on an event, guaranteed, whether or not Claude "decides" to. A Plugin is a zip file bundling any of the above for reuse or sharing. Everything else on this page — subagents, agent teams, workflows, routines, Dispatch — is a different answer to "where does the loop run and what does it share context with."
Claude Code's own built-in tools (file edits, search, shell, web) already cover most coding tasks. Everything below is the extension layer: what you add to teach it your conventions, connect it to systems it can't otherwise reach, and automate what would otherwise be manual.
Integrations: MCP vs Skills vs Plugins
These get lumped together because they're installed and browsed from the same Customize menu, but they solve three different problems and mostly stack rather than compete.
MCP Protocol
The plumbing. Connects Claude to a live external system — auth and the actual API calls live on the server side.
- Provides tools + data access, not knowledge
- Config:
.mcp.json, managed with/mcp - Shows up as regular tools in hook events
Skills Prompt
Knowledge and workflows loaded on demand — either you type /name, or Claude matches your task to its description.
- Reference material or a multi-step runbook
- Lives in
.claude/skills/<name>/SKILL.md(project) or~/.claude/skills/(personal) - Can pre-approve tools, fork to a subagent, ship its own hooks
/deploy runbook, your API style guide, a code-review checklist
Plugins Package
Not a fourth capability — a directory that bundles skills, hooks, subagents, and MCP servers into one installable, shareable unit.
- Skills come out namespaced:
/my-plugin:review - Distributed via marketplaces, installed with
/plugin - Reuse the same setup across repos or teammates
DELETE
| Aspect | MCP | Skill | Plugin |
|---|---|---|---|
| What it is | Protocol for connecting to external services | Knowledge, workflows, reference material | Packaging layer for the other three |
| Provides | Tools and data access | Instructions Claude follows | A turnkey bundle to install in one step |
| Triggered by | A tool call Claude makes | Typing /name, or Claude matching intent | Installing the plugin (activates its parts) |
| Lives in | .mcp.json | .claude/skills/*/SKILL.md | A directory with .claude-plugin/plugin.json |
| Use when | Live data or real-world actions are needed | Claude should reason through repeatable steps | The same setup needs to travel to another repo or person |
"MCP vs Skills vs Plugins" is a false trichotomy. You don't pick one — a skill teaches Claude how to use an MCP server well, and a plugin is how you hand both to someone else.
Slash commands
Type / to filter the live list — it's the source of truth over any cheatsheet. Skill commands are prompts Claude can also trigger itself; Workflow commands fan a task out across many background subagents. Everything unmarked is built-in, fixed CLI logic.
Start a project
/init | Generate a starter CLAUDE.md |
/memory | Edit CLAUDE.md, manage auto-memory |
/mcp | Manage MCP server connections |
/permissions | Allow / ask / deny rules for tools |
/plugin | Install & manage plugins |
/doctor | Setup checkup, can fix issues Skill |
During a task
/plan | Enter plan mode before a large change |
/model | Switch model, set effort with arrow keys |
/effort | Set reasoning depth: low → max, ultracode |
/context | Visualize what's filling the window |
/compact | Summarize the conversation to free space |
/goal | Keep working across turns until a condition holds |
Parallel & background work
/tasks | List background work & finished subagents |
/background | Detach the session to run unattended |
/batch | Decompose & parallelize a repo-wide change Workflow |
/subtask | Fork a background subagent, result returns here |
/fork | Copy this conversation into a new background session |
/branch | Branch the conversation to try another direction |
Ship it
/diff | Interactive viewer for uncommitted changes |
/code-review | Diff review, --fix to apply Skill |
/code-review ultra | Deep multi-agent cloud review |
/security-review | Vulnerability scan of the branch diff |
/simplify | Parallel cleanup pass, applies fixes Skill |
Between sessions
/clear | New conversation, keeps project memory |
/resume | Reopen an earlier conversation by ID or picker |
/rewind | Roll code and/or chat back to a checkpoint |
/rename | Name the session for the resume picker |
/teleport | Pull a web session into this terminal |
/cd | Move the session to a new working directory |
Automation & housekeeping
/schedule | Create/manage routines (schedule-only from CLI) |
/loop | Repeat a prompt on an interval Skill |
/hooks | View configured hooks for tool events |
/agents | Pointer to managing subagents in .claude/agents/ |
/workflows | Watch/pause/resume dynamic workflow runs |
/usage | Cost, plan limits, per-skill/MCP breakdown |
MCP servers can also expose their own commands, discovered dynamically as /mcp__<server>__<prompt>.
Menu items
Outside the terminal REPL, the Desktop and mobile apps add a few surfaces that aren't slash commands at all.
Artifacts
Publish a session's output as a live, interactive page instead of scrollback — updates in place as the session continues.
- Private by default; share org-wide or, if enabled, publicly
- Can pull live data via MCP connectors (separate toggle)
- Pro/Max/Team/Enterprise; org admins can scope by role
Routines
A saved cloud job — prompt, repos, connectors — that runs on Anthropic's infrastructure, not your machine.
- Trigger by schedule, HTTP API call, GitHub event, or all three
- Create at
claude.ai/code/routines, Desktop "New remote task", or/schedule(schedule-only) - Keeps running with your laptop closed
Dispatch
One persistent chat in the Cowork tab. Describe an outcome; it plans the work and spawns child tasks as separate sessions.
- Runs on your desktop — needs Desktop open and awake
- Reaches local files, connectors, plugins, installed apps
- Spawned Code sessions carry a "Dispatch" badge; push notification on finish
Customize
The sidebar hub that unifies Skills, Connectors, and Plugins into one directory instead of three separate menus.
- Install, toggle, and browse marketplaces from one place
- Team/Enterprise: org-shared skills surface here too
- Per-plugin "Customize" opens a task to tune it to your workflow
Dispatch and cloud routines look similar but differ on one axis: Dispatch needs your desktop awake and can touch local files; routines run headless on Anthropic's servers and can't.
Automation and orchestration
Several features all boil down to "run more Claude." The difference is where the loop executes and what it shares context with.
| Primitive | Context | Spawned by | Runs where | Best for |
|---|---|---|---|---|
| Subagent | Own isolated context, returns a summary | Claude automatically, /subtask, or a skill with context: fork |
Your session, foreground or background | Keeping a noisy side task out of your main context |
| Agent team (experimental) | Independent sessions, shared task list, can message peers | You, configuring teammates | Your machine, in parallel | Agents that need to negotiate or split work themselves |
| Dynamic workflow | A JS script holds the loop; intermediate results never enter Claude's context | Ask for "a workflow", or /effort ultracode |
Background runtime, up to ~1,000 subagents | Codebase-wide audits, migrations, cross-checked research |
/batch |
5–30 independent units, each a fresh subagent | You, via /batch <task> |
One background subagent per unit, its own git worktree, opens a PR | Large parallel refactors across a repo |
| Hook | None — a shell command, HTTP call, or prompt, not a conversation | A lifecycle event (PreToolUse, Stop, …) |
Wherever Claude Code runs | Guardrails and side effects that must happen every time |
| Routine | A fresh Claude Code run per trigger | Schedule, API call, or GitHub event | Anthropic's cloud — keeps going if your laptop is off | Unattended recurring or event-driven jobs |
Hooks: the lifecycle events
Hooks are the one primitive here with a guarantee: they always fire on their event, whether or not Claude "chooses" to. That's what makes them the right tool for anything that must hold every time — PreToolUse can even block the tool call outright.
| Event | Fires |
|---|---|
SessionStart | Session begins or resumes |
UserPromptSubmit | You submit a prompt, before Claude processes it |
PreToolUse | Before a tool call runs — can block it |
PostToolUse / PostToolUseFailure | After a tool call succeeds / fails |
Notification | Claude Code sends a notification (permission prompt, idle, etc.) |
SubagentStart / SubagentStop | A subagent is spawned / finishes |
PreCompact | Before context compaction |
Stop / StopFailure | Claude finishes a turn / a turn ends on an API error |
SessionEnd | Session terminates |
Put guardrails in hooks, not prose. "Never edit .env" in CLAUDE.md is a request; a PreToolUse hook that blocks the edit is enforcement.
Which do I use?
| I want to… | Reach for |
|---|---|
| Give Claude a repeatable, reasoned workflow | Skill |
| Connect to a live external system | MCP |
| Ship a whole setup to teammates or another repo | Plugin |
| Guarantee something happens the same way, every time | Hook |
| Keep a noisy side task out of my context window | Subagent |
| Run 10+ agents against a whole codebase | Dynamic workflow, or /batch for repo-wide refactors |
| Run a job on a schedule, from an API, or on a GitHub event — even offline | Routine |
| Assign work from my phone using files on my own machine | Dispatch |
| Publish a shareable, live view of what a session produced | Artifact |
| Manage all my skills, connectors, and plugins in one place | Customize |
Also worth knowing
A few pieces that don't fit neatly under the four headings above but come up in almost every session — worth having on this page too.
CLAUDE.md & memory
Always-on project context, loaded every session — not a skill, so it costs context whether or not it's relevant this turn.
/initgenerates one,/memoryedits it- Keep it under ~200 lines; move reference material to skills or
.claude/rules/ - Nested
CLAUDE.mdfiles load only when working in that subtree
Permissions & sandboxing
How much Claude can do without asking, ranging from ask-every-time to fully autonomous.
/permissions: allow / ask / deny rules by tool/plan: read-only analysis before any edits/sandbox: OS-level isolation on supported platforms
Context & effort
The two dials that trade cost and speed against depth and accuracy.
/contextvisualizes what's filling the window/compactsummarizes;/autocompactsets the trigger point/effort low…max, orultracodeto auto-plan workflows
Sessions & worktrees
Parallel work stays isolated because each session/worktree is its own git checkout.
/resume,/branch,/fork,/subtask- Desktop: split panes, Cmd/Ctrl+N for a new session
- Changes in one worktree don't affect others until committed
Checkpoints
A safety net that's easy to forget exists mid-task.
/rewindrolls conversation and/or code back to any earlier point- Also reachable after
/clear, to restore the prior conversation
Headless & CI
Claude Code isn't only interactive.
claude -p "<prompt>"for scripts and pipelines/install-github-appwires up GitHub Actions- Agent SDK drives full sessions from Python/TypeScript
Cost & usage
Worth checking before automation quietly gets expensive.
/usage(aliases/cost,/stats)- Breaks down spend by skill, subagent, plugin, and MCP server
- Routines attach every connected connector by default — trim what a job doesn't need
Fastest way to keep this current: run /release-notes in a live session, or ask Claude "what changed in Claude Code recently?" — this page is a snapshot, the CLI's own /help and / menu are never stale.