Once you've tried these, there's no going back to Cursor.
Slash commands, subagents, hooks, CLAUDE.md: what Claude Code has that nobody else does. With practical examples from real code.
Top Claude Code features
Claude Code isn't just AI in your terminal. It's an agent orchestrator with hooks, memory, and parallel execution. Every feature below genuinely changes how fast you work, not just a pretty demo trick.
Who this guide is for
This guide covers Claude Code, the terminal tool for developers. If you're just getting started with Claude, begin with the 10-step setup or the quick start. If you run social media accounts and want to automate content, check out Content Factory.
① Slash commands
Quick actions, no explanations needed.
Built-in Claude Code commands that perform a specific action immediately. No need to explain what you want: just type /compact and your context is compressed.
| Command | Description |
|---|---|
/compact | Compress the session context: cut the fluff, keep the substance. Do it before you hit 80% context usage. |
/clear | Start a session from scratch. For when Claude hits a dead end or the conversation gets too long. |
/fast | Switch to fast mode: quicker output without downgrading model quality. |
/model | Swap models mid-session. Opus for a hard problem, back to Sonnet for routine work. |
/init | Create a CLAUDE.md in your project root with a basic structure. |
/review | Run a code review of your current changes. |
/help | List every available command with descriptions. |
The AGINE rule for /compact
We run /compact every time context usage crosses 70%. Don't wait until 90%: at 90%, Claude already starts "forgetting" details from the beginning of the session. After /compact, answer quality bounces back.
② Subagents: 20 scenarios for parallel work
One request, several agents running in parallel.
Claude Code can spin up other Claude agents as subagents via the Task tool. Each one works in its own context, so it doesn't clutter the main one, and returns only a summary. On complex tasks, this fundamentally changes your speed.
- 01 · New feature — architect + explorer launch in parallel. One designs, the other explores dependencies. The results are synthesized before any code gets written.
- 02 · Code review — security-reviewer + performance-reviewer + conventions-reviewer: three angles at once. Takes the same time as one.
- 03 · Tests — unit tests + integration tests + edge cases written in parallel. Not one after another.
- 04 · Refactoring — One agent analyzes the blast radius, a second writes the changes, a third verifies nothing broke.
- 05 · Documentation — README + API docs + changelog generated in parallel from the same codebase.
- 06 · Content — One agent writes for Instagram, another for LinkedIn, a third for Telegram, all at once, each tailored to its platform.
- 07 · Debugging — Several agents investigate different hypotheses about the bug's cause in parallel.
- 08 · Translation — Localization into 5 languages runs in parallel, not one language at a time.
Example: the request "add feature X" launches three agents in parallel
code-architect— Designs the architecture — Analyzes the existing code, proposes the structure of the changes, identifies the files.code-explorer— Explores the codebase — Hunts for similar patterns, dependencies, and the places that need changing. Writes no code.code-reviewer— Checks the result — Once the code is written, reviews it for bugs, security, and adherence to conventions.
The main agent synthesizes all three results and writes the code. The speed of one, the depth of three.
③ Hooks: automatic checks
A shell script that runs before and after every action.
Hooks are commands in your Claude Code settings that fire on every tool use. Wrote a file → the linter runs automatically. Executed bash → the command gets logged. No explicit request needed.
``json
# .claude/settings.json — auto-linter example
{
"hooks": {
"PostToolUse": [
{
"matcher": "Write",
"hooks": [{
"type": "command",
"command": "cd $PROJECT_ROOT && npm run lint --fix"
}]
}
],
"PreToolUse": [
{
"matcher": "Bash",
"hooks": [{
"type": "command",
"command": "echo \"[hook] bash: $TOOL_INPUT\" >> /tmp/claude-audit.log"
}]
}
]
}
}
``
PreToolUse— Before every action. Good for validation, blocking dangerous commands, logging.PostToolUse— After an action. Good for linting, tests, auto-formatting, notifications.Notification— When Claude wants to notify you. Can be routed to Telegram or Slack.
④ Plan mode: think first, code later
The architecture, 30 seconds before the first line of code.
Hit Shift+Tab at the start of a complex task and Claude switches to Plan mode. It writes no code, only a plan: which files to change, in what order, what the risks are. You see the architecture and can course-correct before any work begins.
| When | How to use it |
|---|---|
| A new feature touching 5+ files | Plan mode before you start: architecture with no surprises |
| Refactoring with dependencies | Claude shows the blast radius and the order of changes |
| An unfamiliar codebase | Plan first to understand the structure, then act |
| A bug spanning 3+ components | Plan mode finds the root cause before you start fixing |
⑤ Playwright MCP: Claude sees the browser
You write the UI, Claude checks it itself.
With Playwright MCP connected, Claude Code sees the browser, takes screenshots, clicks, fills out forms. You write a component, Claude opens localhost, verifies it renders correctly, and spots the console error. Without you lifting a finger.
# The scenario we run every day
- → 1. You change a component / page
- → 2. Claude opens localhost:3000 on its own
- → 3. Takes a screenshot of the full page
- → 4. Checks for console errors
- → 5. Clicks through elements to test interactions
- → 6. Reports back: "Found 2 issues: padding is off on mobile, and there's an error in the Network tab"
Setup: add playwright to your .mcp.json with the command npx @playwright/mcp@latest
⑥ Obsidian as long-term memory
The next session remembers the last one.
Claude Code doesn't remember past sessions, at least not by default. An Obsidian vault via MCP Filesystem fixes that. Claude writes down decisions, architecture, unfinished tasks. The next session reads them and picks up right where you left off.
sessions/— A short summary of each session: what you did, what you decided.decisions/— Architecture decisions with context: why this way and not another.roadmap/— Current tasks and plans: Claude knows what's next without being told.
⑦ CLAUDE.md: your project's permanent memory
Whatever's in CLAUDE.md, Claude remembers forever.
CLAUDE.md is read automatically at the start of every session. It's where you describe the project context, working rules, the stack, and decisions already made. Without this file, every session starts with explaining everything from scratch: you burn 10-15 minutes before the first useful action.
What a good project's CLAUDE.md should contain:
- → What we're building — one sentence about the product and its audience.
- → The stack — language, framework, database, key libraries.
- → How to run it locally — commands for dev and tests.
- → Rules — what's off-limits, the code style, how to submit PRs.
- → Links to canonical docs — @AGENTS.md, @voice.md and so on, via @filename.
AGINE rule: CLAUDE.md should never exceed 200 lines. Details go in separate files via @reference. Otherwise the file itself eats tokens at the start of every session.