claude-code-complete-agent/examples/14-build-your-agent/prompt.md

# Example 14: Build Your Personal Agent

This is not a demo. This is the example where you build something real.

Everything you explored in examples 01-13 demonstrated capabilities. This
example puts them together into a personal agent that works for you
specifically. Not a copy of the demo. Not a tutorial exercise. A setup
you will actually use tomorrow morning.

**Time needed:** 45-60 minutes for the core setup. You will refine it
over the first week of use.

---

## What you will build

By the end of this example, you will have:

1. A `CLAUDE.md` written for your life and work (not the demo one)
2. A personal skill that automates something you do every week
3. A messaging channel connected to your phone
4. A scheduled automation that runs without you
5. A tested end-to-end flow: phone to agent to result to phone

This is the setup that makes people text their agent from bed and
find the answer waiting when they sit down with coffee.

---

## Step 1: Write your CLAUDE.md (15 minutes)

Close this repo's `CLAUDE.md` in your mind. Start fresh. Open a new
project directory (or use an existing one) and create `CLAUDE.md`.

Write it like a briefing for a brilliant new colleague on their
first day. Include:

```markdown
# [Your Project or Life Context]

## Who I am
[Your role, what you do day to day, what you care about]

## How I work
[Communication preferences, formats you like, what annoys you]
[Example: "Be direct. Skip caveats. Bullet points over paragraphs."]

## What I am working on right now
[Your top 3-5 priorities with deadlines if they exist]

## What Claude should never do
[Hard boundaries. Things that would break trust.]
[Example: "Never send anything externally without my explicit OK"]

## Tools and accounts
[What MCP servers are configured, what services you use]
[Example: "Slack MCP connected to workspace X. Telegram channel active."]
```

### How to know it is good enough

Read it back and ask: if a capable person read only this file, could
they handle my Monday morning? If the answer is "mostly, yes," it is
good enough. You will improve it every week.

**Pattern from Example 05:** This file is loaded at every session start.
Everything you write here shapes every interaction.

---

## Step 2: Write your first real skill (15 minutes)

Not the demo skill. Not a copy. A skill that solves a problem you
have this week.

Think about what you do repeatedly that follows a pattern:
- A report you write every Monday
- Research you do before every meeting
- A summary you prepare for your manager
- A check-in you run on a project

Create `.claude/skills/[your-skill-name].md`:

```markdown
---
name: [your-skill-name]
description: [one sentence that explains when to use this]
---

# [What This Does]

[Clear instructions for Claude. Be specific about:]

## Steps
1. [Where to get the input: files, web, memory]
2. [What to do with it: research, draft, analyze, compare]
3. [How to format the output: bullets, paragraphs, table]
4. [Where to save it: file path, message channel, both]

## Quality criteria
- [What makes this output good vs. mediocre]
- [What to never include or assume]

## Output format
[Exact structure you want every time]
```

### How to know the skill works

Run it: `/[your-skill-name]`

Does the output match what you would have produced manually? If yes,
you just automated a recurring task. If not, refine the instructions
and run it again. Most skills take 2-3 iterations to get right.

**Pattern from Example 06:** If the skill involves research and writing,
consider using the researcher/writer/reviewer agent pattern inside it.
Multi-agent review catches errors that a single pass misses.

---

## Step 3: Connect your phone (10 minutes)

Pick one channel. You can always add more later.

**Telegram** (works on any phone, recommended for first setup):
```bash
claude --channels
```
Follow the Telegram setup in `messaging/telegram-channels-setup.md`.

**iMessage** (if you live in Apple's ecosystem):
```bash
/install @anthropic-ai/claude-code-imessage
claude --channels
```
Follow `messaging/imessage-setup.md`.

### Test it

From your phone, send: "Run /[your-skill-name]"

If the result comes back to your phone, your agent is connected.

**Pattern from Example 07:** Channels turn a desktop tool into
a personal assistant you can reach from anywhere.

---

## Step 4: Automate it (10 minutes)

Your skill works. Your phone is connected. Now make it run without you.

**For a daily task:**
```
Create a cron job that runs /[your-skill-name] every [weekday] at [time].
Use automation/daily-briefing.sh as a template. Show me the cron entry
before creating it.
```

**For a weekly task:**
```
/schedule "Run /[your-skill-name] and send me the result via Telegram"
at [next Monday]T07:00:00
```

### Test it

Create a `/loop` test first to verify the flow works before committing
to a cron job:

```
/loop interval=120

Run /[your-skill-name]. Send the result to [your channel].
Then wait for the next interval.
```

If the output arrives on your phone every 2 minutes, the automation works.
Replace with a real schedule.

**Pattern from Example 08:** /loop for testing, CronCreate for daily
drivers, /schedule for remote triggers.

---

## Step 5: Test the full flow (5 minutes)

The real test. Put your phone down. Walk away from the computer.

From your phone, send:

```
Run /[your-skill-name] and tell me when it is done.
```

Wait.

When the result arrives, you have a working personal agent. Not a demo.
Not an exercise. A system that does real work on your behalf, triggered
from your phone, using your context, delivering to where you need it.

---

## What you have now

| Component | What it does | File |
|-----------|-------------|------|
| CLAUDE.md | Your context, always loaded | `CLAUDE.md` |
| Skill | Your recurring task, automated | `.claude/skills/[name].md` |
| Channel | Your phone connection | Telegram/iMessage/Discord |
| Schedule | Your automation trigger | cron or /schedule |
| Memory | Your persistent state | `memory/MEMORY.md` |
| Hooks | Your safety guardrails | `hooks/` |

This is the same architecture, at a smaller scale, that runs
production content pipelines. The pieces are the same. The
difference is what you point them at.

---

## What to do in your first week

**Day 1-2:** Use the skill manually a few times. Notice what the output
gets wrong or could improve. Edit the skill file.

**Day 3-4:** Add a second skill for something else you do often. Start
texting tasks from your phone as a habit.

**Day 5-7:** Check your CLAUDE.md. Is it still accurate? Add what you
learned this week. Remove what turned out to be irrelevant.

**After one week:** You will know whether this is a novelty or a genuine
tool. Most people who get this far keep going. The ones who do not usually
stopped at the CLAUDE.md and never made it personal enough to be useful.

---

## Growing from here

Your agent gets more useful the more you invest in it:

**Add more skills.** Every task you do more than twice a week is a
candidate. A good personal setup has 3-5 skills after a month.

**Add more tools.** MCP servers connect Claude to your services.
Slack, Google Drive, calendar, databases. Each one extends what
your agent can do autonomously.

**Add more agents.** The `.claude/agents/` directory can hold
specialists for your domain. A "compliance checker," a "meeting prep"
agent, a "customer research" agent. Pattern: give each agent a role,
a scope, and clear instructions.

**Tune the security.** As you automate more, tighten the hooks. Add
patterns to the deny list. Review the audit log weekly. The more
autonomous your agent is, the more important the guardrails.

---

## Honest assessment

This setup will not replace your judgment, your relationships, or
your taste. It replaces the scaffolding: the research, the formatting,
the status updates, the routine decisions, the cognitive overhead of
remembering where you left off.

The people who get the most from it are the ones who are specific about
what they need. A vague CLAUDE.md produces vague results. A precise one
produces surprisingly useful results from day one.

The time investment is real: one hour to set up, five minutes a week
to maintain. The return depends entirely on how well you describe your
work and how consistently you use it.

Start with one skill. Make it genuinely useful. Everything else follows.