Putting it together: work playbooks

This is the last lesson. A victory lap.

Every lesson before this one taught a single move. How to write a prompt, how to give ChatGPT context, how to pick the thinking level, how to hand a task to Work, how to put a job on a schedule. Useful moves, all of them. But real work is almost never one move. Real work is a sequence: gather the material, shape it, check it, turn it into the thing someone actually asked for.

This lesson is where single moves become plays. A play you can run again next week without thinking. We call it a playbook. By the end you'll have four you can steal and a method to write your own.

What a playbook actually is

A playbook is a repeatable recipe: a fixed set of steps that turns a known input into a known output, the same way every time.

The important word is repeatable. "Summarise this contract" is a task. "Every time a new supplier contract lands, pull out the parties, term, payment terms, and exit clauses, flag anything that differs from our standard, and draft a one-page note for legal" is a playbook. The first you type once. The second you run for years.

Every playbook has the same five parts:

1. A trigger. The input that starts it: a new contract, Monday morning, an email from a client, a finished meeting.
2. The steps, in order. Gather, shape, produce.
3. One human checkpoint. On the step where a mistake would cost something.
4. A finished output. A document, a deck, a Site, a message, a table. Not "some thoughts."
5. A home. Where the instructions and materials live, so the next run starts briefed.

The shift in your head is from asking ChatGPT a question to running ChatGPT through a job. Once you see your work as a set of recipes rather than a pile of one-off requests, it gets faster, because you stop reinventing the steps every time.

Why bother writing it down, if you already know the steps? Three reasons. Consistency: the output looks the same every week, so people learn to trust it. Sharing: a colleague can run your playbook while you're on holiday. Improvement: a written recipe can be fixed; a habit in your head just drifts. Think of a good kitchen. The chef doesn't reinvent the sauce every night. There's a recipe card, and the card gets better every time someone notices what could be improved.

Your toolkit, finally assembled

Here is every tool from the track, by the role it plays in a playbook:

• Pages and writing blocks (2.4) are where a text output gets shaped and shared.
• Prompts (Part 3) are the instructions for each step. The recipe: goal, context, format, boundaries.
• Context and memory (2.5, 4.1) keep each step accurate: the right files, a clean window, an honest memory.
• Thinking levels and research (2.3) are for steps that need depth: an analysis, a comparison, a cited report.
• Projects (4.3) are the home: files, instructions, and history, ready for every run.
• Skills (4.2) package a step you do the same way every time.
• Apps (4.5) bring live input in and send results out: mail, calendar, drive, Slack, CRM.
• Work (4.4) runs multi-step jobs and delivers files.
• Images, slides, and Sites (5.2) turn results into something people look at.
• Codex (5.1) for the playbooks that need code.
• Scheduled and event-triggered tasks (5.3) start the playbook without you.

You don't need all of them in every playbook. Most good ones use three or four.

A quick way to match tool to step: if the step gathers, think apps, files, and research. If it shapes, think prompts, skills, and the right thinking level. If it produces, think Work, slides, Sites, or Codex. If it starts the whole thing, think scheduled or event-triggered tasks. And the home is almost always a project.

Four playbooks you can steal

1. Research to report

Trigger: a question from your boss or a client that needs a real answer. Output: a two-page brief with sources.

1. In a project for the topic, run deep research with a sharp brief: the question, the audience, the time frame, the sources to prefer.
2. Read the report. Checkpoint: open the three sources the conclusion leans on most, and check they say what the report says.
3. Ask ChatGPT to turn it into a two-page brief for the audience, with a one-paragraph summary up top.
4. Need it presented? Hand the brief to Work for five slides.

Climb it: save the research brief as a skill ("research brief for management"), so the question is the only thing you type next time. For topics you follow all year, a monthly scheduled task can run a lighter version and tell you what changed.

2. Inbox to actions

Trigger: every weekday morning, or every new email from a key client. Output: a short list of what needs doing today, with drafts.

1. A scheduled task at 8:00 (or an event trigger on the client's emails) reads your inbox through the mail app.
2. It sorts: reply today, reply this week, information only.
3. For the "reply today" list, it drafts short answers in your tone.
4. Checkpoint: you read every draft. Nothing is sent without you.

Why it works: the boring part, reading and sorting, happens before you sit down. Your attention goes only to the replies that matter. Keep the mail app on Always ask so a draft can never leave on its own.

3. Data to a deck

Trigger: the monthly export lands. Output: a five-slide update in your template.

1. In a project that holds last month's deck and your brand guide, attach the new export.
2. Ask for the analysis first: the three changes that matter, with the calculation shown (lesson 3.4).
3. Checkpoint: check every number against the export. Charts look right even when they're wrong.
4. Ask Work for five slides in the same style as last month's, leading with what changed and what you recommend.

Variant: swap the deck for a Site when people want to check the numbers themselves during the month. Same analysis, a dashboard instead of slides, shared with the team only.

4. Meeting to follow-through

Trigger: a meeting ends. Output: notes, owners, and follow-up drafts, plus a reminder that checks on progress.

1. Paste or upload the notes or transcript into the meeting's project.
2. A skill turns them into decisions, actions with owners and dates, and open questions, in your house format.
3. Ask for a short follow-up email to the attendees. Checkpoint: you read it and send it yourself.
4. Ask ChatGPT to schedule a check-in: "In a week, remind me which actions are due and ask me for a status update."

Why it works: most meetings fail after the meeting, not during it. This playbook makes the follow-up cost two minutes instead of half an hour, so it actually happens.

How to build your own playbook

Pick a job you do at least every month, that takes real time, and that has a clear "done." Then answer five questions:

1. What starts it? The trigger. Be precise: "a new contract in this folder", not "contracts."
2. What does done look like? The output, specific enough that someone else could check it.
3. What are the steps? Write them as you'd explain them to a new colleague. Three to six is plenty.
4. Where could it go wrong? That's your checkpoint. Usually: before anything leaves your hands, or where a number gets decided.
5. Where does it live? A project for the materials, a skill for the step you repeat, a scheduled task for the start.

Write the answers down in a short, fixed form. This is the one we use:

Playbook: [name]
Trigger: [what starts it]
Output: [what done looks like, and for whom]
Steps: 1. ... 2. ... 3. ...
Checkpoint: [which step, and what you check]
Home: [project / skill / scheduled task]
Owner: [who keeps it up to date]

Then run it by hand three times. After each run, fix the instructions that made you correct something. When three runs in a row need no fixes, it's ready to go up a rung.

A worked example. Nadia in HR spends half a day on every new hire's welcome pack. Trigger: a signed contract. Output: a welcome email, a first-week schedule, and a buddy brief. Steps: read the contract for role, team, and start date; fill the schedule template; draft the email and the buddy brief. Checkpoint: she reviews everything before it goes out. Home: an "Onboarding" project with the templates and the tone guide. After three manual runs, she turns the drafting step into a skill. Half a day becomes twenty minutes, most of it reviewing.

The maturity ladder

Every playbook climbs the same three rungs:

1. Ad hoc. You run the steps by hand, in a chat, from memory. That's where every playbook starts, and where you learn what the steps really are.
2. Written down. The instructions live in a project and the repeated step in a skill. Anyone on the team can run it the same way, and the output stops depending on who's at the keyboard.
3. Automated. A scheduled or event-triggered task starts it without you. You get the output and approve the risky step.

Watch one playbook climb. In January, Inbox to actions is a chat Pieter opens every morning: "Here are my unread emails, sort them." In February he writes the sorting rules and his tone into a project, and the drafts improve. In March he turns the sorting into a skill and lets a scheduled task run it at 8:00. In April he adds an event trigger for his two biggest clients. Every step of the way, he still reads every draft before it goes out. The playbook got faster; the checkpoint never moved.

Not every playbook should reach the top. A quarterly strategy memo is fine on rung two. A daily inbox triage begs for rung three. Climb only as high as the job deserves, and keep the checkpoint on every rung.

Pitfalls to avoid

• Automating too early. A broken playbook on a schedule just makes mistakes faster. Prove it by hand first.
• Dropping the checkpoint. "It's been right for weeks" is how the one wrong email goes out. The checkpoint stays.
• Stale homes. Old templates and last year's figures in a project quietly poison every run. Tidy the project when the playbook changes.
• Playbooks about everything. "Handle my week" is not a playbook. One trigger, one output.
• Nobody owns it. Every shared playbook needs one person who updates it when the process changes.
• Too many steps. If a playbook needs ten steps, it's probably two playbooks. Split it where one output becomes the next one's input.
• No feedback loop. When you correct the output, fix the instructions too. Otherwise you correct the same thing every week.
• Forgetting the data rules. Lesson 1.4 still applies at every step: what you may share, with which tool, on which plan.

You made it: the whole course, in one breath

You chose the right plan and found your way around ChatGPT. You learned to pick the thinking level, to check the web, and to give it the right context while keeping its memory honest. You learned to write a prompt that works and to steer it when it doesn't. You kept long chats sharp, packaged your best work as skills, gave ongoing work a home in projects, handed whole tasks to Work, and connected ChatGPT to the tools you already use. Then you built code with Codex, made things people can see, and put work on a schedule. Now you can chain it all together.

That's the whole track. The tools will keep changing; the habits you built here won't. Brief clearly, give context, check the result, and keep a human where it matters.

Where to go from here? Start a small library: one playbook a month is plenty. Share the ones that work with your team as projects and skills, so the whole team gets faster, not just you. And come back to the lessons when a feature changes. We keep them up to date, so you don't have to chase every release note.

Try it

Pick one job from your own week that fits the five questions above. Write its playbook on half a page: trigger, output, steps, checkpoint, home.

Run it by hand this week. Next week, run it again with the fixes. When it holds up three times, give it a project or a skill, and decide whether it deserves a schedule. Your first playbook is the start of a library.

(General exercise. Role and industry versions come once accounts are in.)