Claude Code Guide: Skills, Subagents, Hooks, MCP

I use Claude Code every day, and it’s honestly hard to go back.

Not because it writes code for me (lots of tools can do that). It’s because Claude Code makes me feel like I’m running a small engineering team inside my terminal: fast exploration, solid plans, deterministic automation, integrations everywhere, and a workflow that keeps me shipping without breaking things.

The key is to stop using it like “chat + code” and start using it like a programmable agent runtime. Once you do, your output jumps.

This is the no-fluff guide to the pieces that matter: CLAUDE.md memory, Skills, subagents, slash commands, hooks, and MCP and how they combine into a professional workflow.

The mental model: Claude Code is an agent OS

Claude Code becomes powerful when you treat it like:

Memory layer (project rules & context)
Capabilities layer (Skills + commands)
Delegation layer (subagents)
Automation layer (hooks)
Integration layer (MCP)

If you set these layers right, Claude Code feels less like “assistant” and more like leverage.

1) CLAUDE.md: make your standards automatic

If your team has conventions, don’t “remember them” encode them*.

Claude Code reads CLAUDE.md automatically when a session starts. This is where you put the boring-but-critical stuff that causes PR churn:

stack + versions
how to run tests
style rules that matter
workflow expectations
links to deep docs

Keep it short and sharp:

# Stack
- Next.js App Router
- TypeScript strict
- PostgreSQL + Prisma

# Commands
- npm run dev
- npm run test
- npm run lint

# Rules
- No `any` (use `unknown`)
- Prefer small PRs
- Run typecheck after changes

My rule: if I’ve corrected Claude twice on the same thing, it goes into CLAUDE.md.

2) Skills: reusable expertise Claude can invoke automatically

Skills are how you stop writing the same “please do X this way” instructions forever.

A Skill is a small folder with a SKILL.md file that describes:

what it does
when to use it
what tools it’s allowed to touch

Example (code review):

---
name: code-reviewer
description: Review code for best practices and security issues. Use when reviewing PRs or analyzing code quality.
allowed-tools: Read, Grep, Glob
---

# Instructions
1. Scan relevant files
2. Flag risks and security issues
3. Suggest concrete changes
4. Provide a short checklist at the end

Where they live:

~/.claude/skills/ (your personal global set)
.claude/skills/ (team/project skills committed to git)

When Skills shine: consistent outcomes. “Review this PR” becomes predictable.

3) Subagents: keep the main thread clean and focused

Subagents are specialized workers running in their own context. This matters because long debugging or repo exploration can pollute the main conversation.

Use subagents for:

debugging
refactors
architecture investigation
security review
dependency analysis

Example subagent:

---
name: debugger
description: Use immediately when errors occur. Find root cause + minimal fix + verification.
tools: Read, Edit, Bash, Grep, Glob
model: sonnet
---

You are a debugging specialist.

## Process
1. Capture exact error + repro steps
2. Locate failing area
3. Implement minimal safe fix
4. Verify with tests

My pattern: orchestrator in the main thread, heavy lifting in subagents.

4) Slash commands: turn your best prompts into tools

Slash commands are “prompt macros” with structure and guardrails.

Put them in:

.claude/commands/ (project)
~/.claude/commands/ (personal)

They’re perfect for repeatable tasks:

“create PR description”
“generate changelog”
“commit with convention”
“run focused test suite and summarize failures”

Example conventional commit command:

---
allowed-tools: Bash(git add:*), Bash(git commit:*)
argument-hint: [message]
description: Create a git commit with a conventional message
---

## Context
- Status: !`git status`
- Diff: !`git diff HEAD`

## Task
Create a git commit with message: $ARGUMENTS

This is how you move from “Claude sometimes does it right” to “Claude does it right the same way every time.”

5) Hooks: the difference between “suggested” and “enforced”

Hooks are where Claude Code stops being a helpful assistant and starts being a reliable workflow engine.

Hooks are shell commands that trigger at specific lifecycle events (pre-tool, post-tool, permission requests, session start/end, etc.). They’re deterministic.

That means you can:

auto-format after edits
block changes to sensitive files
enforce branch rules
log tool usage
notify when Claude is waiting

Auto-format example:

{
  "hooks": {
    "PostToolUse": [{
      "matcher": "Edit|Write",
      "hooks": [{
        "type": "command",
        "command": "npx prettier --write $FILE",
        "timeout": 30
      }]
    }]
  }
}

Guardrail example: block edits on main:

{
  "hooks": {
    "PreToolUse": [{
      "matcher": "Edit|Write",
      "hooks": [{
        "type": "command",
        "command": "[ \"$(git branch --show-current)\" != \"main\" ] || exit 2"
      }]
    }]
  }
}

If you do only one thing after reading this article: Add hooks for formatting + basic safety rules. Your speed stays high, but risk drops massively.

6) MCP: connect Claude Code to your real systems

MCP (Model Context Protocol) is what turns Claude Code into a bridge to the rest of your stack: databases, issue trackers, CI, browsers, internal APIs.

Add servers with claude mcp add:

# Remote server over HTTP
claude mcp add --transport http notion https://mcp.notion.com/mcp

# Local server over stdio
claude mcp add --transport stdio postgres --env DATABASE_URL=$DB_URL \
  -- npx -y @bytebase/dbhub

Once MCP is set up, Claude Code can work with tools like:

GitHub / Sentry / Vercel
Notion / Linear / Slack
Postgres / SQLite / MongoDB
Browser automation (Playwright/Puppeteer servers)

The real power move: build a custom MCP server for your domain. That’s where AI stops being generic and becomes a competitive advantage.

7) The workflow that actually ships: Explore → Plan → Code → Verify → Commit

This is my default:

Explore “Read the relevant files without writing code.”
Plan “Propose an implementation plan. Include edge cases and tests.”
Code “Implement step-by-step. Run targeted tests after each change.”
Verify Typecheck + unit tests + any critical integration checks.
Commit/PR Use slash commands for consistent commit messages and PR templates.

If you want to go faster, parallelize with worktrees:

git worktree add ../project-feature-a feature-a
cd ../project-feature-a && claude

# another terminal
cd project && claude

Closing: why this feels like superpowers

Claude Code isn’t magic. It’s leverage.

Memory prevents repetition
Skills encode expertise
Subagents keep you focused
Commands make workflows repeatable
Hooks enforce discipline automatically
MCP connects everything end-to-end

That combination is what makes the daily experience feel so powerful: you’re not “asking an AI to help” you’re orchestrating an agent system.

Do you have any workflow or tool that you want to share? Leave it in a comment!

Claude Code Made Me Ridiculously Productive: Skills, Subagents, Hooks, and MCP

Without the Fluff

Table of contents