From ccf274912724b42b9782ef3ad1c22d1ceec8e8f0 Mon Sep 17 00:00:00 2001 From: Kjell Tore Guttormsen Date: Thu, 26 Mar 2026 21:26:29 +0100 Subject: [PATCH] refactor: rewrite Example 14 as genuine capstone and fix skill creation 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) --- GETTING-STARTED.md | 128 ++--- examples/14-build-your-agent/prompt.md | 645 ++++++++++++++++++------- 2 files changed, 510 insertions(+), 263 deletions(-) diff --git a/GETTING-STARTED.md b/GETTING-STARTED.md index 2a20cb4..fe03a63 100644 --- a/GETTING-STARTED.md +++ b/GETTING-STARTED.md @@ -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 -assistant" into "my assistant that knows how I work." +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. -### Important: skill file format +### How it works -Every skill file needs YAML frontmatter between `---` markers at the top. -Without this, Claude Code will not recognize it as a skill. The `name` field -is what you type after `/` to run it. The `description` field helps Claude -decide when to suggest it. +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 `.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 +``` +Create a skill called "weekly-status" that generates my weekly +status report. It should: 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 +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 ``` -Now you can run `/weekly-status` every Monday morning. -Or text "Run /weekly-status" from your phone. +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 `.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] +``` +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`. -Customize it: add your news topics, your project context, -whatever you want to know first thing in the morning. +The repo already has `.claude/skills/daily-briefing.md`. To +customize it, just tell Claude: -### 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 -- Explain the same instructions to Claude repeatedly +- 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 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) > shows the researcher-writer-reviewer agent pattern that makes complex diff --git a/examples/14-build-your-agent/prompt.md b/examples/14-build-your-agent/prompt.md index 5743041..83ddc11 100644 --- a/examples/14-build-your-agent/prompt.md +++ b/examples/14-build-your-agent/prompt.md @@ -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 -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. +Examples 01-13 showed you individual capabilities: research, file +management, web search, agents, pipelines, messaging, automation, +security. Individually, each one is useful. Together, they form +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 -over the first week of use. +This is not "create a skill and connect your phone." You could have +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) -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 +### The three questions -This is the setup that makes people text their agent from bed and -find the answer waiting when they sit down with coffee. +**1. What do you do every week that follows a pattern?** ---- +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 -project directory (or use an existing one) and create `CLAUDE.md`. +Write down 3-5 tasks. Be specific about inputs, processing, and outputs. -Write it like a briefing for a brilliant new colleague on their -first day. Include: +**2. What roles would you hire for if you could?** -```markdown -# [Your Project or Life Context] +Not "an assistant." Specific roles with specific expertise: -## Who I am -[Your role, what you do day to day, what you care about] +- A **researcher** who tracks your industry and surfaces what matters +- 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 -[Communication preferences, formats you like, what annoys you] -[Example: "Be direct. Skip caveats. Bullet points over paragraphs."] +Write down 2-3 roles. For each: what do they know, what do they produce, +what quality standard must they meet? -## What I am working on right now -[Your top 3-5 priorities with deadlines if they exist] +**3. What must never happen automatically?** -## What Claude should never do -[Hard boundaries. Things that would break trust.] -[Example: "Never send anything externally without my explicit OK"] +The safety question. When your system runs at 07:00 on Monday without +you watching: -## Tools and accounts -[What MCP servers are configured, what services you use] -[Example: "Slack MCP connected to workspace X. Telegram channel active."] +- What actions should be blocked? (sending emails, deleting files, accessing certain APIs) +- What should always be logged? (all external calls, all file writes, all web searches) +- 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 - -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. +This is the same architecture as Example 10, adapted to your work. +You are not inventing something new. You are configuring a proven +pattern for your specific context. --- -## 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 -have this week. +Open your project directory in Claude Code. Your first step is not +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: -- 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 +### The prompt -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 ---- -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] +Ask one category at a time. After all five, write a CLAUDE.md that +would let you handle my Monday morning without additional context. ``` -### 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, -you just automated a recurring task. If not, refine the instructions -and run it again. Most skills take 2-3 iterations to get right. +After Claude writes it, check: -**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. +| Criteria | Test | +|----------|------| +| 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): -```bash +### Create your first agent + +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 ``` -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 the setup for your chosen channel (Telegram recommended +for first setup). See `messaging/` in this repo for detailed guides. + +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 -a personal assistant you can reach from anywhere. +The real test. From your phone, send: + +``` +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:** -``` -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. -``` +### Pick a real task -**For a weekly task:** -``` -/schedule "Run /[your-skill-name] and send me the result via Telegram" -at [next Monday]T07:00:00 -``` +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 +briefing, a real analysis. -### Test it - -Create a `/loop` test first to verify the flow works before committing -to a cron job: +### Run it ``` -/loop interval=120 - -Run /[your-skill-name]. Send the result to [your channel]. -Then wait for the next interval. +/weekly-[your-workflow] ``` -If the output arrives on your phone every 2 minutes, the automation works. -Replace with a real schedule. +### Evaluate honestly -**Pattern from Example 08:** /loop for testing, CronCreate for daily -drivers, /schedule for remote triggers. +Read the output. Compare it to what you would have produced manually. + +**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. -``` -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. +A GETTING-STARTED reader has a Claude Code setup with preferences. +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. --- -## What you have now +## Your first week -| 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/` | +**Day 1:** Run the pipeline manually. Fix what is wrong with the +output. Refine agent instructions. -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. +**Day 2:** Run it again. Compare to yesterday. Is it better? +Add domain knowledge to CLAUDE.md that would have prevented +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 -gets wrong or could improve. Edit the skill file. +**Day 6-7:** Review your hooks and audit log. Are the right things +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 -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. +**After one week:** You have 1-2 automated pipelines, 2-3 specialized +agents, and a growing memory of your work context. Routine Monday +tasks take one phone message instead of two hours. You will know +whether this changed how you work. --- ## 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 -candidate. A good personal setup has 3-5 skills after a month. +**More pipelines.** A pipeline is just a skill that calls agents in +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. -Slack, Google Drive, calendar, databases. Each one extends what -your agent can do autonomously. +**More integrations.** MCP servers connect your agents to external +services: Slack, Google Drive, databases, APIs. Each integration +multiplies what your pipelines can do without manual data gathering. -**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. +**Tighter security.** As automation increases, so should guardrails. +Add domain-specific hook patterns. Review audit logs. Set up alerts +for blocked actions that might indicate a prompt going wrong. -**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. +**Shared agents.** The agents and pipelines you build are markdown +files. You can share them with colleagues, version control them, or +use them as templates for other projects. The system is portable. --- ## 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. +This system will not replace your expertise, your relationships, or +your judgment. It replaces the scaffolding: gathering, formatting, +cross-checking, delivering, and remembering. The work that has to +happen before and after the real thinking. -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 people who get the most from it share three traits: +1. They are specific about their domain in CLAUDE.md +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 -to maintain. The return depends entirely on how well you describe your -work and how consistently you use it. +The time investment is real: 90 minutes to build, 15 minutes a week +to maintain and improve. The return scales with how well you defined +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.