03

Move 03 · Systems

Architecture into a folder. Whatever you add next has a place.

Move 01 gave Claude your soul. Move 02 gave Claude hands. This move is the room they live in. Read it through in order. The architecture is the smallest part of the work and the part that decides whether the next two years compound or collapse.

Section 01 · Why this exists

The entropy tax.

You've finished Move 01 and Move 02. Claude knows your business. Claude can reach your systems. The first month feels like a victory lap. Then the second tax starts to compound, quietly, in the background.

You learn something useful. Claude slips an em-dash into a client email, you correct it, and next session it slips again because you didn't write the rule down. You discover a workflow for pulling weekly numbers and you do it in chat instead of saving it, because saving feels heavy. Your assistant joins a new Slack channel and you make a mental note instead of recording the channel ID. Three months in, you've learned dozens of small things and recorded almost none of them. The same corrections keep firing. The same workflows get rebuilt every week. The same lookups happen by hand.

When you DO try to save something, you put it where it feels right that day. A learned lesson goes in a file called notes.md. An account ID goes into important-stuff.md. A weekly workflow gets dropped in a random folder you never open again. Six months in, your ~/.claude/ is a junk drawer. You've stopped adding because adding feels like making it worse. The compounding never starts.

This is the entropy tax. The first two moves gave you superpowers. Without a room to hold them, every addition increases mess instead of value. The fix isn't more discipline. It's a structure so the discipline becomes automatic.

Without architecture

Lessons disappear. The same corrections fire forever. Workflows get rebuilt by hand every week. Account IDs live in your head until they don't. Six months in, the folder is unnavigable and you've quietly stopped adding to it.

With architecture

Every kind of thing has a place. New additions land in obvious folders without you having to decide. The folder grows wider, not messier. Two years in, your system is denser AND still navigable, because the architecture absorbed the growth.

Section 02 · The metaphor

Room, not pile.

Most operators reach this move thinking of ~/.claude/ the way they think of any folder on their computer: a place to put files. Make a new file, save it in, done. That's a pile. Piles grow but they don't organise. Even a tidy pile becomes a mess the moment you add five more things to it.

A room is different. A room has zones with defined functions. Kitchen, bedroom, study. You don't decide where the kettle goes. The kettle belongs in the kitchen because that's what kitchens are for. Adding a second kettle doesn't make the room messier; the room absorbs the addition because every kind of thing has a defined home.

What most folders become

Pile

Files saved wherever felt right at the time. New folders created ad hoc as needs came up. Half the names start with "notes" or "stuff" or "important". The whole folder grows in entropy with every addition. You can't find anything older than a month and you've quietly stopped looking.

A pile grows. A pile never organises itself.

What the architecture builds

Room

Five things at the top level. Each one has a defined function. Every new addition has an obvious home before you make it. The folder grows wider, never deeper or messier. Three years from now this folder is three times the size and still feels navigable on first open.

The shift

A pile is what you have. A room is what you build. Piles fight you as they grow. Rooms get more useful.

Section 03 · The room

Five things at the top. Two that live alongside.

The room has seven primitives. Five live inside the folder. Two live next to it. Learn the names once. After that, every addition you make for the rest of your time on Claude Code has an obvious home.

The folder

~/.claude/
│
├── CLAUDE.md                  ← the foundation (Move 01)
│
├── skills/                    ← the labour (Move 02)
│   ├── chrome-takeover/
│   └── ghl-toolkit/
│
├── memory/                    ← rules and lessons
│   ├── feedback_no-emdashes.md
│   ├── feedback_member-warmth.md
│   └── project_q3-retention.md
│
├── references/                ← pointers to your data
│   ├── crm-locations.md
│   ├── meta-ad-accounts.md
│   └── slack-channels.md
│
└── commands/                  ← daily-driver shortcuts
    ├── monday-numbers.md
    └── weekly-team-1to1.md

Every kind of thing has a home. Every new addition has an obvious place. Two years from now, this folder is still navigable and three times the size.

The seven primitives, named

  • 01

    Environments

    ~/.claude/CLAUDE.md

    The layer that gives Claude its operating context before a conversation starts. You met this in Move 01. There can be more layers later, but today the one file does the whole job.

  • 02

    Skills

    ~/.claude/skills/

    Files (or small folders of files) that give Claude specific capabilities. You installed two in Move 02. Each does one job, scoped tight, invoked on demand.

  • 03

    Memory

    ~/.claude/memory/

    Rules and lessons that shape how Claude responds. Corrections become memory files. Claude reads them next session and applies the rule automatically, so you stop correcting the same things forever.

  • 04

    References

    ~/.claude/references/

    Pointers to your canonical data. Account IDs, location lists, credentials' homes, system maps. Not the data itself, the pointers Claude needs to reach it.

  • 05

    Commands

    ~/.claude/commands/

    Daily-driver shortcuts. Slash commands you invoke for multi-step workflows. Build once, invoke every day for the rest of your time on Claude Code.

  • 06

    Hooks

    ~/.claude/settings.json

    Automated behaviours that fire on specific events. Most operators don't write hooks in their first year. Knowing the room has a place for them is enough for now.

  • 07

    MCPs

    (connected separately)

    How Claude reaches outside your folder to external systems with persistent connections, like Slack, Notion, Drive. Different from skills (on-demand) vs MCPs (always-connected). Lives next to the room, not inside it.

That's the entire room. Five folders, one settings file, one external connection layer. You won't outgrow it.

Section 04 · The discipline

Where does this go?

Once the room exists, every addition becomes a one-question decision: which primitive does this belong to? After a week of practice you stop having to think. The decision map below is the cheat sheet for the first week.

Learned a lesson from a mistake→ memory/
Found a repeated workflow you do the same way each time→ skills/
Need Claude to reach a new system→ skills/ or MCP
Want Claude to fire something automatically on an event→ hooks/
Discovered an account ID, channel ID, or system pointer→ references/
Context grew past one CLAUDE.md→ environments/

The whole point of the room is that "where does this go?" has a fast answer. If a new addition doesn't fit any primitive, the question to ask is: should it be saved at all?

Section 05 · Two folders, six months in

What it looks like done badly. What it looks like done right.

Sarah Chen, six months after finishing this guide. Same operator. Two ways her ~/.claude/ could look. The first is what happens when you skip the architecture and let entropy run. The second is what happens when you build the room first and let every addition land in its primitive.

Bad · The pile

~46 files, no logic

~/.claude/
├── CLAUDE.md
├── claude-notes.md
├── notes-on-clients.md
├── important-stuff.md
├── ai-stuff-i-learned.md
├── mistakes-to-avoid.md
├── claude-prompts.md
├── slack-channels.txt
├── account-ids.txt
├── workflows/
│   ├── tuesday-workflow.md
│   ├── retention-stuff/
│   │   └── ... (12 files)
│   └── old/
│       └── ... (8 files)
├── skills/
│   ├── marketing-helper/
│   ├── random-thing/
│   └── notes-that-arent-skills.md
├── README.md
├── README-v2.md
└── ... (28 more loose files)

Files grew without architecture. Three different files called variations of "notes." Workflows scattered across random folders nested inside random folders. Account IDs hardcoded into a mystery important-stuff.md. A skills/ folder that does have skills but also has unrelated files dumped in.

The folder is unnavigable. Sarah has stopped adding to it because every addition feels like making it worse. The compounding she was promised never started.

Good · The room

five folders, clean

~/.claude/
│
├── CLAUDE.md
│
├── skills/
│   ├── chrome-takeover/
│   ├── ghl-toolkit/
│   ├── pull-weekly-revenue/
│   ├── draft-retention-email/
│   ├── audit-ad-account/
│   └── team-brief-from-slack/
│
├── memory/
│   ├── feedback_no-emdashes.md
│   ├── feedback_member-warmth.md
│   ├── feedback_offer-no-availability.md
│   ├── project_q3-retention.md
│   └── project_winter-marketing.md
│
├── references/
│   ├── crm-locations.md
│   ├── meta-ad-accounts.md
│   ├── slack-channels.md
│   └── team-contacts.md
│
└── commands/
    ├── monday-numbers.md
    ├── weekly-team-1to1.md
    └── friday-retention-sweep.md

Five things at the top. Each addition over six months landed in its defined place. Memory absorbed dozens of small corrections. References holds every account ID and channel list in clean files Claude can read on demand. Commands holds the weekly workflows Sarah now invokes by name.

The folder is now three times denser than the bad version AND still feels organised. Sarah opens it without dread. She adds something new today and knows exactly where it goes before she creates the file.

The difference isn't effort. The bad folder probably took more work to maintain because everything was ad hoc. The difference is that every addition in the good folder had an obvious home before Sarah made it. Architecture turns growth into compounding instead of mess.

Section 06 · Two ways in

Build the room from scratch, or reorganise what you have.

Same destination, two starting lines. If you came in clean (Move 02's bundle was your first ~/.claude/ activity), run the one-line scaffold below and the room exists. If you already have files in ~/.claude/ and it's drifting into pile, open your Claude Code and paste the audit prompt. Claude lists every file, classifies each one, and walks you through reorganisation.

Path A · Build the room from scratch

Run one command. Room exists.

Open Terminal. Paste the command below. Four folders created with a placeholder README in each that explains what belongs there. From this moment on, every new addition has an obvious home.

mkdir -p ~/.claude/{skills,memory,references,commands}
echo "# Memory · Rules and lessons Claude reads next session.
Save corrections here as feedback_<topic>.md files." > ~/.claude/memory/README.md
echo "# References · Pointers to your canonical data.
Account IDs, channel lists, system maps. Not the data itself." > ~/.claude/references/README.md
echo "# Commands · Daily-driver shortcuts.
Multi-step workflows you invoke by name." > ~/.claude/commands/README.md
echo "Room built. Every future addition now has a home."

Path B · You already have files in ~/.claude/

Audit yours with Claude Code.

Open a fresh Claude Code session. Paste this prompt. Claude lists every file in your ~/.claude/, classifies each one against the seven primitives, suggests the right home for floaters, flags bloat, and walks you through reorganisation one file at a time.

List every file and folder in my ~/.claude/.

I just finished The Operator's Guide to Claude Code. Move 03 (Systems) taught me there's a folder architecture: CLAUDE.md at the root, then skills/, memory/, references/, commands/. Each kind of addition has a home. The folder is a ROOM, not a pile.

Audit my folder:

1. For each top-level file or folder, classify it: belongs in the architecture (matches a primitive) or floating (no clear home).

2. For the floaters, propose the right primitive folder based on what the file actually does:
   - A learned lesson or correction → memory/
   - A pointer to canonical data (account IDs, channel lists, system maps) → references/
   - A repeated multi-step workflow I invoke by name → commands/
   - A skill that touches a system → skills/

3. Flag anything that's actually bloat: one-off notes, stale files, duplicates, files I haven't touched in months that don't belong to any primitive.

Then walk me through reorganisation one file at a time. When we're done, my ~/.claude/ is the room: every file in its primitive, nothing floating, nothing bloated.

Walk-away test

Open ~/.claude/ in your file browser. Look at the top level. You should see CLAUDE.md and four folders: skills/, memory/, references/, commands/. Nothing else. If you see floating files like notes.md or stuff.md, the room isn't built yet. Move them into the right primitive or delete them. The test isn't a quiz. It's a visual check: at a glance, can a stranger figure out what each folder is for?

Close · The three moves together

This is what compounding actually looks like.

Every week you operate, you'll learn something. A lesson. A repeated task. A new system to reach. Each addition has a home. Nothing gets lost. The system gets smarter every week, automatically, because you're feeding it the corrections and additions as they happen instead of letting them disappear. That's compounding. Most tools amplify what you do, one-to-one. Infrastructure is different. The gap between you and someone running a generic AI widens every month, not because you're working harder, but because your system is getting denser while theirs stays the same.

You've done all three moves. The soul. The hands. The room. From here, the question stops being "what can AI do?" and starts being "what should I add to my system this week?" The answers compound for as long as you keep showing up.