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                                  │
│  Specialist team Claude delegates to     │
├──────────────────────────────────────────┤
│  Memory                                  │
│  Persistent context across sessions      │
├──────────────────────────────────────────┤
│  Hooks                                   │
│  Automated actions (backup, safety, QA)  │
├──────────────────────────────────────────┤
│  Skills & Commands                       │
│  Task-specific instructions (/review,    │
│  /summarise, /draft, /decide, /explain)  │
├──────────────────────────────────────────┤
│  CLAUDE.md                               │
│  Behavioural config, preferences, domain │
├──────────────────────────────────────────┤
│  Claude Code                             │
│  The engine — file access, terminal,     │
│  tool use                                │
└──────────────────────────────────────────┘

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.

The key insight: no single layer is the breakthrough. The breakthrough is the layers composing together. A CLAUDE.md alone saves tokens. CLAUDE.md plus skills saves more. Add memory and hooks, and Claude starts feeling like it's been working with you for months. Add agents, and it has genuine depth.

Your Claude Code setup can connect to command-line tools outside of Claude itself. This is one of Claude Code's underrated strengths — because it runs in your terminal, it can use any CLI tool you have installed. The same way you'd switch between apps on your desktop, Claude Code can switch between CLI tools to get things done.

Why CLIs matter

A CLI (command-line interface) is a tool you run by typing a command in the terminal. You've already used one — npm to install Claude Code. There are thousands of others, each specialised for a different task.

The pattern is simple: install a CLI, and Claude Code can use it. No special integration needed. Claude just runs the command the same way you would.

Example: Codex CLI — Delegating Bulk Work

OpenAI's Codex CLI is a lightweight coding tool for delegating repetitive, well-defined tasks. Think of it as a worker you send off with clear instructions: "rename all these files," "apply this change to every component," "update every import statement."

The smart hack: Codex uses OpenAI's tokens, not your Claude tokens. For mechanical bulk operations — tasks where you just need something done, not thought through — delegating to Codex saves your Claude usage for the work that actually benefits from Claude's reasoning.

When to delegate to a tool like Codex:

• The task is mechanical — no judgement required, just execution
• It involves many files with the same change
• You want it done in the background while you keep working

When to stick with Claude Code:

• The task requires planning or decision-making
• You want to review changes interactively
• The task is complex enough that things might go wrong

Setup:

Install via npm:

npm install -g @openai/codex

Usage from Claude Code:

Use codex to rename all .js files in the src/ directory to .ts

Claude delegates to Codex, which handles the mechanical work.

Other CLIs worth knowing about

The Codex example illustrates a general pattern. Here are a few other CLIs that pair well with Claude Code:

• Vercel CLI (vercel) — deploy web projects with one command. Claude Code can build your project and deploy it without you touching a browser.
• Railway CLI (railway) — deploy backend services. Same idea: Claude Code handles the deployment flow end-to-end.
• GitHub CLI (gh) — create pull requests, manage issues, review code. Claude Code uses this heavily for git-related work.
• Google's Gemini CLI — generate visual assets (SVGs, icons) using Google's AI. Useful if you do design work and want a second AI perspective.

You don't need all of these. Install the ones that match your workflow. The point is: Claude Code's power multiplies with every CLI tool you give it access to. Each one is a new capability that Claude can use without you switching context.

Rules are instruction files that load automatically based on where you're working. Unlike your global CLAUDE.md (which loads in every session) or skills (which load when invoked), rules are scoped to specific projects.

How it works: Each project can have its own .claude/rules/ directory containing markdown files with conventions for that project. When you open Claude Code in that project folder, those rules load automatically. Your global CLAUDE.md stays clean, and each project gets its own context.

Example: You work on both a web project and a mobile app. Different conventions for each.

In your web project, create .claude/rules/conventions.md:

# Web Project Conventions
- Use functional components, not class components
- Tailwind CSS for styling — no CSS modules
- File naming: kebab-case
- State management: prefer local state, use context only for truly global state

In your mobile project, create .claude/rules/conventions.md:

# Mobile Project Conventions
- SwiftUI for all new views
- MVVM architecture
- Accessibility labels on all interactive elements
- Test on both iPhone and iPad layouts

When you open Claude Code in the web project, it loads the web rules. When you open it in the mobile project, it loads the mobile rules. No manual switching needed.

You can also put rules in ~/.claude/rules/ for instructions that should apply globally across all projects — things like your preferred code style or documentation format.

Who needs this: People who work across multiple projects with different conventions. If all your work follows the same conventions, your CLAUDE.md handles it fine. Rules are for when you need automatic context-switching between projects.

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

You want to research a topic thoroughly. Instead of running each step manually:

1. The research agent gathers information from multiple angles
2. The summarise skill condenses the findings
3. The results are saved to your vault/file system
4. A memory entry captures key takeaways for future reference

A workflow skill does all four in sequence, adapting based on what the research finds.

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)

• CLAUDE.md: Does anything need updating? New preferences, removed preferences, role changes?
• Memory: Skim MEMORY.md. Remove outdated entries. Move stable patterns to CLAUDE.md.
• Skills: Are you using all of them? Remove skills you haven't invoked in a month. They're costing zero tokens when unused, but clutter makes maintenance harder.
• Hooks: Are they running without errors? Check that git-sync is actually committing. The easiest check: run cd ~/.claude && git log --oneline -5 to see recent backups.

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 2, now with the full picture:

| Situation | Tool | Why | |-----------|------|-----| | Quick question on your phone | Claude.ai | No setup needed, works anywhere | | Brainstorming session | Claude.ai | Lightweight, conversational | | Working with files | Claude Code | Direct file access | | Complex task requiring specialists | Claude Code | Agent delegation | | Task you'll repeat | Claude Code | Skills handle it consistently | | Sensitive operations | Claude Code | Safety hooks protect you | | Building on previous work | Claude Code | Memory carries context forward |

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

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

| Layer | What You Have | |-------|--------------| | Understanding | What Claude is, how to think about it, when to use it | | Claude.ai | Five prompting patterns, Projects, custom instructions | | Claude Code | Installed, configured, comfortable | | CLAUDE.md | Comprehensive behavioural config — 500 words that shape everything | | Skills | 5+ task-specific tools, ability to build your own | | Hooks | Auto-backup, safety gate, code validation | | Memory | Persistent context across sessions | | Agents | 20+ specialists ready when a task demands depth | | External CLIs | Codex for bulk work, Vercel/Railway for deploys (optional) | | Rules | Domain-specific auto-loading context (optional) | | Workflows | Composed multi-step processes |

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.

The independence test: If this guide disappeared tomorrow, could you maintain and extend your setup? If you've followed along, the answer is yes. That was the goal.

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.