Claude Code power use: make it your tool

Out of the box, Claude Code is a strong generalist. The teams that get order-of-magnitude value are the ones who specialise it — encoding their workflows, guarantees, and integrations into the harness itself. Four extension points do that work: slash commands, skills, hooks, and subagents, with MCP feeding all of them. This lesson is the customisation manual.

Slash commands: prompts you never retype

Any prompt you have typed twice belongs in .claude/commands/ as a markdown file — invoked as /name, with arguments interpolated where you mark them. A file ‎.claude/commands/fix-issue.md containing "Read issue $ARGUMENTS in the tracker, reproduce it with a failing test, fix it, and reference the issue in the commit message" turns a paragraph of ritual into /fix-issue 1423. Commands are checked in, so the whole team gets them — the first small step in a theme this lesson repeats: move process knowledge out of heads and into the repo.

Skills: packaged expertise, loaded on demand

A skill is a folder — instructions, reference files, even scripts — that Claude loads when the task calls for it rather than carrying in every session's context. That on-demand loading is the context lesson's just-in-time doctrine applied to know-how: a deploy-check skill holding your rollout checklist, a quiz-authoring skill holding a content pipeline's rules, a security-review skill holding your team's threat-model walkthrough. The description tells Claude when the skill applies (the tool-description craft again — say when, not just what); the body can be long, because it costs nothing until invoked. Skills are the difference between "Claude, and remember we always…" repeated forever, and an organisation whose best practices execute themselves.

Hooks: guarantees, not requests

Everything so far asks the model to behave; hooks enforce behaviour by running your commands at lifecycle points — before a tool executes, after a file edit, when a session ends. Auto-format every file Claude touches; block any edit under legacy/billing/; require the test suite to pass before a session can declare itself done; log every bash command to an audit trail. The design rule: prompts for judgment, hooks for invariants. If a rule must hold 100% of the time, it should be a hook, because "the model usually complies" is not a guarantee — this is the same promote-and-gate instinct from the agents lesson, expressed as configuration.

Subagents: specialists with clean contexts

Claude Code can delegate to subagents — separate agents with their own system prompt, their own tool allowlist, and critically their own context window. Define them in .claude/agents/ (a code-reviewer that only reads, a test-writer with a narrow brief, a researcher that fans out over the codebase) and the main session dispatches to them, receiving back a report rather than a transcript. You know from the context lesson why this wins: the parent stays lean, the specialist reads only its brief, and a fresh-eyes verifier isn't anchored on the writer's assumptions. The multi-agent lesson builds on exactly this mechanism.

MCP: the same integration layer, in your terminal

claude mcp add connects any MCP server — your tracker, your database, your observability stack — and its tools join the session. Combined with the above, the compounding is visible: a slash command that invokes a skill that queries your tracker through MCP, with a hook enforcing that nothing merges without tests. Each piece is small; the composition is a development environment tuned to your team.

Parallel sessions: the workflow ceiling-raiser

One session is a pair programmer; the real shift is running several. Git worktrees give each session its own checkout of a different branch — one Claude fixing a bug, another drafting a feature, a third sweeping tests — with no file collisions, because each has its own working directory. Start with two and the muscle builds fast: your role tilts from writing code to briefing, reviewing, and steering concurrent work, which is precisely the transition the ADLC lesson formalises.

What to take into the next lesson

Commands for ritual, skills for expertise, hooks for invariants, subagents for isolation, MCP for reach, worktrees for parallelism — all checked in, all shared, all compounding. The next lesson removes the remaining constraint: you, present at the keyboard. Headless mode, CI, and the Agent SDK take the same harness where no terminal is open.