You've Had Your Personal OS for a Few Weeks. Now What?
You set up the folders. You ran /today a few times. You created a project or two. It works—but it probably still feels like a fancy filing cabinet.
This guide covers the features that transform a Personal OS from "organized folder" into a genuine work partner. Every technique here comes from real usage patterns—weeks of daily work where Claude handles meeting prep, builds presentations, tracks contacts, writes in your voice, and remembers decisions from three weeks ago.
The audience for this guide is the same as the first: tourism marketing professionals (and anyone in a similar role) who use Claude as a productivity tool. You already have the basics. This is about depth.
Week 1 vs. Week 3: What Changes
The biggest shift is moving from telling Claude what to do to Claude already knowing what to do. Here's what that looks like in practice:
Week 1
- You explain your job and context each session
- Two slash commands:
/todayand/log - CLAUDE.md has basic role and architecture
- Projects are folders with files
- You manually describe your writing style
Week 3+
- Claude knows your role, team, current projects, and preferences
- 8+ slash commands for calls, keynotes, reviews, presentations
- CLAUDE.md has task schemas, call schemas, people directory rules, deployment checklists
- Projects have process notes, spec files, and auto-populated contacts
- A writing profile teaches Claude your exact voice
Optimize Your CLAUDE.md
Your project-level CLAUDE.md probably started with a role description and basic guidelines. Here's how to evolve it into a genuinely useful operating manual.
Add a Task Schema
When Claude creates tasks, it needs a consistent format. Define the schema once, and every task Claude creates will be scannable by /today:
## Task Schema (Required) ```yaml type: task status: [todo, in-progress, done, waiting] created: YYYY-MM-DD due_date: YYYY-MM-DD priority: [high, medium, low] tags: [] ``` Default `tags` to empty list `[]` if none provided.
/today misses tasks because it's looking for due_date and Claude used deadline instead. Consistency here saves you from silent failures.
Add Action Rules
The most useful additions to your CLAUDE.md are behavioral rules you discover through friction. Here are real examples that solve real annoyances:
## General Rules When I ask you to fix or change something, ALWAYS make the actual edit to the file. Apply the change directly. Before creating any new files or project structures, always ask me: 'Should this be (1) local to your vault, (2) shared via GitHub, or (3) deployed to a website?' Then set up accordingly. ## Content Creation When creating content intended for external audiences (partners, clients, industry contacts), always ask 'Is this internal or external?' if unclear. ## Data & Reports Never fabricate or extrapolate data. If I provide 3 months of data, do NOT create year-over-year comparisons. Always flag when source data is insufficient.
How to Discover Your Own Rules
Every time Claude does something that makes you pause—explains instead of editing, creates a file in the wrong place, invents data you didn't provide—write a rule for it. Within two weeks, you'll have a set of instructions that eliminate 90% of the friction.
Add Professional Context
One line at the bottom of your CLAUDE.md that tells Claude who you are saves you from re-explaining your role in every session:
## User Professional Context
[Your name] is [your title] at [your organization].
[One sentence of relevant career history that shapes
your perspective.]
This line flows into every interaction. When Claude drafts an email, it knows your title. When it prepares talking points, it knows your background.
The Global CLAUDE.md: Your Second Brain
Here's something the first guide mentioned briefly but deserves its own section: Claude reads two CLAUDE.md files. Your project-level file (in your Personal OS folder) and a global file at ~/.claude/CLAUDE.md that applies everywhere—across all projects, all folders, all sessions.
~/.claude/CLAUDE.md (the ~ means your home directory). You can edit it by asking Claude: "Edit my global CLAUDE.md file."
What Goes Global vs. What Stays in the Project?
| Global (~/.claude/CLAUDE.md) | Project (Personal_OS/CLAUDE.md) |
|---|---|
| Writing style rules that apply everywhere | Folder architecture and file locations |
| Communication tone preferences | Task schemas and frontmatter formats |
| Tool-specific instructions (how to restart Claude Code, etc.) | Call note schemas and People directory rules |
| "Read files before asking for context" | Project-specific context and deployment instructions |
| Environment details (Claude Code vs. Claude Desktop) | Brand resources and design asset locations |
Real Example: Writing Style as a Global Rule
If you have a strong writing style preference—say you prefer direct positive statements over negative constructions—put it in your global file so it applies to everything Claude writes, in any project:
## Writing Style State what things ARE. Use direct positive statements. ## Communication Guardrails When drafting communications for internal audiences, keep AI framing practical and grounded. Focus on specific tools and wins. Flag if a draft leans too heavy on sweeping transformation language.
The Memory System
Claude Code has a built-in memory feature that most users overlook. When you use the /remember command (or when Claude learns something important about your workflow), it stores notes in a memory file that persists across sessions.
Where Memory Lives
Memory files are stored at: ~/.claude/projects/[project-path]/memory/MEMORY.md
Claude reads this file automatically at the start of every session. It's where Claude stores things like:
- Project index: What you're building, where it lives, and how to deploy it
- Workflow patterns: Conference capture workflows, call note habits, deployment checklists
- Hard-won lessons: "Browser automation fails for diverse sites," "macOS grep works differently than Linux grep"
- Current state: "ComplianceTrack Phase 3 complete, service worker cache at v5"
REAL MEMORY EXAMPLE # Memory ## Project Index - NutriSnap — Personal calorie/macro tracking PWA. Source in Apps/NutriSnap/, deployed to GitHub Pages. - DMO Newsletter Tracker — Subscribe to ~600 US DMO newsletters. Master CSV in 10_Projects/DMO_Newsletter_Tracker/ - ComplianceTrack — ATS PWA for compliance recruiting. Phase 3 complete. SW cache at v5. ## Automation Lessons - Browser automation fails for diverse sites. agent-browser CLI across 600+ different websites produced 0% real success across 3 iterations. - Rule of thumb: If a task involves >50 different websites you don't control, skip automation and optimize the manual workflow instead.
Feeding the Memory
You can explicitly tell Claude to remember something: "Remember that the ComplianceTrack service worker is at cache v5." Or use /remember at the end of a session to let Claude review what it learned and update the memory file automatically.
Memory vs. Process Notes: What Goes Where?
| Memory (MEMORY.md) | Process Notes (process_notes.md) |
|---|---|
| Cross-session facts: project locations, deploy URLs, version numbers | Session-by-session history: what changed, what was decided |
| Lessons learned that apply going forward | Chronological log of work done |
| Claude reads this automatically every session | Claude reads this when working in that specific project |
| Short, factual, current-state | Detailed, narrative, historical |
Build a People Directory
This is one of the highest-value additions you can make to your Personal OS. A People directory in 20_Areas/People/ gives Claude a relationship memory that carries across sessions.
How It Works
Create a template file and tell Claude (in your CLAUDE.md) to auto-populate contacts from call notes:
## People Directory Contact profiles live in `20_Areas/People/`. Auto-populated from Calls. ### Individuals - Template: `_template_person.md` - Schema: type: person, name, company, role, relationship, first_contact, last_contact, tags - Relationship tags: #client, #colleague, #partner, #vendor, #stakeholder ### Auto-population Rules 1. When creating a call note, check if person exists 2. If not, create from template with available context 3. If exists, update `last_contact` and append to history 4. Extract and preserve: personal details mentioned, commitments made, open questions
The Person Template
--- type: person name: company: role: relationship: # client | colleague | partner | vendor first_contact: last_contact: tags: [] --- ## Context <!-- Role, how you met, what they care about --> ## Relationship History <!-- Key interactions, auto-updated from Calls --> ## Personal Details <!-- Family, interests, preferences --> ## Open Items <!-- Commitments made, questions to follow up on -->
What This Looks Like in Practice
After a few weeks, you have a contact file that reads like this:
REAL CONTACT EXAMPLE --- type: person name: Kyle Hudson company: Stack (StackList) role: Founder relationship: partner first_contact: 2026-01-28 last_contact: 2026-02-02 tags: [partner, AI, structured-data] --- ## Context Founder of Stack/StackList - browser extension for saving "cards" into shareable collections. Key value: content is highly discoverable by AI due to atomic structure and auto-generated metadata. ## Relationship History - 2026-01-28: Intro call. Discussed B2B use case, analytics, AI discoverability features. - 2026-02-02: Demo walkthrough. Saw AI Discoverability button (generates FAQ data, structured metadata, regenerates every 2 weeks). ## Open Items - [ ] Play around with StackList extension - [ ] Research FAQ schema for AI discoverability - [ ] Follow up end of February
The Payoff
Before your next call with this person, tell Claude: "I have a call with Kyle Hudson tomorrow. Prep me." Claude reads the contact file, pulls the relationship history, surfaces the open items, and gives you a brief with everything you need—automatically.
Groups Too
For recurring team meetings or external working groups, create a group template. Same auto-population rules apply. This is especially useful for standing meetings where you want Claude to track themes, decisions, and action items across weeks.
Call Notes & Meeting Capture
The /call command is one of the most-used skills in a mature Personal OS. It creates structured call notes that feed into the People directory and can be referenced in future sessions.
The Call Schema
Add this to your CLAUDE.md so every call note follows the same format:
## Calls & Meeting Notes Call transcripts live in `20_Areas/Calls/`. Use `/call` to create or update notes. - Naming: `YYYY-MM-DD_Contact-Name.md` - Schema: type: call, contact, company, date, tags, follow_up - Before follow-up calls, search this folder by contact name to surface prior context
Dictation Mode
The real power is dictation. Add this instruction to your CLAUDE.md:
### Call Notes / Dictation
When I dictate call notes or meeting content, capture
everything immediately into a markdown file without
asking clarifying questions. Append incrementally
as I continue talking.
This means you can talk to Claude during or right after a meeting—"Just had a call with the tech team, here's what happened..."—and Claude creates a properly formatted, searchable call note instantly. No forms, no prompts, no friction.
Call Prep Is Where It Gets Good
Say "Prep me for my call with [name] tomorrow." Claude searches 20_Areas/Calls/ for past notes with that contact, reads their People directory entry, pulls open items, and gives you a brief. Two weeks of captured call notes creates a powerful relationship memory.
Profiles: Teaching Claude Your Voice
Your 99_System/Profiles/ folder is where you store personality instructions that Claude loads on demand. The most immediately useful one is a writing profile.
Why a Writing Profile Matters
Without one, Claude writes in Generic Professional. With one, Claude writes in your voice—with your rhythm, your word choices, your structure preferences, and even your banned phrases.
What a Real Writing Profile Contains
WRITING PROFILE EXAMPLE # Writing Profile ## Voice in One Line Pragmatic builder-teacher who makes AI feel usable, ethical, and a little fun—anchored in specifics, curiosity, and lived experimentation. ## Core Qualities - Practical evangelist: Build, test, translate. Real examples always. - Approachable expert: Intelligence through clarity, not terminology. - Warm but direct: Collegial without saccharine. ## Structure Pattern Most pieces follow: Hook → Context → Translation → Examples → Caveat → CTA ## Style Mechanics - Em dashes as primary transition tool—heavy user - Short paragraphs with whitespace - No semicolons. Parentheses for quick clarifications. - Exclamation points used genuinely—1-2 per email max ## Banned Never use: "revolutionary," "game-changing," "paradigm shift," "stakeholders," "leverage," "synergy," "circle back," "low-hanging fruit," "Dear," "Sincerely," "I hope this email finds you well" ## Quick Test Before finishing: Would this sound natural if read aloud by me on stage? Does it teach or demo something usable? Is there at least one specific example?
How to Use It
Tell Claude: "Load writing mode" or "Use my writing profile." Claude reads 99_System/Profiles/writing_profile.md and adjusts its output accordingly. The key instruction in your CLAUDE.md is:
## Context & Profiles Load only when explicitly requested: - "Writing Mode" → `Profiles/writing_profile.md` - "Coding Mode" → `Profiles/coding_profile.md` Do NOT preload profiles based on inferred task type.
Building Your Writing Profile
The easiest way to build one from scratch:
Copy and paste this into Claude:
I want to create a writing profile so you can match my voice. Here are 3 examples of things I've written recently: [Paste 3 emails, LinkedIn posts, or other writing samples] Analyze these for: voice, structure patterns, word choices I favor, phrases I use, things I avoid, punctuation habits, and paragraph length. Create a writing_profile.md in 99_System/Profiles/ based on what you find.
A Coding Profile Too
If you work with code (even occasionally, as a non-developer using AI tools to build things), a coding profile tells Claude your skill level and preferred explanations:
CODING PROFILE EXAMPLE # Coding Profile ## The Essential Truth I'm an AI-fluent executive who occasionally needs to touch code. My goal is to be a capable user of AI coding tools. ## What This Means for Claude - Explain what commands do before I run them - Explain why we're doing each step - When something breaks, help me understand the error before jumping to fixes - Incremental wins—small working steps over big leaps that might break
The Context Library
Your 99_System/Context_Library/ is the reference shelf. It holds index files and detailed specs that Claude loads when you're working on specific topics.
The Structure
99_System/Context_Library/ │ ├── business_profile.md # Index of work context ├── personal_profile.md # Index of personal context │ ├── project_specs/ # Detailed project briefs │ ├── keynote_spec.md │ ├── social_automation.md │ └── research_hub.md │ └── personal_specs/ # Personal project briefs └── home_office.md
Business Profile: Your Work Index
The business profile is a single file that lists your role, your organization, your active projects (with links to their spec files), and the tools you use. Claude reads this when you say "load business context" and immediately knows what you're working on:
# Business Profile ## Current Role [Your name] - [Title] at [Organization] ## Organization [One-paragraph description of what your org does] ## Active Projects Load the relevant spec from `Context_Library/project_specs/` when working on these: | Project | Spec File | Status | |-------------------|------------------------|------------| | Keynote Prep | keynote_spec.md | Active | | Social Automation | social_automation.md | Active | | Research Hub | research_hub.md | Long-term | ## Tools & Systems - [Project management tool] - [CRM] - [Social media platform]
Project Specs: Deep Context on Demand
Each project spec is a detailed brief that Claude loads when you're actively working on that project. A keynote spec might include the event date, audience size, audience demographics, approved title and description, key themes, and research to incorporate.
Slash Commands Beyond /today and /log
The original guide covered /today and /log. A mature Personal OS has 8-10+ slash commands, each built for a specific workflow. Here's the full toolkit:
| Command | What It Does |
|---|---|
/today |
Scan vault for tasks due today, create daily agenda |
/log |
Append session summary to project's process_notes.md |
/call |
Create or update a call note, auto-populate People directory |
/remember |
Review session learnings, update memory files |
/review |
Generate weekly/monthly summaries of accomplishments, calls, and open items |
/keynote-writer |
Generate keynote content from call notes and past presentations |
/text-to-html |
Convert plain text into email-safe inline HTML formatting |
/brand-usa-pptx |
Create branded presentations from ideas to polished PPTX |
/insights |
Analyze your last 30 days of chat sessions and generate an interactive HTML report (built into Claude Code) |
The /insights Command: Your Monthly Reality Check
/insights is built directly into Claude Code—you already have it. It analyzes your last 30 days of local chat sessions and generates an interactive HTML report showing how you actually use AI: which tools you rely on, what types of tasks dominate your sessions, and where you spend the most time.
This is powerful for Personal OS users because it reveals patterns you can act on. If you discover that 40% of your sessions involve call prep, that's a signal to invest in a richer /callprep skill. If you see repetitive tasks that could be automated, that's your cue to build a new slash command. Run /insights once a month to see how your system is actually performing versus how you think it's performing.
Building Your Own Slash Commands
Every slash command is a SKILL.md file in ~/.claude/skills/[name]/. The format:
--- name: call description: Create or update a call note allowed-tools: Glob(*), Read(*), Write(*), Edit(*) --- # /call - Meeting Note Creator Create a call note in 20_Areas/Calls/. ## What to Do 1. Ask for the contact name and date (default today) 2. Check if person/group exists in People/ 3. Create call note with proper schema 4. Update the People directory entry 5. Surface any prior notes with this contact
Create a new slash command:
Create a new slash command called /[name] that [description of what it should do]. Save it to ~/.claude/skills/[name]/SKILL.md with the proper frontmatter format.
The /review Command: Surprisingly Useful
Set up /review to scan your past week of call notes, process notes, and completed tasks, then generate a summary. This is invaluable for weekly reports, status updates, or prepping for a manager check-in. One command replaces 30 minutes of manual summary work.
Real Project Patterns
After a few weeks, your projects develop a consistent internal structure. Here's the evolved pattern:
10_Projects/ │ ├── Wyoming_Keynote/ │ ├── call_notes.md # Planning call context │ └── process_notes.md # Session-by-session log │ ├── ComplianceTrack/ │ ├── process_notes.md # Detailed build log │ ├── docs/ │ │ └── plans/ # Architecture plans │ ├── css/ │ ├── js/ │ └── index.html │ └── Social_Boosting_Automation/ └── process_notes.md
Process Notes: The Real Secret Weapon
Process notes are where the compounding value lives. Every session logged with /log adds context that Claude can reference later. After 5-10 entries, Claude can:
- Pick up exactly where you left off, even after a week away
- Reference decisions made in earlier sessions ("We decided to use CSS Grid over Flexbox because...")
- Surface open items that haven't been addressed yet
- Avoid repeating mistakes documented in earlier sessions
REAL PROCESS NOTES EXAMPLE ## 2026-02-13 - Phase 1 Build, Review, Deploy Summary: Built complete Phase 1 (Candidates MVP) from plan through two review cycles. Deployed to GitHub Pages. Decisions: - Vanilla HTML/CSS/JS with ES modules: zero build tools, zero dependencies beyond PapaParse for CSV - IndexedDB for all storage: offline-first Notes: - Two full review passes caught 14 total issues - Lesson: be careful with replace_all on function calls that share a name with definitions
Keynote Workflow: A Full-Lifecycle Example
Here's how a mature Personal OS handles a real workflow end-to-end:
Keynote Preparation Lifecycle
Planning Call
Use /call to capture the planning call. Claude creates the note, populates the contact in People/, and flags follow-up items.
Project Spec
Create a spec in Context_Library/project_specs/ with audience, event details, themes, and deliverable checklist.
Content Development
Load writing profile + project spec. Use /keynote-writer to draft. Claude pulls from your archived keynotes and common talking points library.
Deck Creation
Use /brand-usa-pptx (or your equivalent) to generate a branded presentation file from the draft content.
Post-Event Archive
Export the final presentation as PDF. Create a markdown summary capturing stories that landed, data points that resonated, audience questions, and what you'd change.
The Compounding Effect
Each keynote you archive makes the next one easier. By your fourth or fifth archived presentation, Claude has a library of your proven stories, audience-tested data points, and structure patterns that it can adapt to any new audience.
MCP Servers: Claude's App Store
MCP (Model Context Protocol) servers extend Claude's capabilities by connecting it to external tools and data sources. Think of them as apps that give Claude new abilities.
What MCP Servers Can Do
Project Management
Connect to Wrike, Asana, or similar tools. Claude can read tasks, update statuses, and sync deadlines with your /today agenda.
Web & Research
Fetch live web content, access Google Maps data, or search specialized databases—all from within Claude.
File Systems
Access files on your Desktop or Downloads folder. Useful for processing reports or attachments without moving them to your vault.
Domain-Specific Tools
Connect to budget tools (YNAB), health trackers (Whoop), or industry-specific APIs for your organization's data.
Where MCP Servers Live
MCP servers are configured differently depending on which Claude environment you use:
| Claude Desktop | Claude Code (VS Code) |
|---|---|
Config at: ~/Library/Application Support/Claude/claude_desktop_config.json |
Config at: .claude/settings.local.json in your project |
| Supports many MCP servers | Typically fewer servers needed (focused on file work) |
| Great for research, data analysis, browsing | Great for file editing, coding, vault management |
Start With One
The most useful first MCP server for most people is fetch—it lets Claude retrieve web content. If you use a project management tool like Wrike or Asana, adding that server is a high-value second step. Ask Claude: "Help me set up the [tool name] MCP server."
Add an Environment Note to Your CLAUDE.md
Since you might use both Claude Desktop and Claude Code, add this to your CLAUDE.md:
## Environment
I work across two environments: Claude Code (terminal)
AND Claude Desktop. When editing MCP configs or
settings, always ask which environment I mean,
or apply to both.
Writing Rules & Guardrails
Beyond the writing profile (which captures your voice), you can add specific rules that prevent Claude from producing content you'd have to heavily edit.
Communication Guardrails
If you work in an industry where AI hype language is common, add guardrails:
## Communication Guardrails
When drafting communications or presentations for
internal audiences, keep AI framing practical and
grounded. Focus on specific tools and wins.
Flag if a draft leans too heavy on
"AI is changing everything" messaging.
Internal vs. External Content Rules
This one catches a lot of people off guard. Claude can easily mix internal language (testing frameworks, reauthorization processes, internal tool names) into content meant for external audiences:
## Content Creation
When creating content intended for external audiences
(partners, clients, industry contacts), always ask
'Is this internal or external?' if unclear.
Hard-Won Lessons
These come directly from weeks of daily usage. Each one represents a real problem that took time to diagnose.
Context Window Management
Claude can only hold so much information at once. If you load your writing profile, coding profile, three project specs, and a full contact database at the start of every session, Claude has very little room left for the actual work. Load profiles and specs on demand, and tell Claude explicitly in your CLAUDE.md to avoid preloading.
Data Hallucination
Claude will cheerfully create year-over-year comparisons from three months of data if you let it. Add an explicit "Never fabricate or extrapolate data" rule to your CLAUDE.md. This is especially important if you work with reports, analytics, or financial data.
Automation Has Limits
If a task involves interacting with 50+ different websites you do not control (filling out forms, clicking through diverse UIs), browser automation will fail. The better approach: have Claude build you a manual workflow tool (like an HTML checklist with copy-paste prefills) that optimizes the human steps instead.
Deployment Verification
When asking Claude to deploy code to GitHub Pages, Vercel, or similar: always verify the repo exists, the build command works locally first, and confirm the deployment URL after push. Add this as a rule in your CLAUDE.md. Claude will assume deployment succeeded unless you tell it to check.
Skills vs. Legacy Commands
Claude Code has two systems: skills (in ~/.claude/skills/) and commands (in .claude/commands/ inside your project). Only skills work as invocable slash commands. If you created command files in your project folder and they don't trigger when you type the slash command, move them to skills.
PDF Processing
Claude can read PDFs, but comparing multiple PDF reports works much better if you convert them to markdown first. Add a PDF processing rule to your CLAUDE.md with the conversion command, so Claude handles this automatically before starting any analysis.
The Weekly Review
A mature Personal OS benefits from a weekly maintenance cycle. This takes about 15 minutes and keeps everything running smoothly.
Weekly Review Workflow
Run /review
Get a summary of completed tasks, call notes from the week, and open items.
Check Open Items
Review People directory entries for any follow-ups that are due. Scan call notes for action items you committed to.
Archive Completed Projects
Move anything finished to 40_Archives/. Keep your 10_Projects/ folder lean—only active work lives there.
Update Memory
Run /remember to let Claude update its memory with anything from the past week that matters going forward.
Update Business Profile
If project statuses changed (completed, paused, new ones started), update the active projects table in your business profile.
Weekly review prompt:
Run /review for this past week. Then check 20_Areas/People/ for any contacts where follow_up is true and last_contact was more than 2 weeks ago. List anything that needs attention.
Your Evolved Folder Structure
Here's what the full structure looks like after a few weeks of active use:
Personal_OS/ │ ├── 00_Inbox/ # Daily agendas │ ├── 10_Projects/ # Active work │ ├── Keynote_Prep/ │ │ ├── process_notes.md │ │ └── call_notes.md │ └── Newsletter_Tracker/ │ └── process_notes.md │ ├── 20_Areas/ # Ongoing responsibilities │ ├── Calls/ # Meeting notes (NEW) │ │ ├── 2026-02-10_Contact.md │ │ └── _index.md │ ├── People/ # Contact directory (NEW) │ │ ├── _template_person.md │ │ ├── _group_template.md │ │ ├── People_Index.md │ │ └── Kyle-Hudson.md │ ├── Keynotes/ # Presentation archive (NEW) │ │ ├── _workflow_guide.md │ │ ├── common_talking_points.md │ │ └── 2026-02-09_Event.pdf │ └── Someday_Maybe.md │ ├── 30_Resources/ # Reference materials │ ├── 40_Archives/ # Completed items │ ├── 99_System/ │ ├── Context_Library/ │ │ ├── business_profile.md │ │ ├── personal_profile.md │ │ ├── project_specs/ │ │ └── personal_specs/ # Personal projects (NEW) │ ├── Profiles/ │ │ ├── writing_profile.md │ │ ├── coding_profile.md │ │ └── coding_reference.md # Tech environment (NEW) │ ├── Scripts/ │ └── claude_code_config.md # Skills reference (NEW) │ └── CLAUDE.md
Items marked in green are additions beyond the original 1.0 setup. They emerge naturally from daily use—you build them as you need them.
Quick Reference: The Full Optimization Checklist
Use this as a checklist. You can tackle these in any order—each one is independent.
| Optimization | Time to Set Up | Daily Value |
|---|---|---|
| Add task schema to CLAUDE.md | 5 minutes | High—consistent task format for /today |
| Add action rules to CLAUDE.md | 10 minutes | High—eliminates recurring friction |
| Create a writing profile | 15 minutes | High—Claude writes in your voice |
| Set up People directory | 10 minutes (template + CLAUDE.md rules) | High—relationship memory across sessions |
| Set up /call command | 10 minutes | High—structured meeting notes in seconds |
| Create business profile | 15 minutes | Medium—Claude knows your org context |
| Set up /review command | 10 minutes | Medium—weekly summaries in one command |
| Create global CLAUDE.md | 10 minutes | Medium—preferences apply everywhere |
| Set up first MCP server | 15 minutes | Varies—depends on which tool you connect |
| Create Keynotes archive | 20 minutes | Compounds—each presentation makes the next faster |
Your Personal OS Grows With You
These optimizations add up. The more context Claude has—your contacts, your decisions, your writing voice, your project history—the more it shifts from assistant to partner. Start with the highest-value items from the checklist above and add more as your workflow demands them.
Explore More at Agents of Change