claude-code-complete-agent/GETTING-STARTED.md

# 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.

### How this connects to the examples

The `examples/` directory shows what Claude Code can do. This guide
shows how to make it do that for *you*. Each step below references
the relevant examples so you can see the capability in action before
personalizing it.

If you want the full guided path, run the examples 01-10 first
(follow the Cumulative Path in each one), then come here to build
your permanent setup. Or jump straight to [Example 14](examples/14-build-your-agent/prompt.md),
which condenses this guide into one hands-on session.

---

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

Open `CLAUDE.md` in the project root 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 |

> **See it in action:** [Example 05](examples/05-memory-system/prompt.md)
> shows how CLAUDE.md drives Claude's behavior. [Example 14](examples/14-build-your-agent/prompt.md)
> walks you through writing your own from scratch.

---

## 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.

> **See it in action:** [Example 07](examples/07-messaging/prompt.md)
> demonstrates messaging with Telegram and Slack.
> [Example 12](examples/12-remote-control/prompt.md) covers all three
> remote access methods (Channels, Dispatch, Remote Control).

---

## 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: Create your first personal skill (15 minutes)

Skills transform Claude Code from "general AI assistant" into
"my assistant that knows how I work." You do not write skill
files by hand. You describe what you need and let Claude create
the file with the correct format.

### How it works

Tell Claude what you want the skill to do. It creates the file
with proper YAML frontmatter (required for Claude Code to
recognize it as a skill) and markdown body.

### Example: Weekly status report

```
Create a skill called "weekly-status" that generates my weekly
status report. It should:
1. Read CLAUDE.md for current priorities
2. Check git log for this week's activity
3. Look for TODO or ROADMAP files
4. Write a concise report: what was completed, what is in
   progress, what is blocked, plan for next week
Format: bullet points, under 300 words, lead with wins.
Save it to .claude/skills/weekly-status.md
```

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

### Example: Research and save

```
Create a skill called "deep-research" that researches a given
topic thoroughly. It should search the web, cross-reference
claims across sources, and write a structured summary to
research/[topic-slug]-[date].md with key findings, details,
what could not be verified, and source URLs.
Save it to .claude/skills/deep-research.md
```

### Example: Daily briefing

The repo already has `.claude/skills/daily-briefing.md`. To
customize it, just tell Claude:

```
Update the daily-briefing skill to include [your news topics],
[your project context], and [what you want to know each morning].
```

### Iterating on skills

The first version rarely nails it. Run the skill, read the output,
and tell Claude what to fix:

```
The weekly-status output is too long. Update the skill to cap
each section at 3 bullets and total output at 200 words.
```

Claude updates the skill file. Run it again. Most skills take
2-3 iterations to produce output you are happy with.

### When to create a skill

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

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

> **See it in action:** [Example 06](examples/06-multi-agent/prompt.md)
> shows the researcher-writer-reviewer agent pattern that makes complex
> skills powerful. The "Now Try It Yourself" section in each example
> helps you adapt demo capabilities into personal skills.

---

## 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.

> **See it in action:** [Example 04](examples/04-browser-automation/prompt.md)
> demonstrates Playwright MCP for browser automation.
> [Example 07](examples/07-messaging/prompt.md) shows Slack MCP in action.

---

## 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 |
| Follow the cumulative path | Start at `examples/01-agent-runtime/` |
| Build your personal agent | See `examples/14-build-your-agent/` |
| Understand the OpenClaw comparison | See `feature-map.md` |