Claude Code's Missing Manual: Stop Typing and Start Orchestrating

⚡ TLDR

• What it solves: The gap between knowing Claude Code’s features exist and knowing how to wire them together into an automated pipeline.
• Why it matters: Without hooks, memory, and subagent patterns connected, you are still the orchestrator - typing the same rules every session.
• Best for: Developers moving past basic prompting who want hooks, slash commands, and subagents working as a system.
• Main differentiator: Copy-paste templates that connect memory → subagent → pre-commit hook in one cohesive setup, not isolated snippets.
• Usecase example: A /review-pr command that delegates to an isolated code-reviewer subagent and posts GitHub diff comments via MCP - hands-free.

I opened a 50MB log file. VS Code choked. Claude scrolled smoothly, jumped to line 40,000, and filtered the pattern in seconds. For a moment I felt clever. A little later, I realized I had to manually prompt it to do this every single time. I was still doing the orchestration.

luongnv89/claude-howto is a collection of Markdown and JSON files. Specifically, it is a repository of copy-paste templates that configure Claude Code’s memory, hooks, subagents, and slash commands for your project.

Two builders. One grabs the saw immediately. The other asks five questions first. The first feels faster. The second’s shelf is still on the wall six months later. Most people treat Claude like the first builder - typing commands endlessly and hoping the context window survives. This repository is the blueprint for the second builder.

Take a look at how it implements a formatting hook:

# ~/.claude/hooks/format-code.sh
# Formats code automatically before Claude writes to disk
npm run format

And then wiring it in .claude/settings.json:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Write",
        "hooks": ["~/.claude/hooks/format-code.sh"]
      }
    ]
  }
}

You drop these two snippets into your setup, and suddenly your AI never commits misaligned code again.

Why the official docs aren’t enough

The official Claude Code documentation tells you that these features exist. It shows you the API for a slash command. What it does not show you is how to wire a slash command to a memory bank, pass it to an autonomous subagent, and validate the output with a pre-commit hook.

Approach	What you do	What happens	How long it takes
Old way	Type /review, copy-paste rules, complain when it ignores them	Claude hallucinates a standard	10 minutes per PR
This repo’s way	Copy the code-reviewer.md subagent and memory files	Claude invokes the exact agent with your exact rules	5 minutes setup, 0 minutes later

If you are just writing python scripts for fun, you do not need this. But if you are trying to make an AI agent actually review code like a grumpy senior engineer in your CI/CD pipeline, this is what you reach for.

How it pieces together

Setting up hooks strictly handles formatting. Real orchestration begins when you hand over complex workflows to subagents and connect them with external data via MCP (Model Context Protocol).

If you want Claude to review pull requests exactly like the lead engineer does:

# 1. Add GitHub MCP to give Claude raw API access
claude mcp add github -- npx -y @modelcontextprotocol/server-github

# 2. Copy the PR reviewer agent into your project
cp 04-subagents/code-reviewer.md .claude/agents/

When you type /review-pr, you are no longer just sending text to an LLM. The root agent delegates to the code-reviewer subagent. That subagent wakes up inside a completely isolated context window - it doesn’t see your previous chats, it only sees the PR rules from your CLAUDE.md and the actual diff from the GitHub MCP.

Because its context is narrow, the AI doesn’t hallucinate a fake coding standard. It finds an issue, evaluates it against the exact rules, and issues an API call through the MCP server to drop a comment right on the GitHub diff line. The workflow completes silently in the background while you grab coffee.

The tradeoffs

The setup is heavy. If you copy all 10 modules, your .claude folder becomes a maze of rules, skills, and MCP configurations. Sometimes, you just want to ask a quick question, but your over-configured agent team kicks off a multi-step planning phase, invokes three skills, and takes two minutes to say “Yes.” It demands discipline. If you do not actively maintain the memory files, they become stale.

I believe in miracles, so we kept fine-tuning our setup. After a weekend with this guide, my CLI isn’t just an interface anymore. It is an orchestra, and I am finally sitting in the conductor’s chair.