All Days
Day 5
Founder OS — Complete Second Brain Setup
CLAUDE CODE \u00b7 COMPLETE SETUP GUIDE
The full Second Brain.
Every layer.
11 prompts. Each builds on the last. Paste each prompt into Claude Code and follow the conversation. By the end, your AI knows who you are, uses your tools, runs your workflows, and works while you sleep.
Phase 1 \u2014 Foundation (3 steps)Phase 2 \u2014 Intelligence (4 steps)Phase 3 \u2014 Power (4 steps)
BEFORE YOU START
Install Claude Code in 3 steps
Run these commands in order. Then open any folder, type claude and press enter. Every prompt below goes in that session.
PHASE 1 · FOUNDATION
Give Claude your identity, structure, and memory
The three files that define who you are, how your work is organized, and what Claude should remember across sessions. Do these first — every other step depends on them.
1
Step 1 of 11 \u00b7 CLAUDE.md
Build your CLAUDE.md — the identity file
10–15 min
This file is read at the start of every session. It tells Claude who you are, what you’re building, your tools, your communication style, and your rules. Without it, Claude starts fresh every time. With it, Claude already knows your world.
Claude will interview you one question at a time across 8 areas. Answer in full sentences — the richer your answers, the more precisely Claude will behave in every future session. This is the most important step in the entire guide.
Paste into Claude Code
You are setting up my personal CLAUDE.md — the instruction file read at the start of every Claude Code session.
Before writing anything, interview me one question at a time. Never ask multiple questions together. Wait for my answer before asking the next one. After you have enough context, write the full CLAUDE.md file.
Cover these areas in order:
1. Who I am and what I do (job title, business, industry, what I’m building)
2. My current active projects (what I’m working on right now)
3. My daily tools and tech stack (every app, language, platform I use)
4. How I like to communicate with AI (direct / detailed / step-by-step / visual)
5. What I want Claude to help me with most (top 3 use cases)
6. My working style (how I debug, how I make decisions, what frustrates me)
7. Rules Claude must always follow in our sessions
8. Things Claude must never do or assume
After the interview, write the complete CLAUDE.md file and save it to my project root. Structure it with clear markdown headers. Make it feel personal — not a generic template. Keep it under 200 lines.
Start with this exact question:
"Let’s build your CLAUDE.md. I’ll go one question at a time so I can understand your world properly. First: what do you do for work, and what are you currently building or trying to accomplish?"
After Claude writes the file, say "add these rules:" and list anything it missed — be specific about edge cases
Hard limit: 200 lines per CLAUDE.md file. Claude truncates after 200 lines. Use @path/to/section.md imports to keep it lean and modular
Monorepos: put a CLAUDE.md in each subfolder — root loads at startup, subfolders load lazily when Claude reads files in them
Update it anytime: open a session and say "update the tools section in my CLAUDE.md" — Claude edits it in place
2
Step 2 of 11 \u00b7 Folder Structure
Build your folder structure — the PARA system
5 min
A consistent folder structure means Claude can navigate your work without you explaining where things live every session. Based on the PARA method — Projects, Areas, Resources, Archive — customized to your actual work.
Claude reads your CLAUDE.md from Step 1 and creates subfolders that match your real projects. Each folder gets a README.md explaining what goes there with 3 concrete examples from your work.
Paste into Claude Code
Read my CLAUDE.md and understand my work, projects, and tools.
Set up a second brain folder structure based on the PARA method. Customize every subfolder to match my actual work — no generic placeholders.
Create these top-level folders:
- 00_Inbox/ → quick capture, process weekly
- 01_Projects/ → time-bound work (customize subfolders for my current projects)
- 02_Areas/ → ongoing responsibilities (Sales, Marketing, Operations, Technical — based on my work)
- 03_Resources/ → reference and knowledge (tools, notes, docs, inspiration)
- 04_Archive/ → completed or inactive work
- 05_Attachments/ → files, images, PDFs
Rules:
- Every subfolder must reflect my actual work from my CLAUDE.md
- Each subfolder gets a README.md with: what it is, 3 real examples of files I’d store here, how often I’d update it
- Folder names should be instantly obvious — no jargon
After creating everything, show me:
1. The full tree structure
2. My "daily driver" path — the 3 folders I’ll touch every single day
3. One sentence on how to use the Inbox daily
The Inbox is your most important habit — dump everything there first, organize it once a week
If Claude creates too many folders, say "simplify — only create folders I’ll actually use in the next 30 days"
3
Step 3 of 11 \u00b7 Auto Memory
Set up auto memory — what Claude remembers across sessions
5 min
Auto memory lets Claude write notes about what it learns in each session and read them back automatically next time. Without this, every session starts from zero. With it, Claude compounds knowledge about your work over time.
Claude stores a MEMORY.md (max 200 lines, loaded every session) plus topic files for deeper notes. The more sessions you have, the smarter Claude gets about your specific setup, patterns, and preferences.
MEMORY.md index created and structured
3 starter topic files (tools, patterns, decisions)
/memory command shown and tested
Auto memory enabled in settings
Paste into Claude Code
Read my CLAUDE.md and look at my folder structure.
Set up my auto memory system — the system that lets you remember things across sessions automatically.
Do the following:
1. Explain how auto memory works in 3 sentences (what gets saved, where, and when)
2. Create a starter MEMORY.md in the correct location (~/.claude/projects/[project]/memory/MEMORY.md)
The file must stay under 200 lines — this is a hard limit, Claude truncates after 200 lines
Structure: concise index at the top, links to topic files below
Pre-fill it with relevant context from my CLAUDE.md so it’s useful from day one
3. Create 3 starter topic files in the same memory directory:
- tools.md → my stack, how I use each tool, API keys locations, quirks to remember
- patterns.md → coding/workflow conventions I want you to follow consistently
- decisions.md → key decisions I’ve made and why (so you don’t re-litigate them)
4. Enable auto memory — check settings.json and ensure autoMemoryEnabled is true
5. Show me these exact commands:
- How to run /memory to browse loaded files
- How to tell you to remember something specific mid-session
- How to tell you to forget something or correct a wrong memory
After setup, save something useful from our conversation today into memory as a demonstration.
Run /memory at the start of new sessions to verify what’s loaded — you’ll see every file Claude has access to
If Claude remembers something wrong, just say "that’s incorrect — update your memory" and it will fix the file immediately
MEMORY.md has a 200-line hard limit. Claude should move detail to topic files and keep MEMORY.md as a concise index
PHASE 2 · INTELLIGENCE
Skills, rules, hooks, and settings
Layer on specialized workflows, safety guards, context-aware rules, and configuration. This is where Claude goes from "smart assistant" to "system that knows how I work."
4
Step 4 of 11 \u00b7 Skills
Build your skills — reusable slash commands
15–30 min
Skills are markdown files in .claude/skills/ that give Claude specialized workflows triggered by a slash command. Instead of re-explaining a task every time, you write the instructions once and call them forever.
Claude will suggest 5 skills ranked by impact for your specific work, build the highest-value one immediately, and give you the exact command to run it. Skills can also call other skills — this is how you build a real workflow library.
Paste into Claude Code
Read my CLAUDE.md, my folder structure, and my memory files.
I want to build a skills library — reusable workflows I trigger with a slash command.
Skills are markdown files saved in .claude/skills/. Each one:
- Has a YAML frontmatter block (name, description, tools it can use)
- Contains step-by-step instructions Claude follows every time it’s called
- Is invoked with /skill-name [optional arguments]
- Can call other skills, use MCPs, run bash commands, read/write files
First, suggest my 5 most valuable skills based on my work. For each one:
- Name and exact trigger command (/name)
- What it does in one sentence
- What inputs it needs from me (if any)
- What it produces as output
- Why it saves the most time for me specifically
Rank them by ROI — time saved × frequency of use.
Then build skill #1 — the highest-value one. Save it to .claude/skills/[name]/SKILL.md
Include in the skill file:
- Proper YAML frontmatter
- Clear step-by-step instructions
- How to handle edge cases
- Example of a real run with output
Show me how to run it with one real example from my current work.
Then ask: "Ready to build skill #2, or do you want to test this one first?"
Good starter skills: /weekly-review, /meeting-notes, /client-update, /research-brief, /content-draft
Add context: fork to the frontmatter to run a skill in an isolated subagent — prevents context pollution
Skills can reference other skills in their instructions — this is how you build compound workflows
5
Step 5 of 11 \u00b7 Path-Scoped Rules
Add path-scoped rules — context-aware instructions
10 min
Path-scoped rules are instructions that only activate when Claude is working with specific file types. Your TypeScript files get different rules than your documentation. Rules load exactly when needed — not all the time.
This is the precision layer. Instead of one giant CLAUDE.md trying to cover everything, you have targeted rules that fire at the right moment. Claude loads the testing rules when you open a test file. It loads the API rules when you open a route file.
Paste into Claude Code
Read my CLAUDE.md to understand my tech stack and the types of files I work with.
Set up path-scoped rules in .claude/rules/ — these are instruction files that only load when I’m working with matching file types.
How they work:
- Each rule file has YAML frontmatter with path glob patterns
- Claude loads the rule automatically when it reads a matching file
- Rules without path patterns load unconditionally (same as CLAUDE.md)
Create 4 rule files tailored to my stack:
1. A rule for my main code files (match my primary language: *.ts, *.py, *.js, etc.)
Include: code style preferences, naming conventions, patterns I want enforced, what to avoid
2. A rule for documentation and markdown files (*.md, *.mdx)
Include: writing style, structure preferences, how I name files, what format I expect
3. A rule for configuration and environment files (*.json, *.yaml, *.env.example, etc.)
Include: how I structure configs, secrets handling, what Claude should warn me about
4. A rule for test files (*.test.*, *.spec.*, tests/)
Include: testing patterns I follow, what good test coverage looks like for my codebase
For each rule file, show me:
- The YAML frontmatter with correct path globs
- 5–8 specific, concrete instructions (not vague ones like "write clean code")
After creating all rules, show me the frontmatter syntax so I can add my own rules later.
Rules without a paths: frontmatter field load unconditionally — same as putting them in CLAUDE.md
Symlink rule directories across projects: ln -s /shared/rules .claude/rules
User-level rules at ~/.claude/rules/ apply to every project you open — use these for personal preferences
6
Step 6 of 11 \u00b7 Hooks
Install hooks — safety, backup, logging, and notifications
10 min
Hooks are shell scripts that run automatically at specific moments — before a file is edited, after a command runs, when Claude finishes. They are your safety net. Once installed, they run silently in the background on every session.
These 5 hooks catch dangerous commands before they run, back up every file before it’s edited, log all changes, and notify you when Claude finishes a long task. You install them once and never think about them again.
bash-safety.sh — blocks destructive commands
file-backup.sh — backs up files before every edit
file-protection.sh — warns before editing sensitive files
file-logger.sh — logs all changes with timestamp
stop-notify.sh — sounds + notification on completion
Paste into Claude Code
Set up 5 safety and utility hooks for my Claude Code installation.
Create each as an executable shell script in ~/.claude/hooks/ and register all of them in ~/.claude/settings.json under the hooks array.
Hook 1: bash-safety.sh (event: PreToolUse/Bash)
Block these commands with a clear error message:
- git commit (prevent accidental commits — I commit manually)
- git push --force and git push -f
- git reset --hard
- git branch -D
- rm -rf / and rm -rf ~
- DROP TABLE and DROP DATABASE
Output: "🚫 Blocked: [command] — [reason why it’s dangerous]"
Hook 2: file-backup.sh (event: PreToolUse/Edit)
Before every file edit:
- Copy the original to ~/.claude/backups/[filename]-[YYYY-MM-DD-HH-MM-SS].bak
- Keep only the last 10 backups per filename (delete older ones automatically)
- Output: "📦 Backed up: [filepath]"
Hook 3: file-protection.sh (event: PreToolUse/Write + PreToolUse/Edit)
Warn (don’t block) when editing:
- .env files of any kind
- Files containing "secret", "credentials", "password", "token" in the name
- CLAUDE.md and settings.json
Output: "⚠️ Editing sensitive file: [filepath] — proceed carefully"
Hook 4: file-logger.sh (event: PostToolUse/Write + PostToolUse/Edit)
Log every change to ~/.claude/changes-YYYY-MM-DD.log
Format: [HH:MM:SS] [WRITE|EDIT] [filepath]
Hook 5: stop-notify.sh (event: Stop)
When Claude finishes any task:
- macOS: afplay /System/Library/Sounds/Glass.aiff
- Send macOS notification: title "Claude Code" body "Task complete"
Use: osascript -e 'display notification "Task complete" with title "Claude Code"'
After creating all scripts:
1. Run chmod +x on all of them
2. Update ~/.claude/settings.json with all 5 hooks registered
3. Show me the final settings.json hooks array
4. Tell me how to test that hooks are working
A non-zero exit code from a PreToolUse hook cancels the operation — this is how bash-safety.sh blocks commands
To test: ask Claude to run git commit -m "test" — you should see the block message immediately
On Linux, replace afplay with paplay and osascript with notify-send
7
Step 7 of 11 \u00b7 Settings
Configure settings.json — the control panel
5 min
settings.json is the master configuration file for your Claude Code installation. It controls your default model, permission mode, status line, fast mode toggle, all your hooks, and more. One file that governs everything.
After this step you have a fully configured installation. Your status line shows real-time cost, model, branch, and token usage. Permission mode is set so Claude auto-approves file changes but always asks before running commands.
Paste into Claude Code
Read my CLAUDE.md to understand my preferences. Check if ~/.claude/settings.json already exists.
Set up (or update) my ~/.claude/settings.json with a complete configuration. Build a real file, not a template.
Include these sections:
1. Model
- Default: claude-sonnet-4-5 (good balance of speed and quality)
- Add a comment showing how to switch to opus for complex tasks
2. Permission Mode
- "acceptEdits" — auto-approve file reads and edits, always ask before running bash commands
- Explain why this is the right default for daily work
3. Auto Memory
- autoMemoryEnabled: true
- Ensure it’s pointing to the correct memory directory
4. Status Line
Configure to show on every session:
- Current model name
- Session cost (running total in $)
- Token usage (input ↑ output ↓)
- Cache hit % (saves money when high)
- Current git branch
- Session duration
5. Hooks
- Register all hooks from ~/.claude/hooks/ (from Step 6)
- Use absolute paths for all scripts
6. Fast Mode
- Add fastMode: false with a comment explaining when to enable it
(enable for simple tasks to reduce cost, disable for complex reasoning)
7. Useful extras
- maxTurns: 20 (prevents runaway sessions)
- verboseLogging: false (clean output)
After writing the file:
- Explain each setting in plain language (one sentence each)
- Show me the 3 most common things I’d change in this file day-to-day
- Tell me how to switch models mid-session without editing the file
Settings hierarchy: managed policy → project → user (~/.claude) → local → CLI flags. Later always wins
Add alwaysThinkingEnabled: true to get extended reasoning on every response — see Claude’s actual decision process
Add autoUpdatesChannel: "latest" — Claude Code ships multiple updates per week, you want them
Environment override: CLAUDE_MODEL=claude-opus-4 claude — useful for one-off high-stakes tasks without editing the file
PHASE 3 · POWER
Connect tools, automate workflows, unlock advanced modes
MCPs connect Claude to your external tools. /loop runs tasks while you work. Persistent scheduling runs tasks while you sleep. Plan mode and worktrees handle complex, parallel, high-stakes work.
8
Step 8 of 11 \u00b7 MCPs
Install MCPs — connect Claude to your tools
20–30 min
MCPs (Model Context Protocol servers) are plugins that give Claude read and write access to external services. Without MCPs, Claude only sees files on your computer. With them, Claude can act inside Slack, Notion, GitHub, your CRM, your database.
This is the integration layer. Even one MCP changes how you work. Claude reads your toolstack from CLAUDE.md and recommends the MCPs with the highest ROI for your specific setup — then installs the best one step by step.
Paste into Claude Code
Read my CLAUDE.md carefully — especially my tools, integrations, and daily workflow.
I want to connect Claude Code to my external tools using MCP servers.
First, explain what MCPs do in exactly 2 sentences.
Then review my toolstack and recommend the 5 most valuable MCPs for my specific setup.
Choose from this list based on what I actually use:
- filesystem → read/write any file on my computer (always useful)
- github → repos, PRs, issues, branches, commits
- slack → read channels, send messages, search history
- notion → read/write pages, query databases
- google-workspace → gmail, calendar, drive, docs
- linear / jira → issues, projects, roadmap
- postgres / sqlite → query databases directly
- attio / hubspot → CRM records, pipeline, contacts
- brave-search → web search and page scraping
- puppeteer → browser automation, scraping
For each recommended MCP:
- What you can do with it that you can’t do without it (be specific to my work)
- The exact install command
- One concrete example using my actual workflow
Then pick the single most impactful MCP and install it step by step:
1. Run the install command
2. Add the configuration to .claude/settings.json (with any required env variables)
3. Test it works with a real command from my workflow
4. Show me the 3 most useful things I can now do
After the first MCP is installed and tested, ask: "Want to install MCP #2?"
Start with 1–2 MCPs. Adding too many creates noise — you’ll stop using most of them
API keys for MCPs usually live in each tool’s settings under Developer / API / Integrations
MCPs can be scoped per-project in .claude/settings.json or globally in ~/.claude/settings.json
9
Step 9 of 11 \u00b7 /loop
Set up /loop automations — run tasks while you work
5 min
/loop is a built-in command that makes Claude run a task automatically on a timer, between your turns, without interrupting you. Session-scoped — runs while your terminal is open. One command and Claude works in the background while you do something else.
Claude reads your entire setup — CLAUDE.md, skills, MCPs, active projects — and generates /loop commands customized to your actual work. Not generic examples. Your real skills, your real tools, your real workflow.
Paste into Claude Code
Read my CLAUDE.md, browse my .claude/skills/ folder, check what MCPs I have installed, and look at my active projects folder.
I want to set up /loop automations — tasks that run automatically in the background while I keep working.
/loop syntax (already built into Claude Code, nothing to install):
/loop 5m [what to check] → fires every 5 minutes
/loop 20m [what to check] → fires every 20 minutes
/loop 1h [what to check] → fires every hour
/loop 20m /my-skill → runs an entire skill every 20 minutes
/loop 2h /my-skill arg → runs skill with argument every 2 hours
"remind me at 3pm to [task]" → one-time, fires once, then deletes itself
Based on my specific setup — my actual skills, my actual tools, my actual projects — suggest:
5 recurring loops that would make my work sessions more productive:
- The exact command (copy-paste ready, no editing needed)
- What it does in one sentence
- Why that specific interval (not too frequent, not too slow)
- What I should do when it fires (act on it / review it / just read it)
2 one-time reminder patterns I’d use regularly:
- When I’d type them (before a focused work block, before a meeting, etc.)
- The exact syntax
After the list:
- Start the most useful loop right now
- Stay active in the session
- Report back when it first fires and show me what the output looks like
Power move: /loop 20m /review-pr 1234 — runs your full PR review skill every 20 min, not just a status ping
/loop actually runs for up to 3 days — not just your session. It survives as long as your terminal stays open
Run multiple loops in different tmux panes using agent teams — each loop runs a separate agent independently
For tasks that need to truly run overnight (terminal closed) → Step 10 persistent scheduling
10
Step 10 of 11 \u00b7 Persistent Scheduling
Persistent scheduling — run tasks while you sleep
15 min
/loop stops when you close the terminal. Persistent scheduling uses your OS scheduler (launchd on Mac, cron on Linux) to run Claude Code tasks at specific times — daily briefings, weekly reviews, overnight research — completely automatically.
This is the overnight layer. Set it up once and wake up to a morning briefing every day. Your weekly review runs itself on Friday afternoon. Long-running tasks happen when you’re not around.
Paste into Claude Code
Read my CLAUDE.md and my .claude/skills/ folder.
I want to set up persistent scheduled tasks — Claude Code automations that run automatically even when my terminal is closed, using launchd (macOS) or cron (Linux).
First, explain the difference between /loop (session-scoped) and persistent scheduling (OS-level) in 3 sentences.
Then set up 3 persistent tasks based on my work:
Task 1: Daily morning briefing
- Runs every day at 8:00 AM
- Claude reads my active projects folder, checks for any notes added yesterday, summarizes what needs attention today
- Output saved to 00_Inbox/morning-briefing-[date].md
Task 2: Weekly review
- Runs every Friday at 5:00 PM
- Claude reads my 01_Projects/ folder, reads all Progress.md files, generates a weekly summary with wins, blockers, and next week priorities
- Output saved to 02_Areas/Operations/Weekly/week-[date].md
Task 3: One task specific to MY work
- Based on my CLAUDE.md and active projects, suggest the best candidate
- Show me why this one makes sense for my workflow
For each task, create:
- The shell script that runs the claude command (in headless mode)
- The launchd .plist file (macOS) or crontab entry (Linux)
- Instructions to install it (launchctl load, or crontab -e)
After setup, show me:
- How to list all scheduled tasks currently installed
- How to pause a task without deleting it
- Where the logs are stored
- How to manually trigger a task to test it
launchd plist files go in ~/Library/LaunchAgents/ — load with launchctl load ~/Library/LaunchAgents/your.plist
Set ANTHROPIC_API_KEY in the plist environment variables — it won’t inherit your shell environment
Test by setting the schedule to 1 minute from now, check the log, then update to the real schedule
11
Step 11 of 11 \u00b7 Advanced Modes
Plan mode + worktrees — advanced session control
10 min
Plan mode makes Claude propose the full plan before executing anything — you review once, it runs autonomously. Worktrees give you isolated branches with separate Claude sessions so you can work on multiple features in parallel without any context mixing.
Use plan mode for any task that touches 3+ files or has 3+ sequential steps. Use worktrees when you need to switch between features without carrying over context. Together they handle 90% of complex, high-stakes work.
Paste into Claude Code
Teach me two advanced Claude Code features: Plan Mode and Worktrees. Use my actual work as examples.
── PLAN MODE ─────────────────────────────────────────────────
1. Explain what Plan Mode does in exactly 2 sentences
2. Show me how to enable it:
- The CLI flag: claude --permission-mode plan
- The settings.json option
- How to enable it for a single session vs permanently
3. Walk me through exactly when to use it (and when NOT to use it):
Use it: tasks affecting 3+ files, complex multi-step operations, production changes, batch operations
Don’t use it: single file edits, quick questions, low-risk changes
4. Pick a real task from my active projects (from my CLAUDE.md or 01_Projects/) and run it in Plan Mode right now:
- Start the plan
- Show me the full plan it generates
- Wait for my approval before executing
- Explain each step as it runs
── WORKTREES ─────────────────────────────────────────────────
5. Explain what worktrees do in exactly 2 sentences
6. Show me the exact command to create one:
claude --worktree feature-name
7. Explain when I’d want a worktree vs a regular session:
Use worktree: working on multiple features simultaneously, don’t want context to bleed between tasks
Don’t use worktree: single feature, linear work, quick iterations
8. Create a worktree for a current real project or feature from my CLAUDE.md
── COMBINATION ───────────────────────────────────────────────
9. Show me the workflow that combines both:
"When would I open a worktree AND use plan mode inside it?"
Give me a real example from my work with the exact commands to run
Always start complex tasks with plan mode — ask Claude to interview you first with AskUserQuestion before writing any code
Worktrees each have their own CLAUDE.local.md and auto memory — context is fully isolated between them
Add ultrathink to your prompt for maximum reasoning on high-stakes tasks: "ultrathink — refactor this auth system"
Esc Esc or /rewind to undo when Claude goes off-track — never try to fix a bad path in the same context
PRO PLAYBOOK
Best practices from the field
Patterns from Boris Cherny (creator of Claude Code), the Claude team, and the community. Use these from day one.
Commands vs Agents vs Skills \u2014 when to use which
| Use | When | Lives in | Invoke with |
|---|---|---|---|
| /command | Entry-point workflow you trigger yourself. User-facing. Multi-step orchestration. | .claude/commands/name.md | /name |
| agent | Feature-specific specialist that needs its own tools, model, or permissions. Preload with skills. | .claude/agents/name.md | Auto or via Agent() tool |
| skill | Reusable procedure or domain knowledge. Can be standalone (/invoke) or preloaded into an agent. | .claude/skills/name/SKILL.md | /name or via Skill() tool |
| vanilla Claude | Small tasks, quick edits, single-file changes. No setup needed. Fastest path. | \u2014 | just type |
Rule: use commands for workflows, agents for specialists, skills for reusable knowledge. Vanilla Claude Code beats complex setups for small tasks.
Context Management
Run
/compact manually at ~50% context usage. Use /clear when switching tasks. Esc Esc or /rewind to undo when Claude goes off-track. Keep CLAUDE.md under 200 lines. /rename important sessions then /resume them later.Session and Model
/model to switch mid-session. /usage to check limits. /cost for session spend. /doctor to diagnose issues. Add ultrathink to any prompt for extended reasoning on complex tasks.MCP Starter Pack
Context7 \u2014 fetches live library docs. Playwright \u2014 browser automation. DeepWiki \u2014 structured docs for any GitHub repo. Filesystem \u2014 read/write any file. Start with 2 MCPs max. More = noise.
Advanced Automations
/loop runs for up to 3 days. Agent teams + tmux for parallel work. claude --worktree feature-name for isolated branches. /remote to continue from phone. /voice for speech-to-prompt.From Boris Cherny (Claude Code creator)
Always start with plan mode. Ask Claude to interview you first using AskUserQuestion tool. Make phase-wise gated plans with tests at each gate. Commit at least once per hour. Use cross-model QA: build with Claude, review plan with another model. Use
/permissions with wildcard syntax. Follow the changelog daily.Bonus prompt \u2014 get Claude to design your full architecture
Paste into Claude Code
Read my CLAUDE.md, my .claude/ folder (commands, agents, skills, rules, hooks), and my active projects.
I want you to audit my current setup and design the optimal Claude Code architecture for my work.
Analyze and answer:
1. Commands vs Agents vs Skills
- Which of my recurring tasks should be commands (entry-point workflows)?
- Which warrant a specialist agent with preloaded skills?
- Which are best as standalone skills invoked on-demand?
- What should stay as vanilla Claude Code (no setup needed)?
2. Context management
- How much context am I likely burning per session with my current setup?
- Where should I add /compact triggers in my workflows?
- Which CLAUDE.md sections could be moved to @imports to save context?
3. Automation stack
- Which tasks should be /loop (session-scoped)?
- Which should be persistent launchd/cron (overnight/daily)?
- Is there anything that qualifies for a long-running autonomous loop?
4. MCP gaps
- Based on my tools and workflows, which MCPs am I missing that would have the highest ROI?
- Which of my current MCPs am I probably underusing?
5. Priority order
- Give me a concrete list of the 5 highest-leverage changes I should make this week
- For each: what to build, why it matters, how long it takes
Be specific. Reference my actual projects and tools from CLAUDE.md. Not generic advice.