The Full Picture

Let's step back and see the system you've built. Each module added a layer. Here's how they stack:

  ┌──────────────────────────────────────────────┐
  │  Your Conversation                           │
  │  what you type, what Claude says             │
  ├──────────────────────────────────────────────┤
  │  Agents                  ← Module 9          │
  │  specialist team Claude delegates to         │
  ├──────────────────────────────────────────────┤
  │  Memory                  ← Module 8          │
  │  persistent context across sessions          │
  ├──────────────────────────────────────────────┤
  │  Hooks                   ← Module 7          │
  │  automated actions (backup, safety)          │
  ├──────────────────────────────────────────────┤
  │  Skills & Commands        ← Module 6         │
  │  task-specific instructions                  │
  ├──────────────────────────────────────────────┤
  │  CLAUDE.md                ← Module 4-5       │
  │  behavioural config, preferences             │
  ├──────────────────────────────────────────────┤
  │  Claude Code               ← Module 3        │
  │  the engine — files, terminal, tools         │
  └──────────────────────────────────────────────┘

Each layer builds on the ones below it:

• CLAUDE.md shapes how Claude behaves in every conversation
• Skills give it structured approaches to specific tasks
• Hooks automate background operations without consuming tokens
• Memory carries context forward so nothing gets re-explained
• Agents provide specialised depth when the task demands it

And all of this sits on top of Claude Code's core ability to read, write, and work with files on your computer.

Here's where the system gets genuinely powerful. Individual pieces are useful on their own. But the real leverage comes from composing them into workflows.

A workflow is a skill that orchestrates multiple capabilities. Instead of "summarise this document" (one skill) or "use the research agent" (one agent), a workflow chains multiple steps together.

Example: Research Workflow

Example: Writing Workflow

You want to write a piece of content:

1. Brainstorm angles using the brainstormer pattern
2. Pick an angle and outline it
3. Draft using the /draft skill
4. Review using the /review skill
5. Humanise the output (remove AI writing patterns)
6. Save the final version

How to build workflows

Workflows are just skills with more steps. The same ~/.claude/commands/ system. The difference is that a workflow skill references other skills and agents:

Research and write about the topic I specify.

Process:
1. Use the research synthesiser agent to gather information
2. Present key findings as bullet points and wait for my input on angle
3. Create an outline based on my chosen angle
4. Draft the content using the /draft approach
5. Self-review for clarity and logical gaps
6. Present the final draft for my review

Rules:
- Check in with me after step 2 — don't proceed without my input on angle
- Keep the total output under [word limit I'll specify]
- Save the final version to the file path I specify

Start with manual workflows (doing each step yourself). When you notice a sequence you repeat, codify it as a workflow skill. Don't build workflows preemptively for sequences you might do — build them for sequences you've already done three times.

Your setup is a living system. It'll need occasional attention to stay effective.

Monthly check (15 minutes)

When Claude updates

Anthropic updates Claude regularly. Most updates are invisible — better reasoning, fewer errors, new capabilities. Occasionally, an update changes how something works (new settings format, new hook points, modified behaviour).

When that happens, this guide updates too. Check back for notes on what changed and what to adjust. Usually, the answer is "nothing" — the setup we've built is based on stable patterns, not fragile implementation details.

When your work changes

New job, new project type, new domain — your setup should evolve with you. The modular architecture makes this straightforward:

• New domain? Add a rule file or update your CLAUDE.md work section.
• New repetitive task? Create a skill.
• New specialisation needed? Add an agent.
• Old thing no longer relevant? Delete the file. No dependencies to untangle.

Revisiting this from Module 4, now with the full picture:

The general pattern: Claude.ai for thinking, Claude Code for doing.

Claude Code has 50+ built-in commands (type / to browse them). Most are self-explanatory, but a few are genuinely useful and easy to miss:

You don't need to memorise these. Type / at any point and browse. The ones above are just the ones that tend to surprise people — "I didn't know it could do that."

Let's see where you are now compared to Module 1:

This is a comprehensive, token-efficient setup that's been tested across real daily work. It was built incrementally so you understand every piece. Nothing is magic. Nothing is copy-pasted blindly. You know what everything does, why it's there, and how to change it.

More importantly: you know how to evolve it. New skill? Create a file. New agent? Create a file. New preference? Edit CLAUDE.md. The system grows with you.

Thanks for trusting us. We took your time and your tokens seriously. Now go use the thing.

Something unclear? Something we got wrong? Something we could do better? We want to know: [contact method]. This guide is a living document. Your feedback makes the next version better for everyone.