How to build a Claude routine - the three types, with templates

In part one I said an AI employee needs three things: a skill, a routine and a workflow.

The skill is the job description. It's who they are, what they know and how they do the work. If you've built one, you'll have noticed something slightly annoying about it.

It does nothing until you ask.

You can write the best skill in the world and it will sit there, fully briefed, waiting for you to open a chat and say "go." Which is fine for the things you want to do with Claude. It's useless for the things you want done without you.

That's what a routine is for. A skill is an employee who knows the job. A routine is what makes them turn up.

This is part two. Routines.

What a routine actually is

A routine is Claude on a timer.

You write down what it should do, you tell it when to do it - every morning at six, every half hour, every Sunday night - and from then on it wakes up at that time, does the job, and goes back to sleep. No chat window. No you.

Under the hood it's just a file. Every routine you make lives in a folder on your Mac as a SKILL.md - the same shape as a skill, with a schedule attached. Which tells you something important about how to think about it:

A skill and a routine are the same brain, woken two different ways. /proposal in a chat loads the Proposal Writer's brain because you asked. A routine loads the same brain because it's 6am. One brain, two triggers.

Three things about routines that you need to know before you build one, because they explain every rule that follows:

Every run starts from nothing. A routine has no memory of the last time it ran, and no memory of any chat you've ever had. Whatever it needs to know, it reads fresh each time - from your files, your task manager, your calendar. This is why routines read before they do.
It runs where the app is open. A routine on your Mac needs your Mac awake with Claude open. If the laptop's shut when it's due, it runs when you next open it. That's fine for a morning brief. It's not fine for something that's meant to be working while you sleep - and it's the reason I have a Mac Mini that never turns off. More on that below.
Every run costs. Each one is a real Claude session. Every 30 minutes for a two-line job is nothing. Every 30 minutes for a job that reads forty files is a lot. Pick the cadence for the job, not for how impressive it sounds.

Why bother

Because the alternative is you being the timer.

Every recurring thing in your business that only happens because you remembered to do it is a thing you're carrying. The morning check of what's due. The end-of-day "what did I actually do." Filing the emails. Updating the client status page. Chasing the thing that's been sitting at "waiting" for four days.

None of it is hard. All of it is yours until it isn't. A routine is how you stop being the person who has to remember.

And the bigger reason - the one this whole series is building to - is that without a routine, an AI employee isn't an employee. It's a very well-briefed contractor you have to phone every time. The routine is what turns "I have a skill for that" into "that gets done."

You'll need your AI brain for this.

Routines read your files every time they run, because they start with no memory. If your business isn't written down somewhere Claude can read it, a routine has nothing to work from. Not set up yet: The Co-Founder Setup. And if you haven't built a skill yet, start with part one - the third type of routine below needs one.

There are three types of routine

Same as skills - "routine" covers three different things, and they're set up differently.

	What it does	Talks back?	Example
1. The brief	Reads several places, tells you what matters	Yes - one report, to you	Morning brief at 6am
2. The chore	Does one fixed job, the same way, on repeat	Barely - a two-line receipt	Sort the inbox every half hour. Write up the day at 10:30pm
3. The heartbeat	Wakes an employee up to work its queue	To the task, not to you	Blog Writer checks ClickUp hourly for anything assigned to it

1. The brief is read-only. It goes and looks at your calendar, your task manager, your client notes, and it writes you one thing: here's today. It changes nothing. That's what makes it the safest place to start - it can't do damage, and it's the fastest way to see whether Claude reads your setup the way you think it does.

2. The chore is a routine that does a job rather than describing one. It's still one job, still fixed, still the same every time - but it writes, moves or files something. Mine sorts three inboxes every half hour and writes up the day's work into my client logs every night. Nobody reads a chore's output in the morning. You just notice it's done.

3. The heartbeat is the one this series is about. It doesn't have a job of its own - its whole job is to wake up an employee. It loads the employee's skill, opens the task manager, finds every task that's been assigned to that employee and is sitting at the stage it owns, works through them, hands each one on, and goes back to sleep. The routine is short. The skill is where the job lives. That separation is the entire trick, and it's the thing people get wrong.

I run the first two today. The brief runs at 06:06 on my MacBook. The chores run every half hour and at 22:37. The heartbeats are what I'm building right now, and they'll live on the Mac Mini, because they're the ones that need to keep going when I'm not there.

Where it runs - your Mac, a spare Mac, or the cloud

You need to decide this before you build, because it changes what the routine can reach.

Your own Mac. Simplest. Full access to your files, your connected tools, your logged-in browser. The catch is the one above: it only runs while your Mac's awake with Claude open. Right for the brief, since you're opening the laptop anyway. Wrong for anything that's meant to be running at 3am.
A spare Mac that never sleeps. This is what I do. A Mac Mini sits in the corner with Claude open, never closes, and runs every routine that needs to work unattended. Same full access as your own Mac - files, tools, browser - just always on. If you're serious about employees, this is the setup. A second-hand Mini is less than a month of a real assistant.
The cloud. Claude can also run routines on Anthropic's servers - nothing of yours needs to be on. The trade-off is it can't see your Mac. No local files, no local tools, only what's connected through claude.ai and any GitHub repo you point it at. Good for code and for anything that lives entirely in connected apps. Not where your AI brain lives, so not where my employees live.

The rule of thumb: if the routine needs to read your files, it runs on a Mac. If that Mac needs to be awake at a time you won't be, it's a Mac that isn't yours.

How to set one up

The honest answer is: you tell Claude, in a sentence.

Open the Claude desktop app and say what you want and when. "Every weekday at 6am, read my calendar and my ClickUp and write me a brief of today." It will write the routine, save it, and tell you when it'll first run. That's genuinely it.

But - same as skills - if you let it guess the details you'll get a routine that runs beautifully and does the wrong thing. So don't describe the job in a sentence. Give it the template.

Every routine I run, whichever type, is the same five parts. Everything in brackets is yours.

You are [ROUTINE NAME] for [YOUR NAME], running [WHEN] on [WHICH MACHINE].
[One sentence: the job.]
[One sentence: the hard boundary - the thing you never do.]
If one source fails, note it and carry on - never abandon the run.

## Setup
- Where things live: [the folder paths this needs]
- Tools to use: [which connected tools - calendar, task manager, email]
- Read fresh every run: [the files that hold today's truth - your index,
  your routing doc, your status pages]
- Known quirks: [anything that's caught you out before]

## Read, every run
1. [source] - [what to pull from it]
2. [source] - [what to pull from it]
3. [source] - [what to pull from it]

## Do
1. [the job, in order]
2. [the job, in order]

## Hard rules
- [Read-only on X / Never write to Y]
- Never invent. No data → say "no data".
- Never write secrets. The routine says WHERE a credential lives, never what it is.
- Never touch [the areas that aren't yours].
- Finish with a [N]-line report: [what it should tell you].

Two lines in there are doing more than they look like.

"If one source fails, note it and carry on." Without this, a routine that can't reach your calendar one morning gives up entirely, and you get nothing instead of most of something. Routines fail quietly. Make them fail loudly and keep going.

"Never write secrets." A routine that needs a password does not get the password. It gets told where the password is - a Keychain entry, an environment variable - and reads it from there at run time. Never in the file. A routine file is just a text file on a disk, and one day you'll paste it somewhere.

Now the three types, each built from that template.

Type 1 - The brief

The one to build first. Read-only, low stakes, and it teaches you more about how Claude reads your business than anything else you'll do.

Mine reads Google Calendar, every ClickUp list, and the status page for each client, and writes me nine sections: today's schedule, to-dos, new leads, a line per client, where my product build is, content pipeline, fun builds, personal, and inbox count. It never writes to ClickUp. If the calendar's down it says so at the top and does the rest anyway.

Yours can be smaller. Here's the shape:

You are the Morning Brief for [YOUR NAME], running every weekday at [TIME]
on [MACHINE]. Read my calendar and my task manager and write me one brief of
today. You NEVER change anything - no status changes, no new tasks, no edits.
If one source fails, note it at the top and carry on.

## Setup
- Brief goes in: [folder path]/briefs/brief-YYYY-MM-DD.md - a new file each
  day, never overwrite a previous one.
- Tools: [calendar tool], [task manager tool].
- Read fresh every run: [your index or routing doc] for what's what.
- Time rule: a task with a due TIME is a block and shows as start–end. A task
  with only a due DATE is a to-do. Never print a due time as if it were a
  start time.

## Read, every run
1. Calendar - today's events, in time order.
2. Task manager - everything due today, split into blocks (timed) and to-dos
   (date only). Then everything overdue, grouped by list.
3. Per client - the single next task, and the "waiting on" line from their
   status page if there is one.
4. New leads since yesterday.

## Do
Write the brief. Sections, always in this order, always present even if
empty: 1 Today (calendar + blocks) · 2 To-dos (today / overdue) · 3 New
leads · 4 Clients (one line each) · 5 [anything else you want].
Tone: direct, sequenced, no fluff.

## Hard rules
- Read-only on the task manager.
- Never invent a number. No data → "no data".
- Never write secrets.
- Finish by printing the file path and a 5-line summary.

Run it for a week before you change anything. You'll find out where your task manager is lying to you, which is worth the exercise on its own.

Type 2 - The chore

A chore is a brief that's allowed to write. One fixed job, done the same way, on a loop. The two I'd build first:

The end-of-day clerk. This is the one that quietly changed my business. Every night at 22:37 a routine reads every Claude chat I had that day, every task I closed, every file I created - and writes it into the right client's daily log and rewrites their status page. Which means every morning, the brief is reading the truth from last night, not my memory of it. I never write a status update again.

The inbox tidy. Every 30 minutes, 7am to 9pm, a routine files new email into the folders each sender already lives in and leaves anything from a human in the inbox. It reports three lines - moved N, stayed N - and touches nothing else.

The end-of-day one is the more useful template, because it's the one that makes everything else work:

You are the End-of-Day Clerk for [YOUR NAME], running daily at [TIME] on
[MACHINE]. Read what happened today and write it into the right client's log
and status page. Never invent. Read-only on the task manager.

## Setup
- Client folders: [path]/clients/<name>/ - each has daily-logs/ and STATUS.md
- Entity map: [path to your index] - read fresh every run. A piece of work
  maps to a client ONLY if the index supports it. Otherwise it's UNMAPPED.
- Tools: [task manager tool], [session/chat tools if available].
- Today = the current date in [your timezone].

## Read, every run
1. Chats active today - what was done, decisions, blockers, outputs created
   (paths, links). Summarise, never paste.
2. Task manager - tasks closed today and tasks updated today.
3. Files created or changed today under [your outputs folder].
4. Each touched client's current STATUS.md.

## Do, per client
1. daily-logs/YYYY-MM-DD.md - create or APPEND, never overwrite: what was
   done, decisions, blockers, outputs with links, tasks closed (name + link).
2. STATUS.md - rewrite in place, one page: Where we are · What's next ·
   Waiting on · Open risks · Last 3 things done (dated).
3. Anything unmapped - one line each into [path]/For Review/UNMAPPED-YYYY-MM-DD.md

## Hard rules
- Never write to the task manager.
- Never log work against a client the index doesn't confirm. Do not guess.
- Never invent. Never write secrets.
- If a read fails, note it in that client's log and carry on.
- Finish with a 6-line report: clients updated, files written, unmapped
  count, failures.

Notice the difference from the brief: it writes, so it has a mapping rule - it's only allowed to file work against a client when your index says so. A chore that guesses where things go is worse than no chore, because it looks like it worked.

Type 3 - The heartbeat

This is the one that makes an employee an employee.

Here's the model, and it's the same one from part one. An employee has three parts:

A brain - the skill. Job description, rules, voice, where the files are, how to hand off.
An inbox - a filter in your task manager. Every task where AI Employee = this one and status = the stage this one owns.
A heartbeat - the routine. Wakes up on a timer, loads the brain, works the inbox, goes back to sleep.

The heartbeat is deliberately thin. It doesn't know how to do the job. It knows how to find the job and who to wake up. The skill does the work. If you find yourself writing the job into the routine, stop - you're building a second skill that'll drift from the first.

Two things you need in your task manager first (this is part three of the series, but you need the bones now):

A field for who owns the task. Mine's a dropdown called AI Employee. Every task can be assigned to one.
Statuses that mark whose turn it is. At minimum: a stage the employee picks up from, a stage it hands to, and one called with Samantha for anything that needs a human. Mine run to do → researched → drafted → built → in review → with Samantha → approved → done, and each employee owns exactly one of those arrows.

Then the heartbeat:

You are the heartbeat for [EMPLOYEE NAME], running [every hour / every 30
minutes] on [MACHINE]. Your only job is to find this employee's work and do
it using the [EMPLOYEE NAME] skill. You do not do work that isn't in the
queue, and you do not touch tasks that aren't yours.

## Setup
- Load the skill: [EMPLOYEE NAME]. Everything about HOW to do the job is in
  there. Do not improvise around it.
- Task manager: [tool]. List(s) to check: [list names / IDs].
- Outputs go to: [path]/outputs/<area>/ - never only to chat.
- Read fresh every run: [your routing doc / index].

## Find the work, every run
1. Filter: AI Employee = [EMPLOYEE NAME] AND status = [ITS INPUT STAGE].
2. If nothing matches: post one line - "[EMPLOYEE NAME]: queue empty" - and
   stop. Do not go looking for other work.
3. Take the oldest first. Work at most [N] tasks per run.

## For each task
1. Read the ORIGINAL brief in the task description. That's the job. Not your
   idea of the job.
2. Do it, using the skill.
3. Save the output to the outputs folder, named [convention].
4. On the task: add a comment saying what you did, with a link to the output.
5. Change the status to [NEXT STAGE]. If the skill says this needs a human
   decision, set status to "with Samantha" instead and say why in the comment.
6. If this task has already come back to you with "changes requested" 3
   times, stop working it: set "with Samantha" and summarise the loop.

## Hard rules
- Only ever touch tasks where AI Employee = [EMPLOYEE NAME] AND status =
  [INPUT STAGE]. Nothing else. This is how nothing gets done twice.
- Every handoff = status change + comment + link. All three, every time.
- Nothing goes to a client, a website or a social account from this routine.
  Anything public stops at "with Samantha".
- Never write secrets. Never invent.
- Finish with one line: "[EMPLOYEE NAME]: N done, N handed to Samantha, N
  waiting on [whatever]."

Why "oldest first" and "at most N per run" matter. A heartbeat with no cap will take on twenty tasks at 3am and you'll wake up to twenty half-finished things. Cap it. Let it run more often instead.

Why "if nothing matches, stop." An employee with an empty queue that goes looking for something useful to do will find something. It will not be something you wanted. Empty queue, one line, sleep.

Why "read the ORIGINAL brief." By the third time a task has bounced between an employee and a reviewer, the comments are longer than the brief. The brief is the job. Everything else is context.

And the reason the handoff is three things - status, comment, link - every time: the status is for the next employee's filter. The comment is for you. The link is so the work exists somewhere other than a chat window that'll be gone by morning.

The rules that stop it going wrong

Same list I gave part one's employees. It's short because I've broken every one of them.

One routine, one job. A brief that also files email is two routines.
Read-only first. Build the brief before the chore, the chore before the heartbeat. Let each one run for a few days before the next.
Every run reports. Even the chore. Even if it's one line. A routine you can't see is a routine you'll stop trusting.
Nothing public without a human. No routine posts, sends, publishes or deploys. It stops at with Samantha and you press the button.
The routine says where the secret is, never what it is.
Cap it. Max tasks per run. Max loops before it escalates. A routine with no ceiling will find it for you.

So what does it feel like

It looks like this. At 22:37 the clerk writes up the day. At 06:06 the brief reads what the clerk wrote and tells me what today is. That loop runs now. The heartbeats are the next layer: they work their queues on the Mini in between, and anything they can't decide lands in one view in ClickUp called WITH SAMANTHA.

I open the laptop, read one brief, clear one view, and everything I didn't have to decide already happened.

That's what the routine is. The skill is the employee. The routine is the reason they showed up.

Start with the brief

Build the brief this week. Copy the template, fill the brackets, tell Claude when to run it. Then don't touch it for five days - just read it every morning and note what's wrong. The things that are wrong are where your setup doesn't match what you think it is, and that's the list you fix before anything else.

Then the clerk. Then, once you've got a skill you trust from part one, the heartbeat.

Part three is the workflow - the task manager side: the field, the statuses, the views, and how a task moves from employee to employee to you without anything getting done twice. That's the bit that makes the loops actually loop.

If you haven't got your AI brain set up yet, that's the foundation for all of this: start here.

And if what you want is the whole system - the pricing, the positioning, and the tech and AI that lets you run a business on three days a week - that's what I teach.

Watch the free training →

How to Build a Claude Routine: The Three Types (With Templates)