Skip to content
Back to skills

Routine Run

ASecurity

Write a routine for the Routine Run iPhone and Apple Watch app, in the JSON form the app reads. Use it when somebody asks for a routine, checklist or runbook for Routine Run or to paste into it, and when they want steps to walk through one at a time on their iPhone, Lock Screen or Apple Watch, even without naming the app.

  • 2 stars
  • 0 votes
  • 0 copies
  • 0 views
  • Added November 18, 2026
ai-agentsgoapi

Works with

  • cli
  • api
  • mcp

Security analysis

A100/100

Scanned November 18, 2026

npx -y skills add routinerun/routinerun --skill routine-run --agent claude-code

Installs into .claude/skills of the current project.

Are you the author of Routine Run?

Add the live security badge to your README. It updates with every re-scan.

Security grade badge for Routine Run
[![Security: A — Skills Directory](https://www.skillsdirectory.com/api/skills/routinerun-routine-run/badge)](https://www.skillsdirectory.com/skills/routinerun-routine-run)

More formats (shields.io, HTML) on the badges page. Keep it an A: scan every change in CI with Pro.

Download with Pro
SKILL.md
---
name: routine-run
description: Write a routine for the Routine Run iPhone and Apple Watch app, in the JSON form the app reads. Use it when somebody asks for a routine, checklist or runbook for Routine Run or to paste into it, and when they want steps to walk through one at a time on their iPhone, Lock Screen or Apple Watch, even without naming the app.
---

# Writing a routine for Routine Run

> Routine Run is an iPhone and Apple Watch app that walks somebody through a routine one step at a time. When somebody asks you to write a routine for it, this is how. What follows is word for word the request the app itself sends to an assistant, written in the voice of the person asking. Follow it, and ask them what the routine is for if they have not said.

I use an iPhone app called Routine Run. It walks me through a routine step by step. Please write me a routine for it, in the form below, so I can paste your answer straight into the app.

REPLY WITH ONE JSON OBJECT in a single code block, and nothing inside the block but the JSON — no comments. Anything you want to tell me goes after the block.

AFTER THE BLOCK, say in a sentence or two what you made and anything you had to assume. Then remind me to copy the JSON and open https://routinerun.com/w on my phone. That opens the app on the page that reads it, with what I copied already in it, and it shows me what would change before anything is written.

THE FORM (version 2):
- "routineRun": 2 — always.
- "name": what the routine is called.
- "description": one or two sentences on what it is for. If a step needs something the app cannot do by itself — a shortcut I have to make, an app I need — say so here.
- Every "description" is Markdown, drawn as such: **bold**, *italic*, a list ("- " or "1. " lines, separated by \n), and [links](https://…), which are tappable. Reach for a list where the step is a handful of things to check or bring; plain sentences otherwise. No headings, tables or pictures.
- "symbol": an SF Symbols name, like "sunrise" or "timer". Leave it out if unsure.
- "colour": one of red, orange, yellow, green, mint, teal, blue, indigo, purple, pink, brown, grey. A colour already written as a hex, like "#2E7D4F", is one I chose: keep it exactly as it is.
- "values": optional named values the routine keeps, as "name": value — words, a number, true or false, or a link.
- "steps": the steps, in order. Each has "title" (what to do, as an instruction), and may have "description" (how or why, and the tip that saves a beginner — a sentence or three, or a short list), "symbol", "colour", "minutes" (if it runs on a clock), "repeats" (how many times in all, if it is done more than once), "values", "deadline" (a time it has to keep, below), "does" (actions that happen when the step is reached), "buttons" (actions that wait for me to press them; give each a "title" beside its word, like {"set": {"key": "a14", "to": "ok"}, "title": "Got it"}, when two would read the same, and "onNext": true beside one that pressing Next on the step should press too — the button at the end that asks for the next one) and "links".
- "notes": optional, on the routine or on a step, things worth knowing that are not something to do — "The oven runs hot." — as a list of strings, each Markdown. Leave them out rather than repeating the "description".
- "triggers" on a step: optional check-ins, for a step that waits on something I cannot hurry — a parcel, a reply, dough rising. Each asks its "question" from when a run reaches that step until I answer it: [{"question": "Has the parcel come?", "when": {"every": {"hours": 3}, "between": [9, 18]}}], or "when": {"at": "17:00"} to ask at five. Leave them out everywhere else; "followUp" is for a step I put down myself.
- "runName": for a routine with several runs going at once, what each is called, naming a value — "Due diligence: {param:company}" — so the runs read "Due diligence: Acme" rather than "Due diligence 3".
- A step's "title" and "description" may name one of the routine's "values" as {param:name}, for what is only known on the day — "Go to window {param:window}" reads "Go to window 7" once the run is told 7, and "…" until then. Give the value in the routine's "values", empty if nobody knows it yet.
- "links" on a step: things worth opening while doing it — a how-to video, a recipe, a map — as [{"title": "Fixing a dripping tap", "url": "https://…"}]. Only links you are sure exist. For a video, a YouTube search link (https://www.youtube.com/results?search_query=…) is better than a video you cannot check.
- "deadline" on a step: {"at": "09:00"} if it has to be FINISHED by then — being somewhere, a call, a deadline. Give that step its "minutes" too: it begins at its "at" less its minutes, whatever I am doing, and an alarm tells me. Anything still in front of it is skipped unless the deadline's "late" says otherwise.
- WHEN I GIVE A TIME THE WHOLE ROUTINE HAS TO BE DONE BY — "finish by 11:30", "out of the door at nine" — give every step up to that time a "deadline", not only the one that meets it: that step's "at" is my time, and each one before it is the next step's "at" less the next step's "minutes". Only the step that meets my time rings an alarm: give each one before it "tellMe": "notification". With 20 minutes of breakfast and 15 of getting ready for work done by 11:30, breakfast is {"at": "11:15", "tellMe": "notification"} and getting ready {"at": "11:30"}. Otherwise only one step knows the clock, and the rest run late without a word.
- "kind": "startBy" in a deadline — {"at": "08:30", "kind": "startBy"} — if the step is only worth doing when begun by then, like coffee before leaving. After that time it is skipped. Left out, the step is done by its "at".
- "at" can also be a whole date, "2026-10-03 13:00", for a deadline on another day — a report due Friday. A routine with a date in it is for once, so say so after the block: I will start it rather than keep it.
- "day" in a deadline: 2 means its "at" is on the second day of the run, for a routine that takes more than a day — the tap washer on the second evening. Counted from the day I start it, so it works every time.
- "from" in a deadline, instead of "at": counted from a date in "values" — {"from": {"value": "appointment", "days": -3}} is three days before it. Put the date itself in "values" as "appointment": "2026-10-06 10:00". This is how a routine I run again and again can have deadlines: each time, only the date changes.
- "from" can name instead a date several routines share, like a trip — {"from": {"date": "Departure", "days": -1, "hours": 19}} is seven in the evening the day before. Name each date once in "dates" with its day: [{"name": "Departure", "on": "2026-11-14"}] — or without "on" if I have not fixed the day yet: everything waits and starts once I set it. If I already have a date by that name, mine is used and keeps its day, so moving my trip moves every step counted from it. Use a named date when what I said hangs off an event — a trip, a launch, a move — rather than off a run.
- "within" in a deadline, instead of "at": how long after I start the run the step has to be done by — {"within": {"minutes": 60}} for "be there an hour after I set off". Use it whenever what I said was about how long the whole thing takes rather than about the clock: written as a time of day, that routine is late from its first second every morning I start it five minutes behind.
- "late" in a deadline: optional, "skip", "keep" (do what was in the way afterwards) or "ask" (just tell me, move nothing). Left out, a time of day skips and anything with a date or a day asks.
- "tellMe" in a deadline: optional, how the time reaches me: "alarm", "notification", "calendar" (an event in my day) or "reminders" (a reminder with a box to tick). Left out, a done-by on a time of day rings an alarm and everything else is a notification. For a deadline days off, "reminders" is usually what I want.
- "warn" in a deadline: optional, how far ahead to tell me as well — {"hours": 24} for the day before, {"hours": 0} for never. Left out, anything more than a day off is said the day before.
- "startsFrom": optional, when it should offer to start counted from a named date: [{"date": "Departure", "days": -3, "at": "19:00"}], or in minutes from the date's own time: {"date": "Go out", "minutes": -120} is two hours before.
- "followUp" on a step: how I usually put this step down when I am waiting on somebody — {"days": 2, "at": "10:00", "workdays": true, "soonerIf": "reply"} comes back in two working days at ten, or as soon as something arrives with "reply" in it. Only that step is put aside; the rest of the run goes on. Add "wholeRun": true only when nothing after it can be done without the answer. Give it to a step that sends a message, an application or a request; leave it out everywhere else.
- "asksWhatToKeep": false for a routine that is a list of errands rather than a template — today's jobs, this week's shopping, a one-off plan. Left out, a run of it asks at the end which of the things it collected belong to the routine from now on, which is the point of a routine I keep improving and a chore with one answer for a list of errands. Decide it from what I described rather than asking me.
- "rounds": optional, for steps that repeat as a group: {"from": 2, "through": 3, "repeats": 4}, counting steps from 1. Leave "repeats" out to go round until I stop.
- "triggers": optional, when it should offer to start: [{"when": {"at": "07:00", "weekdays": ["mon", "fri"]}}]. Weekdays are mon, tue, wed, thu, fri, sat, sun; leave "weekdays" out for every day.
- "order": optional, for a routine somebody else walks from a code — a car handed over, a visit to a counter: "inOrder" lists every step but opens only the one in hand, with no Later; "oneAtATime" shows only what is done and the step in hand. Leave it out for anything I walk myself.
- "waitsOut": true on a step with "minutes" when Next should wait until they are up — photos that have to be taken, a mask left on. Leave it out everywhere else.
- "severalAtOnce": true only if two runs of it can sensibly be going at once.
- "once": true if this happens once — a plan for today, a one-off job, a trip. When its run is finished it goes to the archive rather than staying among my routines. Leave it out for anything I will do again.
- "staysOpen": true for a list that is never done — things to read later, to watch, an inbox. It waits when it is empty instead of finishing, and I send things to it from the share sheet. It can have no steps at all: its steps are what I send it.
- "nudge": optional, only with "staysOpen": the time of day, like "18:00", it tells me once how much is waiting in it. Leave it out unless I ask to be reminded.
- "tags": optional, one to three words I file routines under, like ["Morning", "Home"]. Use a word I have used; otherwise leave it out rather than inventing a filing system for me.

THE ACTIONS, and these are the only ones — each is one word and what it is about:
- {"shortcut": "Name of a shortcut"} or {"shortcut": {"name": "Focus On via Routine Run", "input": "Work"}} — runs a Shortcuts shortcut by its exact name, handing it the input if there is one
- {"open": "https://example.com"} — opens a link
- {"say": "Words to say"} or {"say": {"text": "idempotent", "lang": "en-US"}} — says the words out loud, in my phone's language unless "lang" names another
- {"copy": "Text"} — puts the text on the clipboard
- {"note": "What to write down"} — asks me to write a note, with this as the prompt
- {"count": "reps"} — adds one to a number value
- {"set": {"key": "mood", "to": "calm"}} — sets a value
- {"add": {"key": "water", "number": 250}} — adds a number to a value
- {"addLine": {"key": "log", "text": "Done"}} — adds a line to a text value
- {"now": "startedAt"} — sets a value to the current moment
- {"howLong": "plankTime"} — keeps how long this step took
- {"run": "next"} — moves the run on: next, pause, finish or stop
- {"putAside": "followUp"} or {"putAside": {"days": 2, "at": "10:00", "workdays": true}} — puts this step aside and brings it back then, while the run goes on — "followUp" is the step's own followUp, a name is one of my own Not now answers, an object is a followUp said here
- {"deadline": {"at": "17:00", "kind": "startBy"}} — gives this step a deadline counted from the press: "hours" from now, or "at" the next time it is that time ("days" on); "kind" is by or startBy, "late" skip, keep or ask, "tellMe" as for a step
- {"checkIn": {"every": {"days": 3}, "at": "10:00", "question": "Has it arrived?"}} — asks a question about this step, or the run with "about": "run", once ("hours" or "at") or "every" so many minutes, hours or days until it is answered; meanwhile the step goes to the end or the run pauses unless "meanwhile" is false; "answers" are now, later, last or skip for a step and resume, pause, next, finish or stop for a run
- {"webhook": {"url": "https://example.com/hook", "method": "POST", "headers": {"Authorization": "Bearer {secret:example}"}, "body": {"run": "{instance}", "step": "{step}"}}} — sends a request to a server; method is GET, POST, PUT or DELETE, POST if left out
- {"event": {"title": "Focus", "in": 0, "minutes": 50}} — puts an event in my calendar, starting in so many minutes and lasting so many
- {"reminder": {"title": "Send the invoice", "in": 60, "list": "Work"}} — adds a reminder to Reminders, due in so many minutes
- {"alarm": {"title": "Tea is ready", "in": 4}} — rings an alarm in so many minutes
- {"scene": "Movie night"} — runs a Home scene by its exact name
- {"health": {"log": "water", "amount": 250}} — writes to Health: water (ml), mindful (minutes) or weight (kg)
- {"homeassistant": {"call": "light.turn_off", "entity": "light.living_room"}} — calls a Home Assistant service; "data" adds fields, "address" is where it answers if not homeassistant.local
- {"slack": {"text": "{instance} is done"}} — posts to a Slack channel through its incoming webhook
- {"ntfy": {"topic": "my-topic", "text": "Time to leave", "title": "Routine Run"}} — pushes a message through ntfy, to a topic I name
- {"pagerduty": {"action": "acknowledge", "key": "{param:incident}"}} — triggers, acknowledges or resolves a PagerDuty incident; trigger needs a summary
- {"ifttt": {"event": "leaving_home", "values": ["{instance}"]}} — fires an IFTTT webhook event with up to three values
- {"discord": {"text": "{instance} is done"}} — posts a message to a Discord channel through the channel's webhook
- {"googlechat": {"text": "{instance} is done"}} — posts a message to a Google Chat space through its webhook
- {"healthchecks": {}} — tells a Healthchecks.io check that this happened, so it can say when one day it did not
- {"pushover": {"text": "{instance} is done"}} — pushes a notification to your devices through Pushover; "title" may be left out
- {"telegram": {"chat": "123456789", "text": "{instance} is done"}} — sends a message from your own Telegram bot to a chat you name
- {"zapier": {"text": "{instance} reached {step}"}} — starts a Zap that begins with Webhooks by Zapier, Catch Hook, handing it the run, the step and a message; "text" may be left out

TIMES I HAVE TO KEEP. If I mention being somewhere at a time, leaving at a time or finishing by a time or a date, put it on the step as its "deadline" — never only in "description". That is what makes the app wake me, warn me the day before, and drop what does not fit.

ASK FIRST if something that changes the steps is unclear — what time I have to be somewhere, how long the travel is, what I already have. Up to three short questions, then the JSON once I answer. If it is clear, write it straight away.

WHAT REACHES PAST MY PHONE. A webhook, an event, a reminder, an alarm, a Home scene and a Health entry each arrive switched off: nothing is sent or written until I have looked at it in the app and said Allow. So write them where the routine needs them. The one exception: on a run you start for me, a button whose webhook I have allowed for you from now on works at once, "onNext" or not — so for a webhook I use every day keep the address, the method and the secret names exactly as before, and change only the body. Never put one in "does": a webhook that goes when the step is reached always waits for my Allow. Never put a password, a token or a key in one — write {secret:short-name} where it goes and tell me after the block which secrets to add; I paste each one in once, on my phone. Only name a Home scene I have told you I have, and only name a shortcut I have told you I have or one of these, which the app offers to add in one tap — use them rather than inventing one:
- "Focus On via Routine Run": Turns on the Focus it is given by name, or Do Not Disturb if none, until it is turned off. Input: the name of a Focus that exists on the phone, like Work — or nothing, for Do Not Disturb.
- "Focus Off via Routine Run": Turns off whichever Focus is on.
- "Do Not Disturb For via Routine Run": Turns on Do Not Disturb for as many minutes as it is given, thirty if none. Input: a number of minutes.
- "Low Power On via Routine Run": Turns Low Power Mode on.
- "Low Power Off via Routine Run": Turns Low Power Mode off.
- "Volume via Routine Run": Sets the volume to the percentage it is given, fifty if none. Input: a percentage, 0 to 100.
- "Brightness via Routine Run": Sets the screen's brightness to the percentage it is given, fifty if none. Input: a percentage, 0 to 100.
- "Play Playlist via Routine Run": Plays an Apple Music playlist by name, shuffled. Input: the playlist's exact name.
- "Start Timer via Routine Run": Starts a timer in Clock for the minutes it is given, twenty-five if none. Input: a number of minutes.
- "Wi-Fi Off via Routine Run": Turns Wi-Fi off.
- "Bluetooth Off via Routine Run": Turns Bluetooth off.
- "Airplane Mode On via Routine Run": Turns Airplane Mode on.
- "Airplane Mode Off via Routine Run": Turns Airplane Mode off.
- "Open App via Routine Run": Opens any app on the phone by its name, including the ones with no link to open them by. Input: the app's name as it reads on the Home Screen, like Notes or Spotify.
A webhook's body can use the same placeholders as anything else a step says: {instance}, {step}, {stepNumber}, {state}, {param:key}. For Home Assistant, Slack, ntfy, PagerDuty, IFTTT and every other service in the list above use its own word rather than "webhook": the app knows their addresses and asks me for the key, so you never have to guess either. A second channel of the same service is the same word with "secret" naming its own key, like "secret": "discord-team".

MAKE IT WORTH HAVING. On a step somebody could get stuck on, put the one tip that matters in its "description" and a link to a how-to — a video search for the exact job is better than a guess. LEAVE "minutes" OUT unless I give a length or the step is timed by its nature — a plank, tea steeping, a focus block — or it has a "deadline". A step with minutes runs a timer and rings when it ends, which on "pack the bag" is only noise; most steps have none. If I mention a time, a deadline or an appointment, it goes on the step as its "deadline". If what I describe is a list I keep adding to — reading, watching, things to deal with — make it "staysOpen".

KEEP IT SMALL. Steps are instructions a person reads while doing them: short titles, one idea each, said as what to do rather than what to stop — "Phone face down on the desk", not "No phone". Most routines are four to eight steps; for a habit I am only starting, the first version is the two or three steps that matter, and it grows once I keep it. Where one thing gives way to another — screens off, out of the door — the step before says what is coming, or the step's "deadline" warns ahead with "warn": {"minutes": 5}. On a step people often miss, its "description" says what to do when it cannot be done today: "No time: the ten-minute version."

GIVE EVERY STEP A "symbol", an SF Symbols name that fits what the step is — "cup.and.saucer" for tea, "shower" for a shower, "figure.walk" for a walk. A step's mark is how it is recognised at a glance on the lock screen and the watch.

WRITE IN MY LANGUAGE: the name, every description, title, tip and note, in the language of what I wrote below — not in the language of these instructions.

IF WHAT I PASTE IS A WRITTEN PROCEDURE — an SOP, a runbook, a checklist from work — keep its steps and their order, and give its other parts the form's places: its purpose is the routine's "description"; its preparation — what to have ready, who to tell — is the first step; each item of its checklist is a true or false value on the step it belongs to, like "values": {"Guard fitted": false}, or a step of its own where checking it is the whole job; who owns it, its version and when it is reviewed go in the routine's "notes", with the question for that review, "Is this still the best way?". Its revision history and sign-offs are not steps.

EXAMPLES, two from routines the app ships with and one against the clock:

```json
{
  "colour" : "orange",
  "description" : "Its timers reach you with a card; set one to wake you if the phone will be face down.",
  "name" : "First half hour",
  "routineRun" : 2,
  "steps" : [
    {
      "minutes" : 1,
      "title" : "Water, before coffee"
    },
    {
      "description" : "Neck, shoulders, hips. Long enough to count, short enough that you do it.",
      "minutes" : 3,
      "title" : "Move for three minutes"
    },
    {
      "description" : "Not the inbox. The inbox is somebody else's list of what your morning is for.",
      "title" : "Read only what you chose to read"
    },
    {
      "description" : "One. A morning that produces three is a morning that produced none.",
      "title" : "Name the one thing today is about"
    }
  ],
  "symbol" : "sunrise",
  "triggers" : [
    {
      "when" : {
        "at" : "07:00",
        "weekdays" : [
          "mon",
          "tue",
          "wed",
          "thu",
          "fri"
        ]
      }
    }
  ]
}
```

```json
{
  "colour" : "pink",
  "description" : "Twenty-five minutes, five off, four times, then a long one. Its timers reach you with a card; set one to wake you if the phone will be face down.",
  "name" : "Pomodoro, four rounds",
  "rounds" : {
    "from" : 2,
    "repeats" : 4,
    "through" : 3
  },
  "routineRun" : 2,
  "steps" : [
    {
      "description" : "One line. The rounds are cheap; deciding what they are for is the part that gets skipped.",
      "title" : "Write what the four rounds are for"
    },
    {
      "description" : "Twenty-five minutes on that one thing. Anything else that comes up gets written down, not done.",
      "minutes" : 25,
      "title" : "Focus"
    },
    {
      "description" : "Away from it. The round after a break you skipped is the round that goes badly.",
      "minutes" : 5,
      "title" : "Five off"
    },
    {
      "description" : "Fifteen minutes, and away from the desk for them.",
      "minutes" : 15,
      "title" : "The long one"
    }
  ],
  "symbol" : "timer"
}
```

```json
{
  "colour" : "orange",
  "description" : "Out of the door in time for nine, with whatever does not fit dropped on the way.",
  "name" : "School run",
  "routineRun" : 2,
  "steps" : [
    {
      "deadline" : {
        "at" : "08:20",
        "kind" : "startBy"
      },
      "minutes" : 5,
      "title" : "Make coffee"
    },
    {
      "deadline" : {
        "at" : "08:35",
        "tellMe" : "notification"
      },
      "description" : "Lunch, water bottle, homework folder.",
      "links" : [
        {
          "title" : "Packing list",
          "url" : "https://www.youtube.com/results?search_query=school+bag+packing+checklist"
        }
      ],
      "minutes" : 10,
      "title" : "Pack the bag"
    },
    {
      "deadline" : {
        "at" : "09:00"
      },
      "minutes" : 25,
      "title" : "Drive to school"
    },
    {
      "minutes" : 20,
      "title" : "Back home"
    }
  ],
  "symbol" : "figure.and.child.holdinghands"
}
```

IF YOU CAN READ THE WEB, read these before you answer, rather than guessing: https://routinerun.com/llms-full.txt is the Routine Run method, the ideas every routine here is meant to follow, as plain text; https://routinerun.com/help is how each part of the app works. If you cannot, carry on without them.

## If you are connected to their phone (the Routine Run MCP server)

Read before you write, and ask in the chat — one message, with choices where there are any ("by 9:00 or 9:30?"), and a default they can leave ("otherwise 25 minutes").

**Starting a run.** 1) list_routines: severalAtOnce says whether a second start is a second run, startsWith lists the values its name and steps need. 2) list_runs: a routine that runs one at a time and is going is carried on, not started again. 3) Any startsWith value the chat has not given: ask — or, if they would rather answer on the phone, start with ask_first and leave it out, and Start on the phone asks. 4) start_run with values, and a name when several are going. 5) Go on with the run id the answer gives. restart only when they asked to start over.

**Writing a routine.** list_routines and find_starter_routine first: offer to change one that is close, or a starter, rather than write a second. Ask only what changes the steps — a time to keep, which of their shortcuts or Home scenes, whether a step does something or only reminds, one run or several at once. Never invent tags, scenes, shortcuts or links. Then propose_new_routine.

**Changing a routine.** get_routine, whole: `description` is what the routine and each step say about themselves, and `written` is the routine to edit and send back. Name steps by number and title from it. Ask only if the change reads two ways ("after step 3, or at the end?"). One step on a list: add_step. Anything else: propose_routine_change with the whole routine, "was" left as it is on every step that was there.

**After a run.** get_run and get_history; suggest at most three changes, each with the reason from what happened. Change nothing without proposing it.

## If you can run commands

Save the routine as routine.json and run `npx @routinerun/form check routine.json` before you answer. It is the check the app makes when the routine is pasted: fix whatever it names, and answer once it says the routine is fine.

Attribution

Is this your skill, or is something wrong with this listing? Request removal or report an issue. Author removals are honored within 72 hours.

View all in ai-agents →

Comments

Loading comments…

Newsletter

Get the weekly list of safe new skills, and the ones we pulled.