open/claude-code-complete-agent
1
0
Fork 0
Code Activity Actions

refactor: rewrite Example 14 as genuine capstone and fix skill creation

Browse source 
Example 14 completely rewritten. Was: GETTING-STARTED.md repeated
(one skill + phone + cron). Now: a 7-phase system design that
produces a complete personal agent ecosystem (custom agents,
multi-agent pipeline, custom hooks, automation, phone delivery).

Requires accumulated knowledge from examples 01-13. Includes:
- Phase 1: Map your work (design before building)
- Phase 3: Custom agent team created via Claude (not manually)
- Phase 4: Pipeline skill chaining agents into complete workflow
- Phase 5: Custom security hooks for user's context
- Phase 7: Test on real work with evaluation rubric
- Three concrete persona examples (marketing, engineering, consulting)

GETTING-STARTED.md Step 4: replaced manual file creation with
"tell Claude to create the skill" workflow. Skills, agents, and
hooks should always be created by asking Claude, not by hand.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
Kjell Tore Guttormsen 2026-03-26 21:26:29 +01:00
commit ccf2749127
2 changed files with 490 additions and 243 deletions
Download patch file Download diff file Expand all files Collapse all files

128
GETTING-STARTED.md
View file

@ -149,105 +149,79 @@ always-on, but covers most situations.
--- ---
## Step 4: Write your first personal skill (15 minutes) ## Step 4: Create your first personal skill (15 minutes)
Skills are what transform Claude Code from "general AI Skills transform Claude Code from "general AI assistant" into
assistant" into "my assistant that knows how I work." "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.
### Important: skill file format ### How it works
Every skill file needs YAML frontmatter between `---` markers at the top. Tell Claude what you want the skill to do. It creates the file
Without this, Claude Code will not recognize it as a skill. The `name` field with proper YAML frontmatter (required for Claude Code to
is what you type after `/` to run it. The `description` field helps Claude recognize it as a skill) and markdown body.
decide when to suggest it.
### Example: Weekly status report ### Example: Weekly status report
Create `.claude/skills/weekly-status.md`: ```
Create a skill called "weekly-status" that generates my weekly
```markdown status report. It should:
---
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 1. Read CLAUDE.md for current priorities
2. Run `git log --oneline --since="7 days ago"` to see 2. Check git log for this week's activity
what changed this week 3. Look for TODO or ROADMAP files
3. Check for any files named TODO, ROADMAP, or similar 4. Write a concise report: what was completed, what is in
4. Write a concise report with: progress, what is blocked, plan for next week
- What was completed Format: bullet points, under 300 words, lead with wins.
- What is in progress Save it to .claude/skills/weekly-status.md
- 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. Claude creates the file. Now you can run `/weekly-status` every
Or text "Run /weekly-status" from your phone. Monday morning. Or text "Run /weekly-status" from your phone.
### Example: Research and save ### Example: Research and save
Create `.claude/skills/deep-research.md`: ```
Create a skill called "deep-research" that researches a given
```markdown topic thoroughly. It should search the web, cross-reference
--- claims across sources, and write a structured summary to
name: deep-research research/[topic-slug]-[date].md with key findings, details,
description: Research a topic thoroughly, verify claims, what could not be verified, and source URLs.
and save a structured summary with sources. Save it to .claude/skills/deep-research.md
---
# 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 ### Example: Daily briefing
The repo already has `.claude/skills/daily-briefing.md`. The repo already has `.claude/skills/daily-briefing.md`. To
Customize it: add your news topics, your project context, customize it, just tell Claude:
whatever you want to know first thing in the morning.
### How to think about skills ```
Update the daily-briefing skill to include [your news topics],
[your project context], and [what you want to know each morning].
```
A skill is worth writing when you: ### 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 - Do the same task more than twice a week
- Explain the same instructions to Claude repeatedly - Find yourself explaining the same instructions to Claude
- Want consistent output format every time - Want consistent output format every time
- Want to trigger something from your phone with one message - Want to trigger something from your phone with one message
Start with 2-3 skills. Add more as you notice patterns. Start with 1-2 skills. Add more as you notice patterns.
> **See it in action:** [Example 06](examples/06-multi-agent/prompt.md) > **See it in action:** [Example 06](examples/06-multi-agent/prompt.md)
> shows the researcher-writer-reviewer agent pattern that makes complex > shows the researcher-writer-reviewer agent pattern that makes complex

645
examples/14-build-your-agent/prompt.md
View file

@ -1,276 +1,549 @@
# Example 14: Build Your Personal Agent # Example 14: Build Your Personal Agent System
This is not a demo. This is the example where you build something real. Everything before this was a demo. This is where you build
something real.
Everything you explored in examples 01-13 demonstrated capabilities. This Examples 01-13 showed you individual capabilities: research, file
example puts them together into a personal agent that works for you management, web search, agents, pipelines, messaging, automation,
specifically. Not a copy of the demo. Not a tutorial exercise. A setup security. Individually, each one is useful. Together, they form
you will actually use tomorrow morning. something fundamentally different: a personal agent system that
handles your recurring work, runs on schedule, and delivers results
to your phone.
**Time needed:** 45-60 minutes for the core setup. You will refine it This is not "create a skill and connect your phone." You could have
over the first week of use. done that after reading GETTING-STARTED.md. This is: design a system
of agents that understands your domain, automate a complete workflow,
add safety guardrails, and test it on real work from your actual week.
**Time needed:** 90 minutes for the full build. You will iterate on
it over the first week. Most people say it clicks around day 3.
**What you need:** A project directory (new or existing) where you
will set up your personal agent system. Everything you build here
is portable. Move it to any project later.
--- ---
## What you will build ## Phase 1: Map your work (10 minutes, no computer needed)
By the end of this example, you will have: Before you build anything, think. The difference between a useful
agent system and a novelty is whether you designed it around how
you actually work.
1. A `CLAUDE.md` written for your life and work (not the demo one) ### The three questions
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 **1. What do you do every week that follows a pattern?**
find the answer waiting when they sit down with coffee.
--- Not creative work. Not relationship work. The structured, repeatable
tasks that eat your time because they require gathering, processing,
formatting, and delivering information.
## Step 1: Write your CLAUDE.md (15 minutes) Examples:
- A weekly status report that pulls from multiple sources
- Competitor monitoring that requires searching, comparing, summarizing
- Meeting preparation that needs research, context, and a briefing doc
- Client updates that combine project data with a professional narrative
Close this repo's `CLAUDE.md` in your mind. Start fresh. Open a new Write down 3-5 tasks. Be specific about inputs, processing, and outputs.
project directory (or use an existing one) and create `CLAUDE.md`.
Write it like a briefing for a brilliant new colleague on their **2. What roles would you hire for if you could?**
first day. Include:
```markdown Not "an assistant." Specific roles with specific expertise:
# [Your Project or Life Context]
## Who I am - A **researcher** who tracks your industry and surfaces what matters
[Your role, what you do day to day, what you care about] - A **writer** who turns your notes into polished documents
- A **reviewer** who catches errors before anything goes out
- A **briefing officer** who summarizes what you need to know each morning
- An **analyst** who processes data and highlights patterns
## How I work Write down 2-3 roles. For each: what do they know, what do they produce,
[Communication preferences, formats you like, what annoys you] what quality standard must they meet?
[Example: "Be direct. Skip caveats. Bullet points over paragraphs."]
## What I am working on right now **3. What must never happen automatically?**
[Your top 3-5 priorities with deadlines if they exist]
## What Claude should never do The safety question. When your system runs at 07:00 on Monday without
[Hard boundaries. Things that would break trust.] you watching:
[Example: "Never send anything externally without my explicit OK"]
## Tools and accounts - What actions should be blocked? (sending emails, deleting files, accessing certain APIs)
[What MCP servers are configured, what services you use] - What should always be logged? (all external calls, all file writes, all web searches)
[Example: "Slack MCP connected to workspace X. Telegram channel active."] - What requires your approval before executing? (anything touching production, anything external)
Write these down. They become your hooks in Phase 5.
### Design sketch
Before touching Claude Code, sketch your system on paper or in your head:
```
[Your recurring task]
|
v
[Agent 1: gather information] --> raw data
|
v
[Agent 2: process and draft] --> draft output
|
v
[Agent 3: review and verify] --> verified output
|
v
[Save to files] + [Send to phone] + [Log to memory]
``` ```
### How to know it is good enough This is the same architecture as Example 10, adapted to your work.
You are not inventing something new. You are configuring a proven
Read it back and ask: if a capable person read only this file, could pattern for your specific context.
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) ## Phase 2: Build your operating manual (15 minutes)
Not the demo skill. Not a copy. A skill that solves a problem you Open your project directory in Claude Code. Your first step is not
have this week. writing a CLAUDE.md yourself. It is asking Claude to interview you
and write one.
Think about what you do repeatedly that follows a pattern: ### The prompt
- 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`: ```
Interview me to create a CLAUDE.md for this project. Ask me questions
about:
1. Who I am and what I do
2. How I like to communicate (format, tone, length)
3. What I am working on right now (top 3-5 priorities)
4. What tools and services I use
5. What you should never do without my permission
```markdown Ask one category at a time. After all five, write a CLAUDE.md that
--- would let you handle my Monday morning without additional context.
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 Claude will ask you questions, listen to your answers, and produce
a CLAUDE.md tailored to what you said. This is better than writing
it yourself because Claude knows what information it needs to be
effective.
Run it: `/[your-skill-name]` ### What makes a great CLAUDE.md
Does the output match what you would have produced manually? If yes, After Claude writes it, check:
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, | Criteria | Test |
consider using the researcher/writer/reviewer agent pattern inside it. |----------|------|
Multi-agent review catches errors that a single pass misses. | Specific enough | Could someone handle your Monday with only this file? |
| Priorities current | Does it reflect this week's work, not last month's? |
| Boundaries clear | Are the "never do" rules unambiguous? |
| Tools documented | Does it list what MCP servers and channels are available? |
| Format preferences stated | Will Claude produce output in the shape you actually want? |
If any answer is "no," tell Claude what to fix. Iterate until it
passes all five. This is the foundation of everything that follows.
**Pattern from Example 05:** CLAUDE.md loads at every session start.
Every agent you create in Phase 3 inherits this context automatically.
--- ---
## Step 3: Connect your phone (10 minutes) ## Phase 3: Create your agent team (20 minutes)
Pick one channel. You can always add more later. Now build the 2-3 agents you identified in Phase 1. You do not write
agent files by hand. You tell Claude what each agent should do and
let it create the files.
**Telegram** (works on any phone, recommended for first setup): ### Create your first agent
```bash
Pick the role you need most. Tell Claude:
```
Create an agent called "[role-name]" that [what it does].
It should:
- [Specific capability 1]
- [Specific capability 2]
- [Quality standard it must meet]
It should NOT:
- [Boundary 1]
- [Boundary 2]
Save it to .claude/agents/[role-name].md
```
**Concrete examples for three different people:**
A marketing manager might say:
```
Create an agent called "market-scanner" that monitors competitor
activity. It should search the web for news about [competitor names],
extract pricing changes, new feature launches, and partnership
announcements. It should produce a structured report with source URLs
for every claim. It should not include rumors or unverified information.
Save it to .claude/agents/market-scanner.md
```
An engineering lead might say:
```
Create an agent called "tech-researcher" that evaluates technologies
for our stack. It should search documentation and GitHub repos, compare
features, check community health (stars, issues, release frequency),
and produce a recommendation with pros, cons, and risks. It should not
recommend anything without checking the last 3 months of GitHub issues
for dealbreakers. Save it to .claude/agents/tech-researcher.md
```
A consultant might say:
```
Create an agent called "client-briefer" that prepares meeting briefs.
It should research the client's company (recent news, financials,
leadership changes), review my notes in memory/, and produce a
one-page briefing with talking points and potential questions they
will ask. It should not include anything I cannot verify in the
meeting. Save it to .claude/agents/client-briefer.md
```
### Create your second agent
Every good system needs a quality gate. Create a reviewer:
```
Create an agent called "[domain]-reviewer" that reviews output from
my other agents. It should check for:
- [Your specific accuracy requirements]
- [Your formatting standards]
- [Common mistakes in your domain]
When it finds issues, it should list them with specific fix
instructions, not vague feedback. Save it to .claude/agents/[name].md
```
### Create your third agent (optional but powerful)
A writer/formatter that takes raw output and shapes it for your
audience:
```
Create an agent called "[output]-writer" that transforms research
and analysis into [format your audience expects]. It should follow
[your organization's style/tone]. It should be concise: [your word
limit]. Save it to .claude/agents/[name].md
```
### Test each agent individually
Before combining them, verify each one works alone:
```
Use the [agent-name] agent to [a specific task from your real work].
Show me the full output.
```
Does the output meet your standards? If not, tell Claude what to fix
in the agent file. Iterate until each agent produces work you would
use. This is worth the time. A weak agent in a pipeline produces
weak pipeline output.
**Pattern from Example 06:** The researcher-writer-reviewer pattern
works for almost any domain. Your agents are the same pattern with
your domain expertise built in.
---
## Phase 4: Build your pipeline (20 minutes)
Now the payoff. You combine your agents into a pipeline skill that
handles a complete workflow.
### Create the pipeline skill
Tell Claude to create a skill that orchestrates your agents:
```
Create a skill called "weekly-[your-workflow]" that runs my complete
[task name] workflow.
Steps:
1. Read CLAUDE.md for current priorities and context
2. Read memory/[your-state-file].md for what happened last time
3. Use the [agent-1] agent to [gather/research/analyze]
4. Use the [agent-2] agent to [draft/format/write]
5. Use the [agent-3] agent to [review/verify/check]
6. If the reviewer finds issues, send back to [agent-2] for fixes
7. Save the final output to pipeline-output/[your-output]-[date].md
8. Update memory/[your-state-file].md with what was done and when
9. Show me the first 10 lines of the output to confirm
Save it to .claude/skills/weekly-[your-workflow].md
```
**Concrete example for a marketing manager:**
```
Create a skill called "weekly-competitive-intel" that runs my
Monday morning competitive intelligence workflow.
Steps:
1. Read CLAUDE.md for the list of competitors I track
2. Read memory/competitive-intel-state.md for what was covered last week
3. Use the market-scanner agent to research each competitor's
activity this week (news, product changes, pricing, partnerships)
4. Use the report-writer agent to draft a structured briefing:
- Executive summary (3 bullets)
- Per-competitor section with changes and source URLs
- "So what" section: what this means for our strategy
5. Use the quality-reviewer agent to verify all claims have sources
and no speculation is presented as fact
6. If the reviewer finds issues, send back to report-writer for fixes
7. Save to pipeline-output/competitive-intel-[date].md
8. Update memory/competitive-intel-state.md with today's date
and what was found
9. Show me the executive summary
Save it to .claude/skills/weekly-competitive-intel.md
```
### Test the pipeline
Run it on a real task:
```
/weekly-[your-workflow]
```
Watch the agents hand off to each other. This is the same orchestration
you saw in Example 10, but configured for your work. The pipeline
should take 2-5 minutes depending on how much research is involved.
### Evaluate the output
Read the output as if your manager, client, or colleague sent it to you.
| Question | If no |
|----------|-------|
| Is it accurate? | Tighten the reviewer agent's instructions |
| Is it the right format? | Adjust the writer agent's output template |
| Is it the right depth? | Change the researcher agent's scope |
| Would you send this as-is? | Identify what's missing and update the pipeline |
Iterate. Run the pipeline again after each adjustment. Most people
need 2-3 rounds to get output they are genuinely satisfied with.
**Pattern from Example 10:** The pipeline is a recipe with
interchangeable ingredients. Swap agents, change topics, adjust the
output format. The orchestration stays the same.
---
## Phase 5: Add your safety layer (10 minutes)
Your pipeline will soon run automatically. Before that happens,
set up the guardrails you identified in Phase 1.
### Create your custom hooks
Tell Claude to create hooks for your specific risks:
```
Create a PreToolUse hook that blocks Bash commands containing any of:
- [pattern 1: e.g., "rm -rf", "DROP TABLE"]
- [pattern 2: e.g., commands targeting your production directories]
- [pattern 3: e.g., curl commands with API tokens in arguments]
Save to hooks/[your-hook-name].sh and register it in
.claude/settings.json
```
```
Create a PostToolUse hook that logs every tool call to
hooks/audit.log with timestamp, tool name, and a summary of what
was done. Save to hooks/audit-logger.sh and register it.
```
### Verify the hooks work
```
Try running: [a command your hook should block]
Then check hooks/audit.log to confirm it was blocked and logged.
```
**Pattern from Example 09:** Hooks run on every tool call, including
inside agent invocations and automated pipeline runs. What you
configure here protects every automated run from Phase 6 onward.
---
## Phase 6: Connect and automate (10 minutes)
### Set up your phone channel
```
claude --channels claude --channels
``` ```
Follow the Telegram setup in `messaging/telegram-channels-setup.md`.
**iMessage** (if you live in Apple's ecosystem): Follow the setup for your chosen channel (Telegram recommended
```bash for first setup). See `messaging/` in this repo for detailed guides.
/install @anthropic-ai/claude-code-imessage
claude --channels Test: send "hello" from your phone. If Claude responds, you are connected.
### Schedule your pipeline
Tell Claude:
```
Create a cron job that runs /weekly-[your-workflow] every
[day] at [time]. Show me the cron entry before creating it.
``` ```
Follow `messaging/imessage-setup.md`.
### Test it Or for remote scheduling:
From your phone, send: "Run /[your-skill-name]" ```
/schedule "Run /weekly-[your-workflow] and send me the executive
summary via Telegram" at [date]T[time]:00
```
If the result comes back to your phone, your agent is connected. ### Test the full flow
**Pattern from Example 07:** Channels turn a desktop tool into The real test. From your phone, send:
a personal assistant you can reach from anywhere.
```
Run /weekly-[your-workflow]
```
Wait for the result. When the pipeline output arrives on your
phone, your system is working end-to-end: phone trigger, agent
orchestration, quality review, file output, delivery.
**Pattern from Example 08:** /loop for testing, CronCreate for
production, /schedule for remote triggers.
--- ---
## Step 4: Automate it (10 minutes) ## Phase 7: Run it on real work (15 minutes)
Your skill works. Your phone is connected. Now make it run without you. This is the moment that matters. Everything up to here was setup.
Now you test it on an actual task from your actual week.
**For a daily task:** ### Pick a real 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:** Not a test. Not a hypothetical. Something you need to do this week
``` that your pipeline is designed to handle. A real report, a real
/schedule "Run /[your-skill-name] and send me the result via Telegram" briefing, a real analysis.
at [next Monday]T07:00:00
```
### Test it ### Run it
Create a `/loop` test first to verify the flow works before committing
to a cron job:
``` ```
/loop interval=120 /weekly-[your-workflow]
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. ### Evaluate honestly
Replace with a real schedule.
**Pattern from Example 08:** /loop for testing, CronCreate for daily Read the output. Compare it to what you would have produced manually.
drivers, /schedule for remote triggers.
**The scoring rubric:**
| Score | Meaning | What to do |
|-------|---------|------------|
| "I would send this as-is" | Your system works. Ship it. | Minor tweaks over time |
| "Close, needs 10 min of editing" | Your system saves 80% of the work. | Refine agent instructions for the gaps |
| "The structure is right but content is off" | Agents need better domain context | Add more detail to CLAUDE.md and agent files |
| "This is not usable" | Pipeline design mismatch | Go back to Phase 1 and re-map the workflow |
Most people land on "close, needs 10 minutes of editing" on the
first real run. By the third run, the agents have been refined
enough that the output is send-ready.
--- ---
## Step 5: Test the full flow (5 minutes) ## What you built
The real test. Put your phone down. Walk away from the computer. | Component | What it does | How to change it |
|-----------|-------------|-----------------|
| CLAUDE.md | Operating manual for your domain | Update weekly with priorities |
| 2-3 agents | Specialists for your recurring tasks | Refine when output misses the mark |
| Pipeline skill | Chains agents into a complete workflow | Add steps, swap agents, change output |
| Custom hooks | Protects automated runs | Add patterns as you automate more |
| Scheduling | Runs the pipeline on autopilot | Adjust frequency based on need |
| Phone channel | Access from anywhere | Add more channels over time |
| Memory | Tracks what was done and when | Grows automatically with each run |
From your phone, send: This is not a configured tool. This is a system.
``` A GETTING-STARTED reader has a Claude Code setup with preferences.
Run /[your-skill-name] and tell me when it is done. You have a multi-agent pipeline that handles a complete recurring
``` workflow, runs on schedule, reviews its own output for quality,
logs every action for safety, and delivers results to your phone.
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 ## Your first week
| Component | What it does | File | **Day 1:** Run the pipeline manually. Fix what is wrong with the
|-----------|-------------|------| output. Refine agent instructions.
| 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 **Day 2:** Run it again. Compare to yesterday. Is it better?
production content pipelines. The pieces are the same. The Add domain knowledge to CLAUDE.md that would have prevented
difference is what you point them at. yesterday's mistakes.
--- **Day 3:** Let the cron job run it. Check the output when it arrives
on your phone. The moment it produces something useful without you
touching anything: that is the moment it clicks.
## What to do in your first week **Day 4-5:** Add a second pipeline skill for another recurring task.
You already have agents. Creating a new pipeline that reuses them
takes 10 minutes.
**Day 1-2:** Use the skill manually a few times. Notice what the output **Day 6-7:** Review your hooks and audit log. Are the right things
gets wrong or could improve. Edit the skill file. being blocked? Is the log useful? Tighten security now that you
trust the system to run autonomously.
**Day 3-4:** Add a second skill for something else you do often. Start **After one week:** You have 1-2 automated pipelines, 2-3 specialized
texting tasks from your phone as a habit. agents, and a growing memory of your work context. Routine Monday
tasks take one phone message instead of two hours. You will know
**Day 5-7:** Check your CLAUDE.md. Is it still accurate? Add what you whether this changed how you work.
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 ## Growing from here
Your agent gets more useful the more you invest in it: **More agents.** As you notice new recurring patterns, create agents
for them. Each agent you add is a building block that any pipeline
skill can use.
**Add more skills.** Every task you do more than twice a week is a **More pipelines.** A pipeline is just a skill that calls agents in
candidate. A good personal setup has 3-5 skills after a month. sequence. Once you have 3-4 agents, creating a new pipeline for a
different workflow takes minutes.
**Add more tools.** MCP servers connect Claude to your services. **More integrations.** MCP servers connect your agents to external
Slack, Google Drive, calendar, databases. Each one extends what services: Slack, Google Drive, databases, APIs. Each integration
your agent can do autonomously. multiplies what your pipelines can do without manual data gathering.
**Add more agents.** The `.claude/agents/` directory can hold **Tighter security.** As automation increases, so should guardrails.
specialists for your domain. A "compliance checker," a "meeting prep" Add domain-specific hook patterns. Review audit logs. Set up alerts
agent, a "customer research" agent. Pattern: give each agent a role, for blocked actions that might indicate a prompt going wrong.
a scope, and clear instructions.
**Tune the security.** As you automate more, tighten the hooks. Add **Shared agents.** The agents and pipelines you build are markdown
patterns to the deny list. Review the audit log weekly. The more files. You can share them with colleagues, version control them, or
autonomous your agent is, the more important the guardrails. use them as templates for other projects. The system is portable.
--- ---
## Honest assessment ## Honest assessment
This setup will not replace your judgment, your relationships, or This system will not replace your expertise, your relationships, or
your taste. It replaces the scaffolding: the research, the formatting, your judgment. It replaces the scaffolding: gathering, formatting,
the status updates, the routine decisions, the cognitive overhead of cross-checking, delivering, and remembering. The work that has to
remembering where you left off. happen before and after the real thinking.
The people who get the most from it are the ones who are specific about The people who get the most from it share three traits:
what they need. A vague CLAUDE.md produces vague results. A precise one 1. They are specific about their domain in CLAUDE.md
produces surprisingly useful results from day one. 2. They iterate on agent instructions instead of accepting first-draft output
3. They actually use it for real work, not just demos
The time investment is real: one hour to set up, five minutes a week The time investment is real: 90 minutes to build, 15 minutes a week
to maintain. The return depends entirely on how well you describe your to maintain and improve. The return scales with how well you defined
work and how consistently you use it. your workflow in Phase 1. A system designed around vague goals
produces vague results. A system designed around "every Monday I need
X from sources Y in format Z" produces something you actually use.
Start with one skill. Make it genuinely useful. Everything else follows. If you followed the examples and built this system, you understand
more about personal AI agent architecture than most people in the
industry. Not because the technology is hard. Because the thinking
in Phase 1, designing your work as a system of agents, is the part
most people skip.