Reading path: I want to master Claude Code
Status: 🟩 COMPLETE Last updated: 2026-06-19 Plain-English tagline: Go from “I type messages and Claude does stuff” to fluent, leveraged, production-quality use. Memory, slash commands, hooks, plugins, subagents, settings — and the daily-use patterns that make it all click.
What this is
A curated trail through the AI-assisted-development section. By the end you’ll be able to:
- Configure Claude Code to fit your specific workflow (permissions, model, env, hooks)
- Build a useful memory base that compounds over time
- Write custom skills and slash commands
- Use hooks to enforce guardrails automatically
- Spawn subagents for parallel research and isolated context
- Install and trust plugins from the community
- Recognize the daily-use patterns that separate fluent operators from button-pushers
14 stops. Pace yourself — 1–3 per session. Most of this is config + habits, so you’ll get the most value by actually trying things as you go.
How to use this path
Each stop has:
- 🎯 Why you’re here — the question this stop answers
- 📖 Read — the entries
- 🛠️ Try — a small thing you can actually do right now
- 🧠 Anchor — the takeaway
Stage 1 — The mental model (2 stops)
1. Get the whole picture first
🎯 Why you’re here: Understand what Claude Code is, what it can do, and the six primitives that make it extensible — before zooming in on any one.
📖 Read:
🛠️ Try: Open a project folder, run claude, and ask Claude to describe what’s in the folder. Notice the tool calls happening on your behalf.
🧠 Anchor: Claude Code is “LLM + tools + loop + your project’s context.” The six primitives (CLAUDE.md, skills, subagents, slash commands, hooks, MCP servers) are how you extend it. Plugins bundle these for distribution.
2. The underlying tech (skim, if you haven’t)
🎯 Why you’re here: Ground your intuitions in how the underlying LLM behaves — it pays off later when you’re debugging weird behavior.
📖 Read:
- What is an LLM? 🟩
- Tool use 🟩
- Agents 🟩
- MCP 🟩 🟦
🛠️ Try: Watch a session and count tool calls. Notice the pattern: read → analyze → act → verify.
🧠 Anchor: Claude Code is a real-world agent. Everything about agents (good system prompts, careful tool design, verification, memory) applies here.
Stage 2 — Configure it for you (3 stops)
3. The memory system
🎯 Why you’re here: Memory is what makes Claude get better at working with you over time. Without it, every session starts cold.
📖 Read:
🛠️ Try: Save a memory of something you’ve been correcting Claude on repeatedly. Use the global memory folder. Check that MEMORY.md picked it up.
🧠 Anchor: Three layers — CLAUDE.md (always loaded), MEMORY.md (index), individual memory files (fetched as needed). Four types (user, feedback, project, reference). Save liberally. Maintain ruthlessly.
4. settings.json — your operational config
🎯 Why you’re here: Permissions, env vars, hooks, model preference, MCP servers — all live here. A well-tuned settings file dramatically reduces friction.
📖 Read:
🛠️ Try: Add three commands you do constantly to your allow list. Notice fewer permission prompts in your next session.
🧠 Anchor: Three buckets — allow (auto), ask (prompt), deny (block). Tune them and your sessions get much smoother. There’s both a global file and per-project files.
5. Hooks — automating guardrails
🎯 Why you’re here: When you want behavior that must happen — every time, regardless of what Claude decides — hooks are the tool.
📖 Read:
- Hooks 🟩
🛠️ Try: Add a Stop hook that beeps when Claude finishes a turn. Notice how it makes long-running sessions less attention-demanding.
🧠 Anchor: Hooks are shell commands that run on events. PreToolUse can block actions; Stop can notify you. Deterministic — they can’t hallucinate.
Stage 3 — Extend Claude (3 stops)
6. Slash commands and skills
🎯 Why you’re here: Codify your repeatable workflows. “Deploy to staging,” “review the diff,” “run the full pre-PR checklist” — turn them into one-key shortcuts.
📖 Read:
🛠️ Try: Create a /check-build skill that runs npm run build and reports failures. Invoke it. Now do it from any session.
🧠 Anchor: Skills and slash commands unified in 2026. Define once in .claude/skills/<name>/SKILL.md; invoke with /<name> or let Claude apply autonomously.
7. Plugins — bundles of extensions
🎯 Why you’re here: Why reinvent skills when someone has already made the bundle you need? Plugins ship pre-built skills, subagents, commands, hooks, and MCP servers together.
📖 Read:
- Plugins 🟩
🛠️ Try: Browse a plugin marketplace. Install one relevant to your stack. Notice the new commands appear.
🧠 Anchor: Plugins = “a folder of skills, subagents, commands, hooks, output styles, MCP configs” packaged for distribution. Install one, get the whole kit.
8. MCP servers — the tool ecosystem
🎯 Why you’re here: Want Claude to drive your browser, query your database, post to Slack, control your desktop? MCP servers expose those tools to any AI agent.
📖 Read:
- MCP 🟩 🟦
🛠️ Try: Install an MCP server you’d actually use (filesystem, GitHub, Postgres, browser control). Watch Claude use its tools in a session.
🧠 Anchor: MCP is “USB-C for AI tools.” Hundreds of servers exist. Adding one is usually a config change, then the tools just work.
Stage 4 — Advanced patterns (3 stops)
9. Subagents
🎯 Why you’re here: For tasks that need parallelism, context isolation, or specialized prompts, subagents are the right tool.
📖 Read:
🛠️ Try: Spawn an Explore subagent for a search question. Notice your main session stays clean of all the file-read noise.
🧠 Anchor: A subagent is a fresh Claude session launched via the Agent tool. Use them for “read many files but don’t dump them all in my main context” or “do this in parallel with that.”
10. Daily workflow patterns
🎯 Why you’re here: There are recurring rhythms in productive Claude Code use. Knowing them saves you reinventing each time.
📖 Read:
🛠️ Try: Pick one workflow pattern (e.g. “plan → build → verify → commit”) and apply it deliberately to your next task.
🧠 Anchor: Plan before doing. Verify before declaring done. Commit small, often. Don’t be afraid to interrupt and redirect.
11. Prompt patterns
🎯 Why you’re here: The same prompt structures work over and over for specific kinds of tasks. Reusing them saves thinking.
📖 Read:
🛠️ Try: Save one prompt template (e.g. “code review of recent changes”) into a skill. Use it next time instead of re-typing.
🧠 Anchor: Catalog the prompts that work. Save the templates. Composability of prompts is the same idea as composability of code — small, reusable, named.
Stage 5 — Operating habits (3 stops)
12. The cardinal rules
🎯 Why you’re here: Tactical guidance from real use — the habits that separate fluent operators from button-pushers.
📖 Read:
🛠️ Try: Pick one rule (most impactful: “let Claude verify its own work”). Insist on it for one full session.
🧠 Anchor: Tell Claude WHY. Let Claude verify. Commit often. Use memory. Interrupt to redirect. Read diffs. Tune permissions. Plan first.
13. When NOT to use Claude Code
🎯 Why you’re here: Knowing the boundaries makes you better at picking the right tool. Claude Code isn’t always the right answer.
📖 Read:
🧠 Anchor: Trivial tasks. Tasks you can’t review. Hands-on UI design. Some data work. For everything else — Claude Code is the default.
14. Iterate on your own setup
🎯 Why you’re here: Mastery isn’t a finish line. Periodically revisit your setup: prune unused memory, tighten hooks, retire stale skills, try new plugins.
📖 Read:
- (No new entry — this is the meta-habit)
🛠️ Try: Set a calendar reminder for monthly Claude Code maintenance. Spend 30 minutes refining.
🧠 Anchor: Your setup is a small product you’re maintaining. Treat it like one.
When you finish this path
You’ll be able to:
- ✅ Configure permissions to minimize friction without sacrificing safety
- ✅ Build a memory base that makes Claude better at working with you
- ✅ Write custom skills for your recurring tasks
- ✅ Use hooks to enforce non-negotiable behaviors
- ✅ Install plugins from the ecosystem with confidence
- ✅ Spawn subagents when context isolation helps
- ✅ Apply daily-use patterns deliberately
- ✅ Get more out of every session than you did before this path
Where to go after this
- Reading path: First webapp — apply Claude Code to building a real thing
- Reading path: Understand LLMs — go deeper into the underlying tech
- Build skills for your specific stack — pick three repeated tasks, turn them into skills
- Contribute to the ecosystem — publish a plugin or MCP server for something you wished existed