# From Demo to Daily Driver

This repo demonstrates what Claude Code can do. This guide
helps you make it do something for *you*.

The difference between a demo and a daily driver is
personalization. Claude Code becomes genuinely useful when it
knows your work, your preferences, and your goals. That takes
about an hour of setup and a week of use.

Here is exactly what to do.

---

## Step 1: Make Claude Code know you (30 minutes)

Open `CLAUDE.md` and replace the demo content with your own
context. This is the most important file in the entire setup.
Claude reads it at the start of every session.

Write it like a briefing for a capable new colleague on their
first day:

```markdown
# My Project

## Who I am
Marketing lead at a SaaS startup. I write content, manage
campaigns, and report to the CEO weekly. Not a developer,
but comfortable with terminal basics.

## How I work
- I think in bullet points, not paragraphs
- I want drafts I can edit, not finished products
- Be direct. Skip disclaimers and caveats.
- Default language: English

## What I am working on right now
- Q2 product launch (deadline: April 15)
- Blog series on AI adoption for small businesses
- Weekly metrics report every Monday by 10 AM

## What Claude should never do
- Send anything externally without my explicit approval
- Make up statistics or quotes
- Commit code to main branch
```

This is not decoration. Every word you write here shapes how
Claude behaves in every session. Be specific. Update it as
your work changes.

### What makes a good CLAUDE.md

| Do | Do not |
|----|--------|
| State your role and current priorities | Write a generic bio |
| Say how you want responses formatted | Leave defaults |
| List what is off-limits | Assume Claude will guess |
| Update it weekly | Write it once and forget it |

---

## Step 2: Set up your phone channel (10 minutes)

Pick one. You can add more later.

**iMessage** (if you use Apple devices):
```bash
# In a Claude Code session:
/install @anthropic-ai/claude-code-imessage
```
See `messaging/imessage-setup.md` for Full Disk Access and
permissions.

**Telegram** (works on any phone):
```bash
/install @anthropic-ai/claude-code-telegram
```
See `messaging/telegram-channels-setup.md`.

**Discord** (if you already live there):
```bash
/install @anthropic-ai/claude-code-discord
```

After installing, launch Claude Code in channel mode:
```bash
claude --channels
```

Send a test message from your phone. If Claude responds,
you are connected.

---

## Step 3: Keep your session alive (5 minutes)

The biggest practical limitation: if the session closes,
your phone channel dies. Fix this now.

**Option A: tmux (recommended)**
```bash
# Start a persistent session
tmux new -s claude

# Launch Claude Code with your channel
claude --channels --enable-auto-mode

# Detach: press Ctrl+B, then D
# Your session keeps running. Close the laptop. Walk away.

# Reattach later:
tmux attach -t claude
```

**Option B: Dedicated machine**

A Mac Mini, an old laptop, or a cloud VPS running macOS.
Set it up once. It runs 24/7. This is the closest to
OpenClaw's always-on daemon.

**Option C: Accept the limitation**

Use channels when you are at your desk. Use Dispatch (Cowork
mobile app) or Remote Control (`/rc`) when you are away. Not
always-on, but covers most situations.

---

## Step 4: Write your first personal skill (15 minutes)

Skills are what transform Claude Code from "general AI
assistant" into "my assistant that knows how I work."

### Example: Weekly status report

Create `.claude/skills/weekly-status.md`:

```markdown
---
name: weekly-status
description: Generate my weekly status report from git
  activity, project files, and current priorities.
---

# Weekly Status Report

Generate a status report for my manager covering this week.

## Steps
1. Read CLAUDE.md for current priorities
2. Run `git log --oneline --since="7 days ago"` to see
   what changed this week
3. Check for any files named TODO, ROADMAP, or similar
4. Write a concise report with:
   - What was completed
   - What is in progress
   - What is blocked or needs input
   - Plan for next week

## Format
- Bullet points, not paragraphs
- Lead with wins
- Be honest about blockers
- Under 300 words
```

Now you can run `/weekly-status` every Monday morning.
Or text "Run /weekly-status" from your phone.

### Example: Research and save

Create `.claude/skills/deep-research.md`:

```markdown
---
name: deep-research
description: Research a topic thoroughly, verify claims,
  and save a structured summary with sources.
---

# Deep Research

Research the given topic. Verify every claim.

## Steps
1. Search the web for 3-5 targeted queries
2. Read the top results
3. Cross-reference claims across sources
4. Write a structured summary to
   `research/[topic-slug]-[date].md`

## Output format
### Key findings
- [finding] ([source])

### Details
[longer explanation with citations]

### What I could not verify
[be explicit about gaps]

### Sources
- [title] - [url]
```

### Example: Daily briefing

The repo already has `.claude/skills/daily-briefing.md`.
Customize it: add your news topics, your project context,
whatever you want to know first thing in the morning.

### How to think about skills

A skill is worth writing when you:
- Do the same task more than twice a week
- Explain the same instructions to Claude repeatedly
- Want consistent output format every time
- Want to trigger something from your phone with one message

Start with 2-3 skills. Add more as you notice patterns.

---

## Step 5: Add your tools via MCP (15 minutes per tool)

MCP servers connect Claude Code to external services.
The repo includes Playwright (browser). Here are the most
useful ones to add:

### Slack (post messages, read channels)

Add to `.mcp.json`:
```json
{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": ["@anthropic-ai/mcp-slack@latest"],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-your-token"
      }
    }
  }
}
```
See `messaging/slack-setup.md` for token setup.

### File system (access specific directories)

Already built into Claude Code. But you can scope it:
add paths to CLAUDE.md so Claude knows where your important
files live.

### Others worth exploring

- **Google Drive** MCP: read and write docs
- **GitHub/Forgejo** MCP: manage issues and PRs
- **Calendar** MCP: check schedule and create events

Each MCP server you add is a new capability. Claude
automatically discovers what tools are available and uses
them when relevant.

---

## Step 6: Let it learn (ongoing)

Claude Code gets more useful over time because:

- **CLAUDE.md** accumulates your preferences
- **MEMORY.md** tracks project state across sessions
- **Skills** get refined as you notice what works
- **Agents** (`.claude/agents/`) can be tuned for your style

### After one week

Claude knows your project structure, your formatting
preferences, and your current priorities. Routine tasks
(status reports, research, file management) take one
message instead of twenty minutes.

### After one month

Your skills cover your most common workflows. Your CLAUDE.md
is detailed enough that Claude rarely needs clarification.
You text tasks from your phone and find the results waiting
when you get back to your desk.

### What to update and when

| What | When | Why |
|------|------|-----|
| CLAUDE.md priorities | Weekly | Your focus changes |
| MEMORY.md | Claude does this automatically | Session state |
| Skills | When you repeat yourself | Efficiency |
| MCP servers | When you need a new integration | Capability |

---

## What your day looks like after setup

**Morning.** You text Claude from bed: "Morning briefing."
A summary of your project state, top news in your field,
and what needs attention today arrives in 60 seconds.

**Commute.** You remember something: "Research [topic] and
save it for me." When you sit down at your desk, the
research is in `research/` with sources.

**Working.** You are in Claude Code at the terminal. It
knows your project. You say "continue where we left off"
and it does, because MEMORY.md has the context. Auto Mode
means it executes without constant permission prompts.

**In a meeting.** Someone asks a question you do not know.
Under the table: "What is [company]'s market share in
[segment]? Sources needed." The answer arrives before the
meeting ends.

**End of day.** "Write my status update for this week and
post it to #team-updates on Slack." Done. One message.

**Weekend.** Claude is still running (tmux). You text on
Sunday evening: "Prepare a summary of what happened in
[your industry] this week." Monday morning, it is waiting.

---

## Honest expectations

**What this setup replaces:** Repetitive research, status
reports, file management, Slack updates, and the cognitive
overhead of remembering where you left off.

**What this setup does not replace:** Judgment, creativity,
relationships, and the work that actually matters. Claude
handles the scaffolding so you can focus on the substance.

**The real cost:**
- Claude Pro or Max subscription ($20-200/month)
- One hour of initial setup
- 5 minutes/week maintaining CLAUDE.md
- A machine that stays on (laptop with tmux, or Mac Mini)

**When it clicks:** Usually around day 3-5, when you catch
yourself reaching for your phone to text Claude instead of
opening a browser to search for something. That is when it
stops being a tool and starts being an extension of how
you work.

---

## Quick reference

| I want to... | Do this |
|--------------|---------|
| Set up from scratch | Follow steps 1-4 above |
| Text Claude from phone | Step 2 (channels) |
| Keep it running 24/7 | Step 3 (tmux or Mac Mini) |
| Automate a routine task | Step 4 (write a skill) |
| Connect a new service | Step 5 (add MCP server) |
| Try the demo examples | See `examples/` directory |
| Understand the OpenClaw comparison | See `feature-map.md` |