# Claude OS: 1,000 hours of Claude in one folder

**3 CLAUDE.md templates, 10 ready-to-install skills, 6 daily workflows and a usage-limits playbook. The setup that turns Claude from a chatbot into a system that works like a small team.**

By Dan Shipped (@danshipped) · Last verified: October 2026

---

Most people use Claude like a very smart search bar. They open a chat, type one line, get a decent answer, and start from zero again tomorrow. Then three things happen:

1. They use maybe 10% of what it can do, and they know it.
2. The output sounds like everyone else's AI output.
3. They hit the usage limit in the middle of the afternoon.

You're right that this is frustrating. And you're right that more prompts won't fix it. I've tried. I build and run my SaaS products alone, and Claude is the rest of my team. What fixed it wasn't a better prompt. It was a **setup**: Claude knowing who I am, what I'm working on, and exactly how I want recurring jobs done, without me re-typing any of it.

This folder is that setup, cleaned up so you can install it in 15 minutes.

**Why it's free**: I'm testing which parts people use most, so I know what to build next. You get the full thing. I get to see what matters. Fair trade.

---

## Start here: your 5-minute win

Before installing anything, do this. It's the single biggest upgrade, and it takes 5 minutes.

**Step 1 (3 min).** Open claude.ai → click your initials (bottom left) → **Settings** → find **Instructions for Claude**. Paste this, and fill the brackets:

```
About me: I'm [NAME], [ROLE] at [COMPANY / "my own business"], based in [CITY, TIMEZONE]. I [one line on what you actually do]. My main goal this quarter: [GOAL WITH A NUMBER AND DATE].
My audience/customers: [WHO, SPECIFIC].
How to answer: lead with the answer, then the reasoning. Default to short (under 150 words) unless I ask for depth. Plain words, no hype words (game-changer, unlock, delve). If you're unsure, say so; never invent facts, numbers or quotes.
How to work: if my request is unclear and the answer would change a lot, ask up to 3 questions in one message first. If it's small, make a sensible assumption and tell me what you assumed. Give me one strong draft, not five options, unless I ask. Point out obvious mistakes even if I didn't ask.
Never: start with "Great question", restate my question, or add disclaimers unless something is genuinely risky.
```

**Step 2 (2 min).** Open a new chat and paste this:

```
Based on what you know about me, what are the 3 recurring tasks in my week where you could save me the most time? For each: the task, a realistic estimate of time saved per week, and the exact first message I should send you to start.
```

Compare the answer with what you'd have gotten yesterday. That's the whole idea of this folder: **context once, results every time.** The rest of this guide does the same thing for every recurring job in your week.

---

## What's in the folder

```
11_claude-os/
├── README.md                 ← you are here (the guide)
├── LIMITS-PLAYBOOK.md        ← stay under your usage limits
├── WORKFLOWS.md              ← 6 end-to-end daily workflows
├── PROMPTS.md                ← all 10 skills as paste-in prompts (ChatGPT/Gemini too)
├── claude-md/
│   ├── personal-assistant/CLAUDE.md
│   ├── coding-project/CLAUDE.md
│   └── business-operator/CLAUDE.md
└── skills/
    ├── install-claude-code.sh    ← one command installs all 10 in Claude Code
    ├── make-zips.sh              ← builds the zips for claude.ai upload
    ├── voice-writer/             (+ voice-profile-template.md)
    ├── anti-generic-strategy/
    ├── research-brief/
    ├── meeting-to-actions/
    ├── inbox-triage/             (+ triage-rules.md)
    ├── weekly-review/
    ├── decision-memo/
    ├── content-repurposer/       (+ platform-rules.md)
    ├── code-reviewer/            (+ checklist.md)
    └── prompt-sharpener/
```

---

## Chapter 1: The mental model (read this, it saves you hours)

Claude has four places to put "how I want things done". Most people only use the chat box. The setup works because each kind of information goes in the right place.

| Layer | What it is | What goes there | Loaded when | Cost to your usage |
|---|---|---|---|---|
| **Instructions for Claude** (claude.ai) / `~/.claude/CLAUDE.md` (Claude Code) | Your profile | Who you are, how you like answers. 10-80 lines. | Every chat | Small but constant. Keep it short. |
| **Projects** (claude.ai) / project `CLAUDE.md` + folder (Claude Code) | A workspace per area of your life or business | Area-specific instructions + reference files (price list, brand guide, past work) | Every chat in that Project | Project knowledge is cached and counts less when reused |
| **Skills** | A folder with a `SKILL.md`: a step-by-step procedure for one job | "How to triage my inbox", "how to review code" | Only the name and description are always loaded; the full instructions load only when the task matches | Very low until used |
| **Memory** | What Claude learns from your chats | Facts and preferences it picks up | Automatically | Managed by Claude |

**The rule of thumb:**
- Something true in every conversation → **Instructions**.
- Something true for one area (one client, one product, one book) → **Project**.
- A repeatable procedure with steps → **Skill**.
- Something you'll mention once → just say it in the chat. Memory may pick it up.

The most common mistake is putting procedures in instructions ("When I ask for a weekly review, do these 12 steps…"). Those 12 steps then load into every chat, even when you're asking about dinner. As a skill, they cost almost nothing until you need them.

---

## Chapter 2: The 15-minute setup

Do these in order. Each step says why it comes before the next.

### Step 1: Instructions for Claude (3 min) — *already done if you did the 5-minute win*
**Why first**: it upgrades every chat from now on, including the ones where you forget everything else.

- claude.ai: Settings → **Instructions for Claude**. Paste a trimmed version of `claude-md/personal-assistant/CLAUDE.md` (delete the `<!-- comments -->` first) or the short block from "Start here".
- Keep it under ~80 lines. If something only matters for one area, it belongs in a Project.

### Step 2: Check memory (1 min)
**Why**: memory is on by default on Free, Pro and Max. You want to know what it already "knows" so it doesn't fight your instructions.

- Settings → **Memory**. You'll see what Claude remembers about you. Edit or delete anything wrong or outdated.
- On paid plans, "Search and reference chats" lets Claude look up past conversations. Leave it on: it's how you avoid re-pasting context.
- Each Project has its own separate memory, so client work stays in its own lane.
- Need a chat that's not remembered? Use an incognito chat.

### Step 3: Create 2-3 Projects (4 min)
**Why**: Projects are where context stops being re-pasted. Everything inside a Project starts with its instructions and files already loaded.

Start with these three (Free accounts can create up to 5 Projects):

1. **"[Business] HQ"**: paste `claude-md/business-operator/CLAUDE.md` (filled in) as the Project instructions. Upload your price list, 1-2 past proposals, a short FAQ, and anything you paste more than once a month.
2. **"Daily ops"**: short instructions ("Inbox, meetings and daily admin. Use my inbox rules: [rules]."). This is where Workflow 1 lives.
3. **"Writing"**: upload your `voice-profile.md` once you've made it (Step 4). Everything you write lives here.

Tip: name files clearly (`price-list-2026.md`, not `doc3.pdf`). Claude finds things by name and content.

### Step 4: Install the skills (5 min)
**Why**: this is where Claude starts doing recurring jobs your way, without a prompt.

**On claude.ai (web/desktop):**
1. Settings: make sure **code execution** (file creation) is on. Custom skills need it.
2. Build the zips. On Mac/Linux: open Terminal in the `skills/` folder and run `bash make-zips.sh`. You get one `.zip` per skill in `skills/zips/`. (No terminal? Right-click each skill folder → Compress. The zip must contain the folder itself, e.g. `voice-writer.zip` → `voice-writer/SKILL.md`.)
3. Go to **Customize → Skills** and upload each zip. Turn them on.
4. Custom skills on claude.ai are per user. If your teammate wants them, they upload them too.

**On Claude Code:**
```bash
cd path/to/11_claude-os/skills
bash install-claude-code.sh
```
This copies all 10 into `~/.claude/skills/` so they work in every project. (To share with a team in one repo, copy the folders into `<repo>/.claude/skills/` and commit them.) Start a new session and type `/` to see them, e.g. `/voice-writer`.

**Test that it works (1 min):** in a new chat, type "Triage these emails:" and paste 3 fake emails. If Claude's reply uses the 5 buckets (Reply now, Deep work, Delegate, Read later, Archive), the skill fired. If not, say "Use the inbox-triage skill" and check that the skill is turned on.

**First skill to run**: `voice-writer`. Paste 3-5 things you wrote yourself. It takes 10 minutes and fixes the "sounds like AI" problem for everything else.

### Step 5: Claude Code basics (3 min, optional but worth it)
**Why**: Claude Code isn't only for coders. It's Claude working directly on files on your computer: it can read a folder of notes, write reports into it, and keep your skills and CLAUDE.md as real files you can edit. It's included in Pro and Max.

```bash
# Install (macOS / Linux / WSL)
curl -fsSL https://claude.ai/install.sh | bash
# Windows PowerShell:  irm https://claude.ai/install.ps1 | iex

cd ~/your-folder
claude            # starts a session; log in with your Claude account the first time
```

The 8 commands you need on day one:

| Command | What it does |
|---|---|
| `/init` | Scans the folder/repo and writes a starting `CLAUDE.md` |
| `/clear` | Fresh start for a new task (saves usage) |
| `/compact [what to keep]` | Summarizes a long session, keeping what you name |
| `/model` | Switch model (lighter for simple work) |
| `/usage` | See your plan usage and what's consuming it |
| `/context` | See what's taking up context right now |
| `/resume` | Go back to an earlier session |
| `Shift+Tab` | Cycle permission modes, including **plan mode** (Claude proposes a plan before touching anything) |

Where files go:
- `~/.claude/CLAUDE.md` → your personal instructions for every project.
- `./CLAUDE.md` in a folder → instructions for that project (`CLAUDE.local.md` for private notes, add it to `.gitignore`).
- `~/.claude/skills/<name>/SKILL.md` → personal skills. `.claude/skills/<name>/SKILL.md` → project skills.

That's the setup. Everything below is how to get the most out of it.

---

## Chapter 3: The 3 CLAUDE.md templates

Each template in `claude-md/` has `[BRACKETS]` to fill and an HTML comment above every section explaining **why** it exists. Read the comments once, then delete them.

| Template | Use it for | Where it goes |
|---|---|---|
| `personal-assistant/` | Your default profile: who you are, how you like answers, your tools and people | claude.ai: Settings → Instructions for Claude. Claude Code: `~/.claude/CLAUDE.md` |
| `coding-project/` | One software repo: stack, exact commands, project map, rules, danger zones, gotchas | `./CLAUDE.md` at the repo root (run `/init` first, then merge) |
| `business-operator/` | Your business brain: offer, customers in their own words, numbers, priorities, how decisions get made | claude.ai: a "[Business] HQ" Project. Claude Code: `~/business-hq/CLAUDE.md` |

**Five rules for a CLAUDE.md that actually gets followed:**

1. **Short beats complete.** Anthropic's guidance for Claude Code is to keep each CLAUDE.md under ~200 lines; longer files reduce adherence. Mine are under 100.
2. **Specific beats general.** "Be concise" does little. "Under 150 words unless I ask for depth" works.
3. **Say why.** "Money is integer cents because floats caused a rounding bug in refunds" gets followed in situations you didn't predict.
4. **No contradictions.** If two lines conflict, Claude may pick either. Review the file once a month.
5. **It's a living file.** Every time Claude makes the same mistake twice, add one line ("Known gotchas" in the coding template). That's how the file gets smarter than any template.

---

## Chapter 4: The 10 skills

A skill is a folder with a `SKILL.md` file. The top of the file has two fields: `name` and `description`. The description says what the skill does **and when to use it**. Claude reads only these short descriptions at the start, and loads the full instructions when your request matches. That's why you can install 10 (or 50) without slowing anything down.

| Skill | What it does | Say this to trigger it | Extra files |
|---|---|---|---|
| `voice-writer` | Learns your voice from 3-5 samples, then writes like you, with a self-check against AI-isms | "Write this in my voice" / "Build my voice profile" | voice profile template |
| `anti-generic-strategy` | Makes strategy docs, decks and plans specific: swap test, choices, numbers, kill signals | "Fix this deck, it sounds like every other deck" | |
| `research-brief` | Question → sourced, decision-ready brief with confidence levels | "Research [X] so I can decide [Y]" | |
| `meeting-to-actions` | Transcript → decisions, owners, deadlines + recap emails ready to send | "Here's the call transcript, give me the actions" | |
| `inbox-triage` | Sorts messages into 5 buckets and drafts the replies; never sends anything | "Triage my inbox" | your triage rules |
| `weekly-review` | 20-min guided review: planned vs done, patterns, next week's top 3 | "Weekly review" | |
| `decision-memo` | One-page decision memo: options, weighted criteria, pre-mortem, kill criterion | "Should I [A] or [B]?" | |
| `content-repurposer` | 1 long piece → 10 platform-native posts with different angles | "Turn this into posts" | platform rules + limits |
| `code-reviewer` | Reviews diffs/PRs for real bugs and security holes, ranked, with fixes | "Review my changes" / `/code-reviewer` | review checklist |
| `prompt-sharpener` | Turns a vague ask into a 7-part brief, then runs it or saves it as a skill | "Sharpen this prompt" | |

**How they're built (so you can trust them and edit them):**
Every skill follows the same structure: when to use it → gather inputs (ask once, in one message) → step-by-step procedure → a fixed output format → a self-check before delivering → hard rules (e.g., never invent numbers, never send emails). That structure is the difference between "a prompt" and "a process". It's also why the output is consistent from one week to the next.

**Editing a skill**: open its `SKILL.md` and change it like any document. Common edits:
- Change the output format to match your team's (e.g., your proposal sections).
- Add your own banned words to the voice-writer self-check.
- Add your stack-specific rules to the code-reviewer checklist.
On claude.ai, re-zip and re-upload after editing. In Claude Code, changes apply in the next session.

**Using them with ChatGPT or Gemini**: `PROMPTS.md` has every skill compressed into one paste-in prompt. Save your favorites as a Custom GPT or a Gemini Gem so you paste once.

---

## Chapter 5: Why your outputs sound generic (and the fix)

Generic output has three causes. Each has a fix in this folder.

**Cause 1: Claude doesn't know anything specific about you.**
With no context, the most likely answer is the average answer. That's what "generic" means. Fix: the Instructions + Projects setup (Chapter 2). Every fact you give once is a fact Claude can use forever.

**Cause 2: You asked for a topic, not a job.**
"Write a post about pricing" has a thousand average answers. "Write a 150-word LinkedIn post for agency owners arguing that hourly pricing punishes speed, using my example of the 3-day project I priced at $4,500" has very few. Fix: `prompt-sharpener` checks your ask for goal, audience, context, task, inputs, format and quality bar, and fills the gaps before running.

**Cause 3: Nobody checks the draft against "would only we say this?"**
Fix: `anti-generic-strategy` runs the **swap test** on every sentence: *could a competitor put this in their deck unchanged?* If yes, it gets rewritten with a fact only you have, or cut. `voice-writer` checks the draft against your real sentence length, your openers and a never-list of words you'd never use.

A quick way to see the difference, from a real strategy doc pattern:
- Before: "We deliver an innovative, seamless experience that empowers merchants to grow."
- After: "Checkout loads in under a second on mobile. Merchants who switched told us speed was the reason in [N] of [N] calls." (Brackets stay until you have the real numbers. That's the point.)

---

## Chapter 6: Stay under your limits (summary)

Full playbook with sources: **`LIMITS-PLAYBOOK.md`**. The short version:

**The one idea**: every message re-sends the whole conversation so far. Message #40 in a long chat costs far more than message #1, even if both are one line.

**The 8 habits that matter most:**
1. **One task = one chat.** New topic → new chat. Carry context over with a 200-word summary.
2. **Recurring material lives in a Project**, not pasted. Project content is cached and counts less when reused.
3. **Edit your message** instead of sending "no, I meant…".
4. **Batch related questions** in one message.
5. **Brief well the first time.** Corrections cost more than a longer first message.
6. **Turn off what the chat doesn't need**: web search, connectors, extended thinking for simple tasks.
7. **Lighter model for intern-level work**, the top model for hard reasoning.
8. **In Claude Code**: `/clear` between tasks, keep CLAUDE.md short, check `/usage` and `/context`, disable unused MCP servers.

On Pro and Max, chat and Claude Code share one pool of usage. Check where you stand in Settings → Usage (or `/usage` in Claude Code).

---

## Chapter 7: The 6 daily workflows (summary)

Full step-by-step with the exact words to type: **`WORKFLOWS.md`**.

| # | Workflow | Skills chained | Time |
|---|---|---|---|
| 1 | Morning inbox | inbox-triage → voice-writer → meeting-to-actions | ~15 min |
| 2 | A post in your voice | voice-writer → content-repurposer | ~20 min |
| 3 | Client proposal | meeting-to-actions → research-brief → anti-generic-strategy → voice-writer | ~45 min |
| 4 | Weekly review | weekly-review → decision-memo | ~20 min |
| 5 | Research → decision | prompt-sharpener → research-brief → decision-memo | ~1 hour |
| 6 | Ship a small feature | prompt-sharpener → plan mode → code-reviewer (Claude Code) | 1-2 hours |

Times are what they typically take me once the setup is done; your first run of each will be slower.

The pattern under all six: **capture → structure → draft → you decide → save what you learned.** Claude does the first three. You do the fourth. The fifth is what makes the system better every week.

---

## Going further

Once the basics are running, these are the upgrades worth your time. All are real features, documented by Anthropic.

**1. Write your own skills.** The best skill is the one for the job only you do. After doing a task once with Claude, say: "Turn what we just did into a skill: name, a description that says when to use it, numbered steps, output format, rules." Rules for the frontmatter: `name` is lowercase letters, numbers and hyphens (max 64 characters, and it can't contain "claude" or "anthropic"); `description` says what it does and when to use it (keep it under ~200 characters for claude.ai). Keep `SKILL.md` under ~500 lines and move long reference material into separate files in the folder, linked from `SKILL.md`. Claude reads them only when needed.

**2. Skills that only you can trigger (Claude Code).** For anything with side effects (deploying, sending, publishing), add `disable-model-invocation: true` to the frontmatter. Then it runs only when you type `/skill-name`, never on Claude's own initiative.

**3. Live context in a skill (Claude Code).** A line like `` !`git diff HEAD` `` inside a skill runs the command first and pastes its output into the instructions. Great for review, changelog and status-report skills.

**4. Path-scoped rules (Claude Code).** Put topic files in `.claude/rules/` (e.g., `testing.md`, `api-design.md`). Rules can be scoped to file paths so they only load when Claude works on matching files. Keeps your main CLAUDE.md short.

**5. Connectors.** On claude.ai, connecting Gmail, Google Calendar or Drive lets `inbox-triage` and `weekly-review` read your real data instead of pasted text. Turn connectors on per chat when needed: they're token-heavy.

**6. Subagents for noisy work (Claude Code).** "Use a subagent to run the full test suite and report only failures." The verbose output stays in the subagent; your main conversation stays light.

**7. Hooks (Claude Code).** Hooks run your own scripts at fixed points (e.g., before every shell command). Use them for things that must *always* happen, like blocking a dangerous command or trimming test output. CLAUDE.md is guidance; a hook is enforcement.

**8. Audit monthly.** Once a month, open your Instructions, Project instructions and CLAUDE.md files, and delete anything outdated or contradictory. Ten accurate lines beat fifty stale ones.

---

## Limits (what this won't do)

I'd rather you trust the parts that work than oversell the parts that don't.

- **It won't remove usage limits.** It makes the same allowance go much further. If you do heavy daily work in Claude Code, you may still need a bigger plan.
- **Skills don't sync between surfaces.** Skills uploaded to claude.ai, installed in Claude Code, and uploaded to the API are three separate installs. You set each up once.
- **Custom skills on claude.ai need code execution turned on.** On claude.ai, skill files can't be updated by Claude automatically: when voice-writer builds your profile, you save it yourself (Project knowledge or re-zip). In Claude Code it can write the file directly.
- **Skills are guidance, not guarantees.** Claude usually picks the right skill from the description, but not always. Naming the skill ("use the decision-memo skill") always works.
- **Inbox and calendar workflows depend on connectors.** Without them, you paste. Still fast, but not automatic.
- **Claude can be wrong.** Research briefs flag confidence and sources for a reason. Check prices, dates, legal and money details yourself. Nothing here is legal, tax or financial advice.
- **Features move fast.** Menu names and limits change. Everything here was checked in October 2026. If your app looks different, trust the app.

---

## Want this done automatically?

Everything here is the do-it-yourself version: you install, you fill the brackets, you maintain it.

I'm building **Claude OS Pro**: new skill packs every month (client work, sales, hiring, finance ops, content), each tested before release, auto-updated when Claude's features change, plus a small private group of people running the same setup and sharing what works.

If you'd want that, **reply YES to my DM** (or join the waitlist from the link I sent). Tell me which skill you used first and which one you'd want next. That decides what I build.

**Follow @danshipped** for the next drop. I build in public with Claude every day, and I share the parts that actually work.

*Made by Dan Shipped — @danshipped. AI & SaaS — shipped.*