The Command Kit

The Command layer is the shared brain you maintain with your AI. It's the framework, the ethos, the folder structure, the most simplistic boiled-down framework of your business. Highest-level view: what your business does, who it serves, why it's important, why it's special. It's where you, the captain, work. It's what your AI references. It's what your agents add to and reorganize as the work gets done.

If you only take one thing away: Command is your shared brain with your AI coworkers. Everything else follows.

What's actually in mine

My current Command Kit, the one I'm typing this from, has a fixed top-level structure. Each top-level folder has a job. Nothing is decorative.

• CLAUDE.md, the schema. Tells the AI where things go, who works here, what we're trying to do, how I want things done. This is the one file I'd save if I lost everything else.
• raw/, immutable source material. PDFs I download, web clips, research jobs, agreements, meeting transcripts. The intake folder. Things go in, never come out.
• wiki/, LLM-compiled knowledge. One entity page per venture, client, person, or concept. Cross-referenced with wikilinks. Maintained by Claude as I work.
• ventures/, code and ops folders for each business or project. Git repos, project files, deployable software.
• missions/, thin files linking to Linear issues. Just navigation aids, Linear is the source of truth.
• templates/, recurring patterns. Meeting log format, decision template, venture page skeleton. The structure I want preserved across new entries.
• atlas/, navigation Maps of Content (MOCs), Obsidian-style. The way you find things when you don't remember exactly where they live.
• calendar/, daily notes, journal. Human-authored.
• tools/, reusable scripts. Fixed inventory. New scripts get scrutiny before they earn a slot.
• archive/, deprecated, completed, one-off. Where things go to die without losing the history.

The structure mirrors how I actually think about my work. Anthropic's own best practices recommend the same: organize folders to mirror how you think. Project → areas (marketing, finance, ops) → specific things. Each level can hold its own CLAUDE.md.

The first 24 hours, for someone with nothing

If you've never built a Command Kit, here's the order of operations for day one:

1. Clone the open-source starter. git clone https://github.com/shipwithmax/command ~/command. Or grab it from the product page.
2. Open it in Claude Code. cd ~/command && claude. Optionally also open it in Obsidian, the markdown files render beautifully and the wikilinks work.
3. Edit CLAUDE.md. Replace the placeholder with: who you are (one paragraph), what you're working on (one paragraph), how you want Claude to work with you (3-5 bullet points). Save.
4. Drop one real document into raw/. A PDF of a key document. Your business plan. A meeting transcript. Anything you'd want Claude to know about.
5. Ask Claude to read it and create a wiki entry. "Read raw/[filename]. Create a wiki page summarizing the key points and link to the source." Watch what happens.
6. Update CLAUDE.md with one thing you learned. Maybe the wiki page Claude made was structured wrong. Maybe the way it summarized was off-tone. Capture the correction in CLAUDE.md so it doesn't repeat.

That's day one. You've now run one rotation of the Captain's Flywheel inside your Command Kit. Multiply that by 90 days and you have a brain Claude understands.

Three things I learned the hard way

1. Connect your project management tool early. For me, it's Linear. Every task I do gets linked back. Every change I commit references its issue. This forces the system to stay contextually aware: what is this project, what task am I doing, how does it ladder up. Without this, OpenClaw-style autonomous agents go off the rails because they have no anchor for what matters this week vs. next quarter.
2. Don't build dashboards too early. The only thing worse than no dashboard is a busy dashboard you don't actually use. I've built dozens for my clients, operations, sales, marketing, content, analytics, and I'm telling you: until you intimately understand what data analytics you need in your life, every dashboard is premature optimization. The Command Kit is the dashboard. Markdown is the dashboard.
3. Git everything. The folder must be version-controlled. Without git, you can't roll back when an agent reorganizes badly. You can't see what changed last week. You can't audit Claude's edits. You can't safely let agents touch the structure. Git turns the Command Kit from a fragile pile of files into a system you can let your crew work in.

The boundary question, Command vs. Compute

Where do you draw the line? Easy heuristic:

• Command holds theory, the ideas, decisions, frameworks, knowledge that make your business yours. Stuff you'd want to keep if you switched AIs. Stuff that requires you to author and update.
• Compute holds execution, the workers, scripts, agents, MCPs, deployed services that turn theory into output. Stuff you can replace or refactor without losing anything irreplaceable.

Edge cases: Where do prompt templates go? Command (they're authored by you, they encode your taste). Where do API keys go? Outside both, secrets file, never in the repo. Where do agent configs go? Compute (they're disposable execution detail). Where do "lessons learned" go? Command, in the relevant entity page or concept page.

Anthropic's three-layer memory model

As of March 2026, Anthropic ships a three-layer memory system. We integrate with it:

1. CLAUDE.md (you write). Explicit instructions, "AI onboarding plus operating manual." Brief, explicit, high-signal. Not a knowledge dump.
2. MEMORY.md (Claude maintains). Auto-memory file Claude writes itself based on what it learns about your patterns and preferences. Loads first 200 lines at session start. Routing rules don't go here, they belong in CLAUDE.md.
3. Chat memory (cross-session). Claude remembers context from prior conversations and surfaces it when relevant.

The Command Kit works on top of all three. CLAUDE.md sits at the root of your folder. MEMORY.md gets generated next to it. The wiki, raw, ventures, and tools folders give Claude the explicit context it needs alongside the implicit memory it builds. Together: a brain that gets smarter with every session.

How Command evolves

You'll know your folder structure is wrong when finding things gets harder, not easier. When you're afraid to add a new entry because you don't know where it goes. When Claude keeps misfiling new content. That's the signal to reorganize.

The most common evolution path I've seen: start with the open-source starter; add one new top-level folder when you feel friction; merge or split sub-folders when patterns emerge; promote frequently-referenced entries to atlas/. Don't restructure for fun. Restructure when the friction tells you to.

When Command fails

The most common failure: bad context produces bad output. Claude can't read between the lines if the lines aren't there. The fix is almost always upstream, improve the CLAUDE.md, write a clearer wiki entry, drop a missing source into raw/. Once. Fixed forever.

The second-most-common failure: you stopped using Command and started bypassing it. Easier to just type the prompt directly. Faster in the moment. Slower in aggregate. Discipline of returning to the folder, of writing context once and reusing it, is what makes the system compound. Skip it and you're just doing prompt engineering, which (per our doctrine on context) is a much weaker leverage point than context engineering.

This is what Peter Naur called "theory building" back in 1985: the program lives in your mind. Code is its shadow. The Command Kit is the explicit articulation of the theory, so the AI can render the shadow without losing the thread.