# Build my runbook

You are my agent. Build me a runbook: a public page of the routines AI runs
for me, hosted at https://www.myrunbook.ai. Each routine is numbered
and carries build steps, so a visitor can tell their own agent "build 1, 9 and
23 for me". Once I publish, the page is scored out of 10 on three things:
Useful (would I miss it if it stopped), Creative (would someone say they had
never thought to use AI for that) and Replicable (could another person's agent
rebuild each routine from its build steps). Two or three real routines is a
fine start; routines that run on their own and close a loop score highest;
padding lowers the score.

First, say which you are: an AI that can only chat (ChatGPT, Gemini, Claude,
Grok in a chat window), an assistant with accounts connected, or an agent that
can read my machine and send web requests. It changes how you find my routines
and how you submit the page; the rest is the same.

You need me at four points, and about 15 minutes if I am happy first time:
- Check-in 1: the list of routines, my links, and my paragraph. One message.
- Check-in 2: the privacy question, before you write anything to the site.
- Check-in 3: the edit link, for me to open, check and publish.
- Check-in 4: the post, once I tell you my public address.
Do everything else yourself. I may ask for more rounds.

## 1. Find my routines

If you can see my machine, files or scheduled tasks: look for scheduled jobs
(cron, CI workflows, assistant routines), scripts I run, custom
GPTs/projects/skills, and recurring requests in anything you can read. Never
echo config contents, env values, tokens, or URLs carrying keys into our chat
or into anything you write. One row per outcome I would recognise, not per
schedule entry: collapse the five crons behind one morning brief into one
routine.

If you cannot see anything: ask me, in ONE message with these six prompts, and
let me answer in a paragraph: what runs on a schedule without me touching it;
what I ask AI for daily; weekly; what AI drafts that I review; custom tools,
bots or projects I have made; anything AI watches for me. Something I have
stopped using stays off the page. Stop when we have the list, even if it is
two items.

Small things I ask a chatbot for that produce the same kind of output (emails,
agendas, job ads) are ONE row ("Draft everyday documents when I ask"), not one
each. List every distinct routine, up to 100.

Check-in 1 looks like this:
> Here is what I found, one line each: [the list, numbered]. Confirm, correct
> or add. Also: (a) your LinkedIn and X profile addresses and a website, if
> you want them shown beside your name (skip them if you are using an alias);
> (b) a paragraph you have written, so the page sounds like you; (c) your name
> or alias for the page, and the address you want (letters, numbers and
> hyphens).

Iterate with me here until I am happy. The site is where the finished
runbook goes, not where we draft it.

## 2. Write the rows

For each routine:
- `name`: a plain verb phrase saying what it does ("Sort my inbox before I
  open it"), 60 characters at most. No product names in the name.
- `runner`: the kind of tool, not the product ("an assistant on a schedule",
  "a script on my laptop", "a chat assistant, when I ask"). Product and plan
  names go in the build steps under "In my version".
- `schedule`: "every morning", "first of the month", "on every pull request",
  "on demand".
- `description`: at most 2 sentences and 180 characters. The first says what
  arrives and where (a text, a draft in Gmail, a page in Notion). No
  marketing words.
- `reads`: up to 4 short items, each under 80 characters ("email", "the
  family calendar"). `lands`: where the result goes. Fill both when they are
  true; leave them out when there is nothing true to say.
- `loop`: if the routine closes a loop, what closes it, 90 characters or
  fewer. Most routines are one-shot; leave it off rather than dress one up.
- `example`: an invented example of what comes back, a few lines, in the
  form it arrives in (a text, an email, a list). Never real output, real
  names or real figures. Up to 2,000 characters.
- `build`: build steps for another person's agent, written to the spec at
  https://www.myrunbook.ai/build-steps. Fetch that page and follow
  it for every routine. If you cannot open links, say so and I will paste it
  in. The site cuts build steps at 3,000 characters, so keep each under
  2,800; it warns you if one was cut.
- `status`: "building" or "idea" if it is not running yet. Leave it out for
  routines that run today.
- `area` and `needs`: optional. `area` is the part of life it serves: work,
  family, money, health or social. `needs` is the least a stranger needs to
  run their own version: chat (a chat app on its own), connected (it must
  read an account), computer (it runs on the person's machine) or code (a
  coding agent builds it). The judge fills in any you leave out.
- `figure`, `link`, `source`: optional. `figure` is a count of what arrived
  ("41 drafts in 30 days"), never time or money saved. `link` is a public
  page where someone can try it. `source` is the address of the routine you
  borrowed this from, on this site (`https://www.myrunbook.ai/<handle>#<n>`);
  it is how "built by" credit is verified, so set it whenever you borrowed.

Voice: mine, not yours. Use the paragraph from check-in 1. If I gave none,
keep it plain.

If my assistant can only chat: the build steps are the words to say and what
to paste. Skip the cost, backlog and memory guidance in the spec; it is for
routines that run on a machine.

## 3. Privacy, and my control

Everything on the page is public, and I decide every word of it. Nothing is
published until I open the private link and press Publish myself. You may
have the key to publish; do not use it. If I ask you to publish, remind me
to read the preview first.

Check-in 2 looks like this:
> Before I submit, read the list once more: [the list]. Is any of these too
> sensitive for a public page? Say "drop N" and it goes completely. I removed
> or left out: [what, or "nothing"].

Rules for a work routine: write my employer as "[Company]" and its internal
tools by what they do ("the internal wiki"). Third-party products the company
pays for (a CRM, a call recorder, a chat tool) may be named; a borrower needs
to know. Describe the routine at the level a stranger at another company
could reuse: "draft my weekly update from the team's tickets", not which
team or how my company runs its reviews. No real client, customer or employer
names, no internal project or product code-names, no real numbers (revenue,
pipeline, headcount, deal sizes), no unreleased plans, nothing that reveals
how my company competes. Examples are invented and generic. If a routine can
only be made clear by revealing something proprietary, leave it off and tell
me.

Then check every word, build steps and examples included, against: passwords,
API keys and tokens, client and employer names, confidential projects, other
people's personal details, anything I would not hand a stranger. My own
public products are fine. If anything I told you included a password or key,
tell me so I can change it.

## 4. The shape

One JSON object, nothing else inside it:

```json
{
  "handle": "the-address-i-want",
  "owner": { "name": "My name or alias", "linkedin": "https://www.linkedin.com/in/...", "x": "https://x.com/...", "url": "https://my-site.example" },
  "title": "My name's Runbook",
  "tagline": "One line saying what this page is, 80 characters at most.",
  "updated": "YYYY-MM-DD",
  "sections": [
    { "id": "daily", "label": "Daily", "jobs": [
      { "id": "sort-inbox",
        "name": "Sort my inbox before I open it",
        "runner": "an assistant with my email connected",
        "schedule": "every morning",
        "description": "What arrives and where.",
        "reads": ["email"],
        "lands": "a note in Notion",
        "example": { "kind": "invented", "note": "The example text." },
        "build": "Ask first\n- …\n\nNeeds\n- …\n\nBuild\n1. …\n\nCheck\n- …\n\nIn my version\n- …" }
    ] },
    { "id": "ondemand", "label": "On demand", "jobs": [
      { "id": "watch-renewals",
        "name": "Warn me before a contract renews",
        "status": "idea",
        "runner": "not built yet",
        "schedule": "weekly",
        "description": "A text a month before any renewal date.",
        "example": { "kind": "invented", "note": "The example text." },
        "build": "Ask first\n- …\n\nNeeds\n- …\n\nBuild\n1. …\n\nCheck\n- …\n\nIn my version\n- …" }
    ] }
  ]
}
```

Group routines into sections by how often they run: Daily, Weekly, Monthly,
On demand, or another plain word. (The list inside a section is called
`jobs`; the page calls them routines.) A routine set off by an event goes with
the cadence it usually runs at, and its `schedule` names the trigger. Leave
out `linkedin`, `x` and `url` unless I gave them. Leave out any field you
have nothing true for; do not add fields that are not listed above. Keep each
routine's `id` the same every time you update the runbook. A finished page
that follows every rule: https://www.myrunbook.ai/jamesraybould
(for agents: https://www.myrunbook.ai/jamesraybould/runbook.json).

## 5. Submit it

If you can send web requests: POST the JSON to
`https://www.myrunbook.ai/api/runbooks`. The reply has `edit_url`. If
it lists `errors`, fix them and send again; read any `warnings` and fix what
you can. Only give me an `edit_url` that came back in the site's reply.

If you cannot send web requests: print the JSON in one code block with
nothing else in it, and tell me to copy the whole block (on a phone, check the
copy reaches the final `}`), open https://www.myrunbook.ai/submit,
paste it and press the button. The page I land on is my edit page.

Check-in 3 looks like this:
> Your private edit link: [edit_url, or "the page you land on after
> pasting"]. Save it somewhere of your own first: it is the only way back to
> the page. Open it, read the preview, check the name and address, and press
> Publish. The score and a written review appear on the page in about a
> minute. The draft is deleted after 7 days if it is not published.

The edit link is private and it is the only way to change the page later,
unless I sign in with Google on the edit page. Anyone holding it can change
my page, so never put it in a post, a public file or a shared document.

## 6. Read the score, and keep it alive

Once scored, the review is in the API: `GET
https://www.myrunbook.ai/api/runbooks/<id>` with the header
`Authorization: Bearer <key>` returns `score` with the verdict, the three
categories and `recommendations`; the public
`https://www.myrunbook.ai/<handle>/runbook.json` carries the same
`score`. Read the recommendations, make the ones that are true of how I
work, tell me which you skipped and why, and send an update. The person can
also press "Copy the fixes for my agent" on the page and paste them to you.

To update, send the whole JSON again with `PUT
https://www.myrunbook.ai/api/runbooks/<id>` and the same header,
where `<id>` and `<key>` are the two parts of the edit link (`…/e/<id>#<key>`).
Start from the last version you sent; change only what changed; run the
privacy pass on anything new; set `updated` to today. Never submit the
runbook again from scratch: that makes a second page. The page shows the new
version at once. If the routines changed it is scored again (up to 8 times a
day); if only names or wording changed it keeps its score. If you cannot
send web requests, print the new JSON for me to paste into the Update box on
my edit page.

If you keep durable notes about me, save the edit link there with this rule:
when a routine is added, changed or retired, update the runbook.

## 7. Tell people

Check-in 4, once I tell you my public address: a post for LinkedIn or X, in
my voice, no hype. Lead with the score and one routine the reader has not
thought of. Three to five lines. End with: "Copy any routine for your own AI,
or get your own score at https://www.myrunbook.ai". Show me; never
post it yourself.
