10 Claude Code Features Most Developers Don't Know Exist

You're Using 20% of It

Most developers interact with Claude Code the same way: open a terminal, ask it to write a function, accept the diff. That workflow alone is valuable. But it's roughly equivalent to buying a CNC machine and using it as a table saw.

Claude Code has quietly become an orchestration platform. Agent teams, lifecycle hooks, custom sub-agents, persistent memory, git worktrees — these aren't experimental flags buried in a config file. They're shipping features that fundamentally change what "AI-assisted development" means.

Here are ten of them, with real examples.

1. Agent Teams and Parallel Execution

Since Opus 4.6 shipped in February, Claude Code supports teams of 2-16 agents working on the same codebase simultaneously. One session acts as the lead, decomposing work and assigning tasks. Teammates work in parallel, each with their own context window, communicating through a mailbox system.

This isn't theoretical. Anthropic's own engineering team used 16 agents to build a Rust-based C compiler from scratch — 100,000 lines of code, capable of compiling the Linux kernel on x86, ARM, and RISC-V.

The practical use case for most teams: spin up 3-4 teammates to tackle independent modules in parallel while you review results as they land.

# Start a team lead session
claude --team-lead

# Inside the session, spawn teammates
/teammates add --count 3 --scope "packages/api,packages/ui,packages/shared"

Each teammate gets its own context, its own piece of the puzzle, and reports back when done. A 3-agent team uses roughly 3-4x the tokens of a sequential session, but on complex tasks the wall-clock savings dwarf the cost.

2. The /loop Command

/loop transforms Claude Code from a request-response tool into a monitoring daemon. Define an interval and a prompt, and it executes automatically on a schedule.

# Run lint check every 5 minutes during a refactor
/loop 5m "Run eslint on packages/api/src. If there are new errors since last check, fix them."

# Monitor test suite while teammates work
/loop 2m "Run the test suite for packages/shared. Report any new failures."

This is powerful during large refactors or when you have agent teammates making parallel changes. Instead of manually re-running tests, the loop catches regressions as they happen.

3. Custom Skills and Slash Commands

Skills are reusable prompts stored as markdown files in .claude/commands/. Any file you drop there becomes a slash command available in every session.

<!-- .claude/commands/review-pr.md -->
Review the current branch against $ARGUMENTS (default: main).
Check for:
1. Security issues (SQL injection, XSS, exposed secrets)
2. Performance regressions (N+1 queries, missing indexes)
3. API contract changes that aren't backward-compatible
Output a structured review with severity levels.

Now /project:review-pr develop runs a full code review against any base branch. The $ARGUMENTS placeholder captures whatever you type after the command name.

You can scope skills globally (~/.claude/commands/) or per-project. We've seen teams build libraries of 30+ skills — deployment checklists, migration generators, incident response playbooks — that encode institutional knowledge directly into the agent's behavior.

4. The Hook System

Hooks are lifecycle callbacks that fire at specific points during a Claude Code session. There are 14+ trigger points: SessionStart, PreToolUse, PostToolUse, SubagentStart, Stop, TaskCompleted, and more.

Each hook receives JSON via stdin with session context — session ID, transcript path, working directory — and can modify behavior or trigger side effects.

// .claude/hooks.json
{
  "hooks": {
    "PostToolUse": [{
      "command": "node .claude/hooks/notify-on-file-change.js",
      "match": { "tool": "Edit" }
    }],
    "SessionStart": [{
      "command": "bash .claude/hooks/load-context.sh"
    }]
  }
}

Real use cases we've seen in production: auto-running tests after every file edit, posting to Slack when a session completes, loading project-specific context at session start, validating that agents don't touch files outside their designated scope.

5. Sub-Agent Patterns

Sub-agents are specialized Claude instances spawned within a session, each with their own context window, tool restrictions, and system prompts. Unlike teammates, sub-agents report only to their parent.

The key insight: sub-agents solve context exhaustion. Instead of cramming everything into one 1M-token conversation, you delegate focused tasks to agents that only see what they need.

<!-- .claude/agents/security-reviewer.md -->
You are a security review agent. You ONLY have access to Read and Grep tools.
You cannot modify files. Review the code at the paths provided and return
a structured report of security findings with severity levels.

You can restrict which tools a sub-agent can access, which MCP servers it connects to, and what permissions it has. A security reviewer that can read but never write. A documentation agent that can write markdown but never touch source code.

6. MCP Server Integrations

MCP (Model Context Protocol) servers extend Claude Code with external tools and data sources. The ecosystem has exploded — there are now 50+ production-quality MCP servers covering databases, browsers, design tools, project management, and more.

// .claude/mcp.json
{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["@anthropic/mcp-server-postgres", "--connection-string", "$DATABASE_URL"]
    },
    "browser": {
      "command": "npx",
      "args": ["@anthropic/mcp-server-playwright"]
    }
  }
}

As of March 2026, MCP servers can request structured input during task execution via interactive dialogs — form fields or browser URLs — without interrupting the workflow. This means an agent can authenticate with an OAuth flow mid-task without you needing to paste tokens manually.

7. Git Worktrees for Isolated Work

The worktree feature runs an agent in a temporary git worktree — a clean copy of the repo. This is invaluable for risky experiments, large refactors, or when you want an agent to try something without polluting your working tree.

# Agent works in an isolated worktree
/worktree "Refactor the authentication module to use the new session API.
If tests pass, create a PR. If not, report what broke."

The worktree is automatically deleted if no changes are made. If the agent produces useful work, it lives in a real git branch you can review and merge normally. Combined with agent teams, you can have multiple agents working in separate worktrees — zero conflict, zero context pollution.

8. Memory and Context Management

Claude Code maintains persistent memory across sessions through CLAUDE.md files at three levels: global (~/.claude/CLAUDE.md), project root, and subdirectories. The agent reads these automatically at session start.

But the lesser-known feature is the /compact command and its hook counterpart PreCompact. When your conversation approaches context limits, /compact compresses the conversation while preserving key decisions and context. The PreCompact hook lets you control what gets preserved.

<!-- CLAUDE.md -->
# Project Context
- Auth uses better-auth with session tokens, not JWTs
- All database access goes through Drizzle ORM — never write raw SQL
- The /api/v2 routes are deprecated — use /api/v3
- Run `pnpm test:unit` before committing, `pnpm test:e2e` for integration

This is institutional knowledge that survives across every session, every teammate, every sub-agent. Teams that maintain good CLAUDE.md files report dramatically fewer "the agent forgot how our project works" incidents.

9. Code Review Workflows

Claude Code can run structured code reviews that go beyond "looks good to me." Combine a custom skill with git integration and you get a review pipeline that checks security, performance, API compatibility, and test coverage.

# Review all changes on the current branch against develop
/project:review-pr develop

# Review a specific PR by number (with GitHub CLI)
claude "Review PR #247. Check out the branch, read every changed file,
and produce a review with: security findings, performance concerns,
API breaking changes, and test coverage gaps. Use severity levels."

The real power here is chaining this with hooks. Set up a PostToolUse hook that triggers on git push, and every push automatically spawns a review sub-agent. The review results land in your terminal before you even open the PR page.

10. The /effort Command

Released in March 2026, /effort controls how much compute Claude applies to your request. Lower effort levels respond faster and use fewer tokens for straightforward tasks. Higher levels activate extended thinking for complex reasoning.

# Quick formatting fix — don't overthink it
/effort low
"Fix the indentation in src/utils/format.ts"

# Complex architectural decision — take your time
/effort high
"Analyze our current database schema and propose a migration strategy
for adding multi-tenancy without downtime."

The "max" effort level has been removed from the command, but you can temporarily activate maximum reasoning depth by including "ultrathink" in your prompt. This is useful for architectural decisions, debugging race conditions, or any task where getting it right matters more than getting it fast.

The Compound Effect

Each of these features is useful in isolation. The real shift happens when you combine them: agent teams running in parallel worktrees, coordinated by hooks, with custom skills and MCP servers encoding your team's standards, all persisted in memory that survives across sessions.

That's not AI-assisted development. That's AI-native development infrastructure.

We've been building with this stack every day. Orchestrating specialized agents, enforcing review workflows, maintaining institutional memory, shipping software with governance that scales.

For the bigger picture on how these patterns translate to team-wide productivity, read our multi-agent productivity playbook.

Want to see what happens when you orchestrate multiple Claude Code agents with governance, review pipelines, and persistent institutional knowledge? That's what we're building at Kyros. See features or view pricing.