Prompt Library

The system you're about to build

Tip: every prompt block has a Copy button in the top-right corner.

How to use these prompts

These are build prompts — you give them to Claude Code (in your terminal, inside a project folder) and it writes the code with you. They work best when you:

1. Run them in order: backend first, then agents, then the extras.
2. Let Claude ask questions — answer with your own paths, API keys, and preferences.
3. Review each change before accepting. You're the architect; Claude is the builder.

The agent system

Build me a personal "agent OS" backend in Python with FastAPI. Requirements:

1. SQLite database (single file, agent_os.db) with tables: agents, messages,
   outbox, pipeline_items, tasks, projects. Create tables non-destructively on
   startup (safe to re-run) and seed initial data only if the tables are empty.

2. REST API with one route file per resource:
   - GET/POST /api/agents        — agent registry + heartbeat status
   - GET/POST /api/messages      — message log
   - GET/POST/PATCH /api/outbox  — the outbox (see below)
   - GET/POST/PATCH /api/tasks   — tasks with status cycle: todo → in_progress → done
   - GET/POST/PATCH /api/projects — projects; progress auto-computed from the
     ratio of completed tasks (fall back to a manual progress column if a
     project has no tasks)

3. An "outbox" pattern: agents write rows like {content, action, metadata,
   status}. Other agents poll it and dispatch by action type (e.g.
   send_telegram, send_email). Status flows: pending → sent.

4. A process manager route (POST /api/process/{name}/start and /stop) that
   spawns registered agents as subprocesses with subprocess.Popen, writes
   their logs to ~/.agent-os-logs/{name}-agent.log, and tracks PIDs.

5. A BaseAgent class every agent inherits from: registers itself in the
   agents table, runs a heartbeat loop, exposes write_to_outbox(content,
   action, metadata), and handles SIGTERM cleanly via start()/stop().

Use a virtualenv, requirements.txt, and uvicorn with --reload for dev.
No ORM needed — plain sqlite3 is fine. Ask me anything unclear before coding.

Build a "Mission Control" dashboard web UI for my agent-os backend
(FastAPI on http://localhost:8000). Requirements:

1. Tabs: COS (chief-of-staff overview), Team (agent cards), Outbox, Tasks,
   Projects.

2. Team tab: one card per agent showing name, status (alive/stale/dead based
   on last heartbeat), and Start/Stop buttons wired to
   POST /api/process/{name}/start and /stop.

3. Tasks tab: list from GET /api/tasks, click to cycle status
   (todo → in_progress → done → todo; blocked → todo).

4. Projects tab: list from GET /api/projects with progress bars
   (progress is computed server-side from task completion).

5. Poll the API every 5 seconds for live updates. Keep it dependency-light:
   plain HTML/CSS/JS or a single-file app is fine.

6. Dark theme, clean typography — this gets screen-recorded for YouTube,
   so it should look good at 1440p.

Show me a plan of the file layout before writing code.

Build a Router Agent for my agent-os system. It extends BaseAgent and is the
multi-channel entry/exit point:

1. Poll the outbox (GET /api/outbox?status=pending) on a short interval.
2. Dispatch by action type:
   - send_telegram → deliver via my Telegram bot (token in .env)
   - send_email    → hand off to the Email Agent
3. Also listen for inbound messages from Telegram and Slack, and write them
   into the messages table so other agents (and I) can see them.
4. Mark outbox rows as sent after successful delivery; leave them pending
   (with an error note in metadata) on failure so nothing is lost.
5. Heartbeat so Mission Control shows it alive. Handle SIGTERM cleanly.

Keep secrets in .env. Walk me through the Telegram bot setup (BotFather)
and Slack app setup as part of this.

Build an Email Agent (my "Inbox agent") for my agent-os system. It extends
BaseAgent and works with Gmail:

1. Authenticate with the Gmail API via OAuth. Store the token at
   data/gmail_token.json. If the token is missing or expired, open a browser
   for the OAuth flow when run directly in a terminal.
2. Monitor the inbox on an interval. For each new email, classify it with
   Claude (urgent / needs-reply / newsletter / ignore).
3. For needs-reply emails, draft a response with Claude and write it to the
   outbox for my approval — never auto-send. I approve from Mission Control
   or by telling Claude "approved".
4. Send Telegram notifications (via the Router Agent outbox pattern) for
   urgent emails.
5. Heartbeat + clean SIGTERM handling like my other agents.

Use the Anthropic API with a small fast model (Haiku) for classification to
keep costs low, and a bigger model only for drafting. Ask before coding.

Build a Calendar Agent for my agent-os system. It extends BaseAgent and works
with Google Calendar:

1. OAuth like my Email Agent — token at data/calendar_token.json, browser
   flow when run directly in a terminal if the token is missing/expired.
2. Watch the messages table for calendar-intent messages (e.g. "lunch with
   Ana Thursday 1pm"). Use Claude to parse them into structured events
   (title, start, end, attendees) and create them via the Calendar API.
3. Write a confirmation to the outbox (send_telegram) after creating an
   event, so I get a ping with the event details.
4. Morning summary: at a configurable time, write today's agenda to the
   outbox as a Telegram message.
5. Heartbeat + clean SIGTERM handling.

Same conventions as my other agents: .env for secrets, log to
~/.agent-os-logs/, registered with the process manager.

Build "Blinky", a morning content-scout agent for my agent-os system. It
extends BaseAgent:

1. Sources: HackerNews (Firebase JSON API), Reddit (r/MachineLearning,
   r/LocalLLaMA, r/artificial, r/singularity), GitHub search API (use
   GITHUB_TOKEN from .env if set, unauthenticated fallback), and a Substack
   RSS feed of my choice.
2. Pre-filter titles with a keyword list (AI-related terms) BEFORE calling
   Claude — saves tokens on obviously irrelevant items.
3. Score the surviving items with Claude Haiku on relevance/quality out of
   10. Threshold: 6.0 to make the digest.
4. Run daily at 07:00 local time. Sleep in 60-second chunks so SIGTERM is
   handled promptly.
5. Output two outbox entries: send_telegram (plain-text digest) and, if a
   DIGEST_EMAIL env var is set, send_email with an HTML version.
6. HTML email: render with pure Python f-strings (no Jinja2 — I don't want
   the dependency). Clean single-column layout, dark-friendly.

Same conventions as my other agents. Show me the scoring prompt you plan to
use before wiring it in.

Build me "Jarvis", a voice assistant that sits on top of my agent-os system.
It lives in its own project folder (~/jarvis) with its own virtualenv:

1. A WebSocket server on port 8765 as the realtime channel between the
   voice loop and any UI.
2. Announcements: poll my agent-os outbox (GET
   http://localhost:8000/api/outbox?status=sent) and speak completed
   actions aloud with TTS ("Blinky sent your morning digest", "Draft reply
   to Ana is ready for review").
3. Voice input: wake word, then speech-to-text, then route the transcribed
   command into agent-os as a message (POST /api/messages) so the other
   agents can act on it.
4. Register it with my agent-os process manager as agent name "jarvis" so
   Mission Control can start/stop it. On start, kill anything holding
   port 8765 first so the WebSocket port is always free.
5. Recommend the best local-first TTS and STT options for a Mac (M-series)
   and let me choose before you code.

Keep it modular: the announce loop, the voice loop, and the WebSocket
server should be separable pieces.

Adding your own prompts

This page is a plain HTML file. To add a prompt, copy any <div class="prompt-card"> block in site/prompts.html, paste it where you want it, and edit the title, tags, description, and prompt text. The copy button, search, and tag chips pick it up automatically.