Forge
← Back to all packs
7 phases · 29 prompts

Ship One Field-Service Workflow

Turn one messy field-service job into a tested workflow your team can run safely.

0 of 29 done
One job, start to finish

Pick the workflow

Finish with one repeatable job, its inputs, its saved output, its review rule, and a clear exception path.

01

Name the workflow

You pick a single repeatable field-service workflow to build first and state plainly why the others wait.

Interviews youDecides
Help me pick the one field-service workflow this pack builds first, and write the decision down.

Start by asking me for my list of candidates. Do not suggest candidates yourself — wait for mine. For each one I name, ask me: how many times it happens in a normal week, who does it today, what the finished thing is at the end, and whether it currently runs through the live worker, the temporary twelve-field form, or neither.

Then apply this decision rule and show your working:
1. Does it run several times a week with roughly the same shape each time?
2. Can a person look at the finished result and tell whether it is good in under a minute?
3. Can one full run be done without writing over live job data?

Pick the candidate that clears all three. If two clear all three, pick the one operators already do by hand today, because the comparison is free.

If nothing on my list clears all three, say so plainly. Do not pick the least-bad option. Instead name the single thing I should count or watch this week to break the tie, and tell me to come back with it.

If my preferred pick fails the rule, say that once, in one short paragraph, with the reason. If I still want it after hearing you, go with my call and note the risk in the write-up.

Finish with a short page I can paste into the next step: the chosen workflow in one line, my answers to the three questions, and one sentence per rejected candidate giving the real reason it waits and what would move it up the list.
Open chat ↗
02

Map Input And Output

You write down exactly what goes into the chosen workflow and what a finished, saved result looks like.

Interviews youWrites
Help me write down exactly what goes into my chosen workflow and what a finished, saved result looks like.

Ask me for these before you write anything:
- the chosen workflow, in the one line I already settled on
- two real recent runs of it, actual jobs rather than invented ones
- for each run: everything that had to be known before work could start, and exactly what existed when it was done — a saved route, a file, a message to a driver, a row in a system

Label my evidence for each run: **seen** (I have the record in front of me), **remembered** (I did it but I am recalling from memory), or **assumed** (I am describing how it ought to work). Show the label next to anything you build from it. If both runs are assumed, say the map is unverified, and tell me to keep the records of one real run before I build on this. "I don't know what the finished thing looks like yet" is a fair answer — write it down as an open question instead of filling the gap.

Then give me two lists.

**Input** — every fact the workflow needs, one per line, each marked required or optional, each with where it comes from today (customer call, dispatcher's head, the twelve-field form, another system). Flag anything that exists only because the twelve-field form asks for it.

**Done** — what exists when the run is finished, where it is saved, and how a non-technical operator can tell at a glance that it worked.

End with the two lists as one page, plus any input you could not trace to a source.
Open chat ↗
03

Write The Review Rules

You get a stated review rule for normal runs and a named exception path for anything that fails it.

Interviews youWritesDecides
Help me write the review rule for this workflow and name the path for anything that fails it.

Ask me for these first:
- my input and output map for the chosen workflow, pasted in
- who looks at a finished result today, and how many minutes they realistically have
- what has gone wrong in the last month, in whatever detail I have

Then write one review rule as a single sentence: what gets checked, by whom, against what, before the result counts as done. Keep every check to something an operator can see on the finished result itself — no reading model output, no opening a dashboard they do not already use.

Then build the exception path. For each way a run can fail the check — missing input, result that is obviously wrong, a run that touched live job data it should not have, a run that never finished — give me a row with: what the failure looks like, where the job goes next, and who owns it by name or role. If I cannot name an owner, write **unowned** rather than inventing one. Unowned rows are build blockers, so list them separately at the end.

If nobody reviews results today and I cannot name someone who will, say so and stop there. Recommend that I do not build the automated version until a named reviewer exists, and say why in two sentences I could repeat to someone else.

Finish with one page: the review rule in a single sentence, the failure table, and the list of unowned gaps to close before any prompt text is written.
Open chat ↗
04

Profile The Operators

You describe the non-technical operators who will actually use this, including how much AI they already touch.

Interviews youWrites
Help me describe the people who will actually run this workflow, including how much AI they already touch.

Ask me for these before you write the profile:
- who does this work, by name or role, and how many of them there are
- what device they use while doing it, and whether they are sitting down
- what happens in the ten minutes before and the ten minutes after
- which tools they already open every day without being asked
- what they have actually done with AI tools at work, if anything

Label every claim about AI use as **observed** (I watched them), **reported** (they told me), or **assumed** (my guess). Treat assumed claims as unknown in the profile, not as facts. "Not yet" and "I don't know" are correct answers here and should be written down as such.

If I ask you what to expect from operators generally, say the published numbers disagree and cite them: a Housecall Pro survey put roughly 70% of home-service pros as having tried AI and about 40% as actively using it, while ServiceTitan's 2026 trades report counted only 12% with AI embedded in operations plus 34% experimenting (both summarised at fieldtics.com/blog/ai-in-field-service-2026). Say plainly that my own observation of my own operators outranks both numbers, and that neither should be used as a design assumption.

Finish with a one-page profile: up to three operator types, each with device, the moment they use this, the words they already use for the job, what they will not do under any circumstances, and an evidence label per line — followed by a short list of unknowns I could settle by watching one shift.
Open chat ↗
Every request enters one way

Fix intake

Finish with every request landing in one capture point and a measured decision on which intake fields stay.

05

Find Every Intake Channel

You get a complete list of the places job requests arrive today, including the informal ones.

Interviews youResearchRecurring
Help me list every place a job request arrives today, including the ones nobody set up on purpose.

Ask me for these before you build the list:
- the chosen workflow, in the one line I already settled on
- every inbox, phone number, form, portal and account that customers can reach
- who personally receives requests, by name or role
- what happened with the last five jobs: where did each one first show up?

Then walk me through the informal ones one at a time and wait for an answer on each: texts to a technician's own phone, calls straight to the owner, walk-ins, a regular customer who always emails one specific person, voicemail nobody transcribes, a note on a whiteboard, requests passed on by a supplier or a landlord, messages on a social account. If my answer is "none", ask whether I have actually checked that person's phone or inbox this week. "Unknown" is a fair answer and belongs in the list as unknown, not as none.

Label each channel **seen** (I looked at the messages), **reported** (someone told me it happens), or **assumed** (I think it probably does). Anything assumed goes in a separate block at the bottom, because it cannot be routed until confirmed.

Give me one table: channel, who receives it, roughly how many requests a week, what arrives (voice, text, photo, paper), whether it currently lands in any system or only in a person's head, and the evidence label.

This list goes stale the moment anything changes. Add a standing note at the end: any new phone number, inbox, sign, account or new hire means a new line on this table before it goes live.

Finish with the table, the assumed block, and the count of channels that currently land nowhere but in someone's memory.
Open chat ↗
06

Build One Front Door

You route every channel into a single capture point so no request starts life outside the system.

BuildsInterviews youRecurring
Help me route every intake channel into one capture point, so no request starts life outside the system.

Ask me for these first:
- my channel table, pasted in
- what the single capture point will be (the temporary twelve-field form, the live worker, a spreadsheet, something else)
- who is willing to do the typing or forwarding for each channel, by name or role

Then, for every channel on my table, give me a row with: how a request gets into the capture point, who does that step, how long it takes them, and what happens today if they skip it.

Hold to two rules and say them back to me plainly:
1. No routing, ordering or planning logic gets built until every channel has a named path in. Capture first, clever second.
2. The front door only creates new requests. It never edits or overwrites an existing job. If a channel would need to update an existing job, mark it and keep it out of the front door for now.

A person retyping a voicemail into the form is an acceptable path. A channel with nobody named to do the retyping is not a path — it is a hole. List holes separately at the end with the one decision each needs from me.

If more than a third of my channels come out as holes, say so and recommend I stop here and settle ownership before any prompt text gets written.

This routing map is only true until the next channel appears. End with a standing rule in my own words: a new channel does not go live until it has a named path into the capture point.

Finish with the routing table, the hole list, and the one sentence I would say to an operator explaining where requests go now.
Open chat ↗
07

Audit The Twelve Fields

You get a field-by-field record of who uses each answer and what breaks without it.

Interviews youResearch
Help me audit the temporary twelve-field intake form one field at a time, so I know who actually uses each answer.

Ask me to paste the twelve fields with their exact labels. Then take them one at a time and ask, for each:
- who reads this answer after submission, by name or role
- what they do with it
- what happens today when it comes in blank
- roughly what share of submissions leave it blank or junk, if I can see that
- whether it is free text or a choice (dropdown, radio, checkbox)

Label each field **seen** (I checked stored submissions or asked the person who uses it), **reported** (someone told me they use it), or **assumed** (my guess). Do not upgrade a label for me. Fields I can only describe as assumed come out marked unaudited, and unaudited fields are not eligible for any cut decision.

"Nobody uses this" and "I don't know who reads it" are both useful answers. Write them exactly as I say them.

Say this once, plainly, so it is on the page: removing fields by gut feel goes wrong in both directions — one documented case lost 14% of conversions after deleting three fields, because the ones removed were the fields users actually wanted to give (cxl.com/blog/reduce-form-fields). So this audit records use, it does not decide anything yet.

Finish with a twelve-row table: field, who uses it, what breaks without it, blank rate, free text or choice, evidence label. Under it, two short lists: fields with no named user, and fields I could only mark assumed.
Open chat ↗
08

Measure Field Drop Off

You track where people abandon the form so the field debate rests on your own numbers.

NumbersRecurringUses your browser
Help me measure where people abandon the twelve-field form, so the field debate runs on my own numbers.

Ask me for these before you set anything up:
- what the form is built in, and what it can already report
- whether I can see partial entries or only completed ones
- how many people open the form in a normal week, and how many submit
- my field audit table, if I have it, pasted in

Then set up the smallest measurement that answers the question. Tell me exactly which numbers to record each week: form opens, starts (first field touched), completed submissions, and the last field touched on each abandoned attempt. Plus, for completed submissions, the blank rate per field.

Set the cadence: same day each week, same numbers, in one sheet. Keep collecting until I have either three weekly rows or 100 form opens, whichever comes later. Tell me the earliest date I am allowed to decide anything from it.

If my weekly volume is too small for that to finish in a reasonable time — say under about thirty starts a week — say so directly. Recommend I change nothing about the form yet, keep a hand tally of who bailed out and where, and come back when there is enough to read. Do not build a cut decision out of five abandoned attempts.

For context only, not as a target: 2025 survey data reports average abandonment near 68% once a form asks for more than seven fields, and free-text answers abandon more than dropdowns and radio choices (brixongroup.com/en/lead-forms-in-b2b-the-perfect-balancing-act-between-data-depth-and-conversion-rate). My own numbers outrank that.

Keep the sheet running after any change I make, so before-and-after stays comparable. Say that plainly at the end.

Finish with the sheet's column headers, the first week's row ready to fill, the weekly recording step written as one line, and the date I can first decide.
Open chat ↗
09

Decide Keep Or Cut

You get a written keep-or-cut call per field backed by measured evidence rather than a rule of thumb.

DecidesNumbersWrites
Help me write a keep-or-cut call for each of the twelve intake fields, based on what I measured.

Ask me for all three of these and do not proceed without them:
- my field audit table, pasted in
- my drop-off sheet with at least three weekly rows or 100 form opens
- the current completion rate

Then apply this rule per field and show your working:
1. Named user and something breaks when it is blank → keep.
2. No named user, high blank rate, and it sits at or before where people abandon → cut candidate.
3. No named user but people answer it easily and abandonment does not cluster there → keep for now, it costs nothing.
4. Marked unaudited in my table → no decision. Audit it first.
5. Free text with a high blank rate → convert to a choice before considering deletion.

Cap the first change at three fields, and ship changes one at a time so the drop-off sheet can tell me which one moved the number.

If the numbers show no abandonment cluster and completion is acceptable, the honest call is keep all twelve and change nothing. Write that down as a decision rather than hunting for something to trim.

If I tell you to cut fields without the measured rows, say once, in one short paragraph, that you disagree and why: Unbounce's own database showed conversion rising again past seven fields, with ten fields beating three (cobloom.com/blog/form-fields-and-conversion-rates-is-less-really-more), so field count alone predicts nothing here. Do not accept a reason like "twelve is obviously too many, cut it to five." If I still want it after hearing you, follow my call and record the risk beside it.

Finish with one page: a keep, convert, cut or audit-first call per field with the evidence line under each, the single change I ship first, and the number that would prove that change wrong.
Open chat ↗
No duplicates, no runaway spend

Protect live work

Finish with safe retries for every live write and hard limits on model cost and output length.

10

List Every Live Write

You get a register of every step that changes live job data and what it overwrites.

Interviews youBuildsDecides
Help me build a register of every step in this pack that changes live job data, and what each one overwrites.

Ask me for these before you write the register:
- my input and output map for the chosen workflow, pasted in
- every step in the run, in order, from the request arriving to the saved result
- for each step, what it saves and where it saves it (a job record, a route, a status, a message log, a calendar slot)
- which of those places already held a value before the step ran

Then take the steps one at a time. For each, ask me whether it creates something new or replaces something that already existed, and if it replaces, whether the old value is still recoverable anywhere. "I don't know" is the honest answer for some of these and it belongs in the register as unknown.

Label every row **traced** (I followed the actual call and saw what it writes), **reported** (someone told me it works this way), or **assumed** (I think it probably does). An assumed row is not cleared to run against live data. Do not upgrade a label for me, and do not guess a label from the step's name.

If more than a couple of rows come out assumed, say so and recommend I stop here: trace those calls before building any guard, because a guard on a write you have not traced protects nothing. Recommending that I do nothing yet is a valid outcome of this prompt.

This register is only true for today's build. End with a standing rule in my own words: any new step, prompt or integration that saves anything gets a row here before it touches live data.

Finish with one table — step, what it writes, where, creates or replaces, is the old value recoverable, evidence label — plus a short list of the replacing steps whose old values are gone for good. Those are the ones the next steps have to protect.
Open chat ↗
11

Build The Idempotency Key

You create one key per intended action and reuse it across retries so repeats never double the work.

Interviews youBuilds
Help me define one idempotency key per intended action so a retry can never do the work twice.

Ask me for these first:
- my register of live writes, pasted in
- how a run starts: an operator pressing something, a form submission, a queue picking up a message, a scheduled trigger
- every way a step can be attempted more than once — a timeout that retries, an operator pressing again because nothing appeared, the worker re-running a failed queue item, me re-running it by hand
- whether the place I store jobs can enforce a unique value on a column, and what it does when a duplicate arrives

Then apply this rule and show it per write step: the key is created once, at the moment the intended action is formed, and reused unchanged by every retry of that same action. The key belongs to the intention, not to the attempt. A second attempt that generates a fresh key is a second action, and that is exactly how work gets duplicated (stripe.com/blog/idempotency).

For each write step in my register, give me: where the key is created, what it is made from, where it is stored, how long it is kept, and what the step returns when it sees a key it has already completed — which must be the stored result of the first attempt, not a new write.

If my store cannot enforce uniqueness on the key, say so plainly and do not paper over it. Specifically, do not accept a check-then-write pattern, because two retries arriving together can both pass the check and both write. "Not yet — the store can't hold this" is a real answer, and the honest next move is to name the one change that would make it possible.

Finish with a table of write step, key source, storage location, retention, and repeat-response, plus the one sentence I would put in the code comment above each write.
Open chat ↗
12

Reject Mismatched Key Reuse

You get a rule that refuses a reused key carrying different parameters instead of quietly executing it.

BuildsWrites
Help me write the rule that refuses a reused idempotency key when it arrives with different parameters.

Ask me for these before you write anything:
- my key table from the previous step, pasted in
- the full list of parameters each write step takes
- which of those parameters could plausibly differ between two attempts that share a key, and why that would happen

Then hold this rule and state it in the output: same key with the same parameters returns the first result and writes nothing new; same key with different parameters is refused and nothing is written. A changed parameter means a different intended action, and a different action needs its own key (scaler.com/topics/idempotency-in-rest-api).

Work out with me how the comparison happens. For each step, tell me which parameters go into the stored fingerprint, which are deliberately excluded (timestamps and retry counters usually are), how the fingerprint is stored beside the key, and what the step does when the fingerprint does not match.

Then write the refusal message twice. Once for the log, with the key, the stored fingerprint and the incoming one. Once for the operator, in plain words they can act on. Do not ship something like "Error: idempotency key conflict (409)" — a non-technical operator cannot do anything with that. The operator version should say what was not saved and what to do next, in one line.

If I claim no parameter can ever change between retries, ask me what happens when an operator edits an address and presses again inside the same run. If that produces a same-key-different-parameters case, the refusal path is required, not optional.

Finish with one page: the rule in a single sentence, a per-step fingerprint list, the two refusal messages, and the name of the person who sees the operator message when it fires.
Open chat ↗
13

Cap Spend At The Gateway

You set a hard cutoff that blocks or downgrades requests before credits are gone, not after.

NumbersDecidesBuilds
Help me set a hard spend cutoff that blocks or downgrades model requests before the credits are gone.

Ask me for these first:
- what I have actually spent on model credits in the last full month, and where that number comes from
- roughly how many model calls one run of the workflow makes, and which model each call uses
- what sits between my worker and the model API: a proxy, a gateway, a single wrapper function, or direct calls scattered around the code
- the monthly number that would genuinely hurt if I hit it

Label my spend figure **billed** (read off the provider's invoice or usage page), **logged** (added up from my own call logs), or **estimated** (worked out from an assumption). If it is estimated, say the cap is provisional and tell me to pull the billed number before I rely on it.

Then set three numbers with me: a monthly ceiling, a per-day ceiling, and a per-run ceiling. Say for each one where it is enforced and what happens at the limit — refuse the call outright, or downgrade to a cheaper model and carry on. The enforcement has to sit at the layer that can actually refuse a call. An alert is not a cap: something like "Heads up: you've used 90% of your monthly credits" arrives after the money is committed and stops nothing (tokonomics.ca/blog/complete-guide-llm-api-cost-management).

If I say an alert plus my own discipline is enough, push back once, in one short paragraph, then follow my call and write the exposure down in plain numbers.

If nothing in my setup can refuse a call, say so and recommend I do not open the automated path to all operators yet — run it on my own hand-triggered calls until a single choke point exists.

This cap only holds while every call goes through that choke point. End with a standing rule: any new call site routes through the gateway, or the cap does not exist. Finish with the three numbers, where each is enforced, and the line an operator sees when a request is blocked.
Open chat ↗
14

Set The Token Ceiling

You enforce a maximum output length in the call itself and repeat the limit inside the prompt.

NumbersBuilds
Help me set a maximum output length in the model call itself and repeat that limit inside the prompt.

Ask me for these before you pick any number:
- every model call in the workflow, with the setting it currently uses for maximum output tokens, or none if it is unset
- the longest output I have actually seen that was good and usable — pasted in, or its length if I measured it
- the longest output I have seen that ran away, if one has
- what the output is used for: a saved route, a message to a driver, a summary an operator reads

If I have not measured a real good output, say the ceiling is a guess and name it as provisional in the result. Do not invent a round number and present it as considered.

Then set, per call, a hard ceiling in the API call: the longest good output plus a stated margin. Alongside it, write the plain-words limit that goes inside the prompt — a line an operator would understand, like a stated maximum number of stops or lines. Both levels are needed: a limit written only in the prompt reduces typical length but never caps it, so the enforced ceiling is the one that protects the budget (codercops.com/blog/llm-api-cost-optimization-production-2026).

Then handle what happens when a response hits the ceiling. A truncated route saved as if it were complete is worse than no route, so tell me how the step detects truncation and mark the rule: a truncated response fails the run and writes nothing to live job data. If I cannot detect truncation on a given call, say so and leave that call marked unprotected rather than assuming it is fine.

Finish with one table — call, enforced maximum, in-prompt limit sentence, truncation check, what happens on truncation — and a note of which ceilings are provisional until I measure real outputs.
Open chat ↗
A safe way back before edits

Make rollback real

Finish with production pinned, drafts separated, every model call traceable, and rollback rehearsed.

15

Pin Production To A Version

You lock the live worker to one fixed prompt version so edits cannot reach operators by accident.

Interviews youUses your browserBuilds
Help me pin the live Forge worker to one fixed prompt version, so an edit can never reach operators by accident.

Ask me for these before you write anything:
- how the live worker gets its prompt text today — typed into a dashboard field, read from a file, pulled from a database row, something else
- whether anything live right now carries a version number, id or date, for each of the four existing packs
- who else can change that text, and what they would have to click to do it
- where an unchanged copy of last week's working text sits, if one exists at all

Label each answer **verified** (I opened it and looked just now), **reported** (someone told me), or **assumed** (my belief about how it works). Do not upgrade a label for me. If a pack's live version has no id, write **unknown** — that is the honest answer and it is the first thing to fix.

Then build the pin. One row per pack: pack name, the exact version string now live, the date it went live, and where the unchanged copy is stored. If a pack has no version string, tell me the smallest way to create one: copy the live text to a stored, named, read-only version (v1, with today's date) and point the worker at that name instead of at the editable field.

Hold one rule: production points at a fixed name, never at "latest" and never at a field I can type into. If the worker can only read an editable field, say so plainly and name the one change that puts a fixed name in between.

If I tell you I would rather just be careful when editing live, say once that this is the expensive failure — tightening one edge case quietly degrades the main use, and without a stored version there is no way back (braintrust.dev/articles/best-prompt-versioning-tools-2025). If I still want it that way, note the risk on the record and move on.

A pin is only true until the next publish. End with the standing rule in my own words: nothing goes live without a new version name and a new line on this table.

Finish with the pin table for all four packs, and the list of packs still running on an unnamed version.
Open chat ↗
16

Point Development At Latest

You get a separate working lane where drafts run on latest without touching the pinned production path.

Interviews youBuilds
Help me set up a separate working lane where drafts run on latest, without ever touching the pinned production path.

Ask me for these first:
- my pinned production record, pasted in
- what I actually have to work with: a second worker, a config switch, a branch, a separate API key, or only the one live setup
- whether a draft run can currently reach live job data, and how
- whether dev and production spend from the same credit account
- which of the four packs I want to draft against first

Then design the lane and write it as instructions I could follow half asleep: how a draft run picks up "latest", the exact switch or command, how I get back to the pinned path, and how I can tell at a glance which lane I am in before I hit run.

Three rules to state plainly and keep:
1. Dev never writes to live job data. It reads a copy, or writes to a scratch place nobody dispatches from.
2. Dev never uses the production version name. Production stays pinned; only dev resolves latest.
3. No operator-facing route reaches dev — no shared link, no shared inbox, no form that quietly posts to the draft worker.

If I cannot separate dev from live job data today, say so and recommend I stop here: write no drafts until the separation exists. "Not yet" is the correct answer to record, not a reason to be careful and carry on. Say in two sentences what the separation would take, so I can decide whether it is an afternoon or a week.

If dev and production share one credit account, flag it as a spend risk in one line and leave it there — this step is about isolation, not budgets.

Finish with a one-page lane sheet: the switch to run a draft, the switch back, what dev is forbidden to touch, and the one check that tells me which lane a run just used.
Open chat ↗
17

Log Prompt And Version Ids

Every model call records which prompt and version produced it, so you can trace any bad output.

Interviews youBuilds
Help me make every model call record which prompt and which version produced its output, so I can trace any bad result back.

Ask me for these before you design the log line:
- every place in my setup that calls a model — the four packs, the live worker, the temporary twelve-field form, anything scheduled
- what each call already writes to a log today, if anything
- where logs go, how long they are kept, and whether I can read one without opening code
- how an operator tells me about a bad output now: do they have anything I could search on?

Label each call site **seen** (I opened the code or the log and looked), **reported** (I believe it exists because someone said so), or **assumed** (my guess that it is there). Assumed call sites are unverified — say clearly that I cannot claim coverage until each one is checked.

Then give me one log line format used everywhere: timestamp, pack name, prompt name, version id (the pinned name, never the word latest), environment as prod or dev, request or job id, model name, and whether the call was a retry.

Say once, plainly, why the version id is non-negotiable: untracked edits pile up as prompt debt, where a fix for one case reportedly disrupts a large share of other queries, so the prompt and version id belong on the call from day one (promptot.com/blog/prompt-versioning-development-vs-production-best-practices).

Operators are not reading logs. So add the other half: the request id must be visible on the finished result, or recoverable from the saved route, so a non-technical operator can point at one job and say this one, and I can find the exact call.

Logging only holds if new work carries it. End with the standing rule: a new pack, a new prompt or a new call site is not done until its log line includes the prompt name and version id, and that check goes on whatever list I run before publishing.

Finish with the call-site table and its evidence labels, the exact log line format, and the single test — run one job, find its line, read the version id back out loud.
Open chat ↗
18

Write The Rollback Steps

You get a short written procedure for returning production to the last known good version.

Interviews youWritesDecides
Help me write the short procedure for putting production back to the last known good version.

Ask me for these first:
- my pinned production record, pasted in
- for each pack, which version I would call last known good, and how I know that
- how long a change takes to reach operators — instant, a deploy, a cache that has to clear
- who can run the rollback if I am unavailable, by name
- whether reverting prompt text can leave a job half written in live data

Apply this decision rule for last known good, and show your working per pack: a version qualifies only if it ran in production for a full week with no operator complaint, or it was scored against my example jobs and I still have the scores. Anything else is untested, and untested versions are not rollback targets.

If no pack has a stored version that qualifies, say so and stop. Recommend I write no new drafts until one stored, qualifying version exists, because the procedure would have nothing to point at. Write "none yet" against the pack rather than nominating the least-bad candidate.

Then write the steps: numbered, fewer than ten, one action each, no judgement calls in the middle. Include who I tell and in what words, what happens to jobs that are mid-run when I revert, how I confirm the revert actually landed (read the version id back out of a log line), and the one note I write down afterwards — date, which version, why.

Then make it real: run the procedure once on purpose, at a quiet hour, before I need it. Time it. If it takes longer than five minutes or needs a decision I had not written down, fix the steps and run it again.

Finish with the numbered procedure on one page, the last known good version named per pack, and the measured minutes it took the one time I ran it.
Open chat ↗
Normal, messy, and hostile cases

Test real jobs

Finish with a fixed set of real jobs that catches regressions before operators see them.

19

Collect Fifteen Common Jobs

You gather real everyday jobs that represent the normal workload the pack must handle well.

Interviews youResearchBuilds
Help me collect fifteen real everyday jobs that stand in for the normal workload this pack has to handle well.

Ask me for these before you build anything:
- the chosen workflow, in the one line I already settled on
- where past requests are stored today, and how far back I can actually read them
- roughly how many jobs come through in a normal week
- the usual mix in plain words (repairs, installs, callbacks, quotes, whatever I actually say out loud)

Then pull the fifteen with me, one at a time, in proportion to that mix. Each one needs three things: the request exactly as it arrived, word for word including typos and missing bits; what a good finished result looks like for it; and where it came from.

Label every job **record** (I copied it from a stored request), **recalled** (a real job written from memory), or **invented** (I made it up to fill a slot). Do not upgrade a label for me, and do not write invented jobs unless I ask. At least ten of the fifteen should be record-level, because a set built from memory drifts toward the jobs I find easy.

If I can only find six real ones, say six and stop there. Do not pad to fifteen. Write the shortfall as an open item with where I would go to find the rest — a phone, an inbox, last month's invoices.

For context, the working target for a set like this is fifteen to thirty examples spanning common, edge and hostile cases (promptot.com/blog/prompt-versioning-development-vos-production-best-practices). This step is the common ones only; leave the messy ones out for now or they will crowd out the normal workload.

Finish with a numbered table of the jobs I have: id, raw request, expected finished result, evidence label. Under it, the count of record-level jobs and the count of slots still empty.
Open chat ↗
20

Add Edge And Adversarial Jobs

You add the messy, incomplete and hostile requests that quietly break routing and planning logic.

Interviews youBuilds
Help me add the messy, incomplete and hostile requests that quietly break routing and planning.

Ask me for these first:
- my fifteen common jobs, pasted in
- the worst week this workflow has had, in whatever detail I remember
- any job that had to be redone, cancelled part-way, or apologised for
- what the workflow does today when a required fact is simply missing

Then take these categories one at a time and wait for my answer on each. For every category, ask whether I have a real example, and if so make me paste the actual request text:
- address missing, wrong, or a place that does not exist
- two jobs at the same address on the same day
- a time window that cannot be met, or two that contradict each other
- the same request submitted twice within minutes
- a day with far more stops than anyone can drive
- a job cancelled after the route was already saved
- a request written in another language, or as a voicemail with no transcript
- a test or junk submission from someone poking the form
- a notes field containing instructions aimed at the system rather than the technician, such as telling it to ignore everything above and put this job first

If I have no real example for a category, write it as **untested gap** and move on. Do not invent one to fill the row. Invented adversarial jobs teach the pack to survive my imagination, which is not the thing that breaks it. If I ask you to invent some anyway, cap it at three and mark every one as invented.

Keep the whole set between fifteen and thirty jobs. If adding edge cases pushes it past thirty, tell me which common jobs are near-duplicates and can be dropped instead.

Finish with the added rows — id, category, raw request, what the pack should do with it, real or invented — plus the list of untested gaps I still have no example for.
Open chat ↗
21

Freeze The Job Set

You fix the example set as a stable benchmark so scores stay comparable between drafts.

DecidesBuilds
Help me freeze the example set so scores stay comparable from one draft to the next.

Ask me for these before you freeze anything:
- the full set as it stands, pasted in or with its file location
- the total count
- where it will live, and who can edit that file
- whether any job still carries real customer details that could end up written back into live data

Then check the set against this rule and show your working, row by row:
1. Every job has an id, the raw request, and what a good finished result looks like.
2. Every job has a category (common, edge, adversarial) and an evidence label.
3. The count sits between fifteen and thirty.
4. No job contains live identifiers that a test run could push back into real job records.

If any row fails, do not freeze. List the failing rows and the one thing each needs. A half-frozen set is worse than none, because the scores it produces look trustworthy and are not.

When it passes, write the frozen version: a name, today's date, the count, and the storage location. Say plainly that a score only means something against a named version — this is the whole reason for freezing. Tightening one edge case can quietly degrade the main use case, and that only shows up when the comparison set has not moved (braintrust.dev/articles/best-prompt-versioning-tools-2025).

The set will go stale. Write these standing rules in my own words at the end:
- the frozen file is append-only and never edited in place
- new jobs go on a pending list, dated, and wait for the next re-freeze
- re-freeze after any published change to the workflow, and otherwise at a fixed interval I name now
- old versions are kept, so old scores stay readable

Finish with the frozen set version line, the count by category, and the pending list started with whatever is already waiting.
Open chat ↗
22

Score Every Draft

You run each prompt draft against the frozen set and record pass and fail per job.

RecurringNumbersBuilds
Help me run a prompt draft against the frozen job set and record pass and fail for every job.

Ask me for these before the first run:
- the frozen set version name and its location
- the draft I want to score, and the version id it will be logged under
- what counts as a pass, in one sentence per job type
- the token ceiling set in the call, and my rough credit cost for one full pass of the set

If I cannot state the cost of a full pass, work it out with me before running anything. A full set run is the most expensive routine thing in this build, and it should never be a surprise.

Set the cadence and hold me to it: one full run per draft, not one per edit. Batch the edits, then run. Record every run the same way — date, draft version id, frozen set version, then one row per job with pass or fail and a one-line reason for each fail.

Label how each score was reached: **checked** (a fixed rule decided it, such as required stops present or times in order), **read** (I read the output myself), or **skipped** (not scored this run). Skipped is never a pass, and a run with skipped rows cannot be compared cleanly to a previous one — say so on the sheet rather than filling the gaps.

Then compare against the last run of the same frozen set. Any job that passed before and fails now is a regression. Stop and fix regressions before scoring anything new; that is the exact failure where a fix for one case disturbs the rest, and untracked edits pile up as prompt debt (promptot.com/blog/prompt-versioning-development-vs-production-best-practices).

The sheet is append-only. Add these standing rules: never overwrite an old run, rerun the whole set when the model changes or the frozen set is re-frozen, and note both version ids on every row.

Finish with the scoring sheet for this run, the regression list, and the pass count next to last run's pass count.
Open chat ↗
23

Split Automated And Human Review

You decide which checks a machine can judge and which you must read yourself as sole reviewer.

DecidesInterviews youRecurring
Help me decide which checks a machine can judge and which I have to read myself, given that I am the only reviewer.

Ask me for these first:
- the frozen job set and the pass definitions I wrote
- every check I want run, in my own words
- how many minutes a week I can realistically spend reading outputs
- what it actually costs when a bad route reaches an operator — a wasted drive, a missed window, a lost customer

Then sort every check into one of three columns and show the reason for each:
- **rule** — a fixed check with one right answer: required stops present, no duplicate stop, times in order, output within the length limit, nothing written to live job data
- **judged** — a model can form an opinion: is the note readable, does the summary match the request
- **mine** — only I can tell: is this route actually drivable, does the order make sense for these streets, would an operator trust it without ringing me

Decision rule: if a wrong answer would reach an operator and cost a drive or a customer, it goes in **mine**, no matter how well a machine scores it.

Set the reading rhythm. First full run on a new draft: I read every job. After that, a fixed sample per run — name the number — plus every regression and every adversarial job, every time. Write the minutes that sample costs and check it against the budget I gave you.

If the sample does not fit the budget, recommend shrinking the frozen set rather than dropping human review, or not publishing this round.

If I say I want the judged column to cover everything, push back once, in one short paragraph: automated and model-as-judge checks scale, but human review is still held to be necessary for high-stakes output, and there is nobody behind me to catch it (getmaxim.ai/articles/prompt-versioning-best-practices-for-ai-engineering-teams). Say plainly that how much of this can be judged automatically is genuinely unsettled. Then follow my call and note the risk on the page.

Finish with the three-column check list, the weekly reading budget in minutes, and the sample rule in one sentence I can follow on a busy day.
Open chat ↗
A small launch with a stop rule

Release safely

Finish with a watched canary, a specific rollback trigger, and the proven version live.

24

Pick The Canary Slice

You choose a small, low-risk slice of real traffic to receive the change first.

Interviews youDecidesWrites
Help me choose the small slice of real traffic that gets this change first.

Ask me for these before you pick anything:
- what the change is, in one line, and the version id it carries
- the version id production is pinned to right now
- my frozen job set scores for the new draft, pasted in
- my channel table or weekly request volume, so we know what real traffic looks like
- which operators touch the results, and how many of them there are

Label each number I give you **measured** (I read it off a record), **estimated** (I worked it out roughly), or **unknown**. Build the slice from measured numbers where they exist and say out loud which parts rest on estimates.

Then apply this rule to every slice I propose, and show your working:
1. Can I read every result the slice produces, by hand, within one working day?
2. If every result came out wrong, could the work be redone by hand with no customer harm and no live job data left overwritten?
3. Does the slice actually contain the kinds of jobs this change affects?

Pick the smallest slice that clears all three. Good slices tend to be one day of the week, one operator, one depot, or one customer type — something an operator can describe in a sentence.

If nothing clears all three, say so and recommend I do not put this on real traffic yet. Name the cheaper option instead: run the draft against the frozen job set again, or run it alongside the live path without saving its output, and tell me what would need to change for a real slice to qualify.

Finish with a one-page canary plan: the slice in one sentence, who and what is inside it, the expected number of runs, the start and end dates, the version id the slice runs, and the confirmation that everything outside the slice stays on the pinned version.
Open chat ↗
25

Name The Rollback Trigger

You get a specific number or symptom that ends the canary and reverts the change without debate.

Interviews youWritesDecides
Help me write the trigger that ends this canary and reverts the change, so the call needs no argument when it happens.

Ask me for these first:
- my canary plan, pasted in, including the slice and the version id it runs
- the baseline numbers I am comparing against: pass rate on the frozen job set, credit spend per run, and how often results needed fixing by hand before this change
- who is watching the slice each day, by name or role
- who is able to revert production, and how quickly they can do it

Mark each baseline **measured**, **estimated** or **unknown**. If a baseline is unknown, do not invent a percentage to compare against. Use a plain count instead, for example three hand-fixed results inside the slice, and say that is what we are doing and why.

Then write three to five triggers. Each one must be a single number or a single observable symptom, checkable by someone looking at the results and the spend total, and written with who watches it, who reverts, and how long they have to act. Include at minimum: one trigger for duplicated or overwritten live job data, where a single instance is enough to revert immediately; one for credit spend running above plan; one for output quality falling below the baseline or the plain count.

If I offer something like "we revert if it feels worse", say once that this is not a trigger because it cannot be checked by anyone but me at the moment I say it, and ask what I would be looking at when I said it. Turn that into the number.

If a trigger cannot be measured with what exists today, either name the one thing to add before the canary starts, or drop the trigger. Do not keep unmeasurable triggers on the page.

Finish with a trigger card I can pin next to the canary plan: each trigger on one line, the threshold, the watcher, the reverter, the revert window, and the version id production returns to.
Open chat ↗
26

Publish The Full Pack

You promote the watched version to everyone with the release notes and pinned version recorded.

DecidesNumbersWrites
Help me decide whether this change is ready for everyone, and write the release record if it is.

Ask me for these before you judge anything:
- the canary plan and the trigger card, pasted in
- what actually happened during the canary: number of runs, any trigger that fired, and any near miss I noticed but did not act on
- the frozen job set scores for the new version and the outgoing version, side by side
- the version id going live and the version id currently pinned in production
- confirmation that I have read my rollback steps start to finish since this change was made

Label the canary results **measured** (I read the logged runs), **reported** (an operator told me) or **unknown**. If the run count is unknown, treat the canary as incomplete.

Then apply this rule and show each answer:
1. Did the canary run the planned window at the planned volume?
2. Did no trigger fire, with every near miss written down?
3. Does the new version score at least as well as the outgoing one on the common jobs, not only on the edge case that prompted the change?
4. Can I name the exact version id to return to, and have I read how to do it?

If any answer is no, do not publish. Say which one failed and the single next step, whether that is extending the canary, fixing the draft against the frozen set, or writing the rollback steps first. Publishing a bad pack is the expensive mistake here, and waiting a week costs nothing.

If all four pass, write the release record for me: the new pinned version id, the previous version id kept beside it, the publish date, and release notes in language a non-technical operator reads once — what changed, what they will notice, and the one line telling them what to do and who to tell if a saved route looks wrong.

Finish with that release record as a single page, and the new pinned version id stated on its own line.
Open chat ↗
Cost, adoption, and usable output

Decide after 30 days

Finish with a written keep, rework, or stop decision based on real use and hand-checked quality.

27

Pull Cost And Adoption Numbers

You compare thirty days of credit spend and real operator usage against the figures you started with.

NumbersRecurringInterviews you
Help me compare thirty days of credit spend and real operator usage against the figures I recorded when this went live.

Ask me for all of these before you build any comparison:
- the starting figures I wrote down at publish: weekly credit spend, number of runs a week, number of operators expected to use it
- the actual gateway or billing total for the last thirty days, broken down by week if I have it
- the run log for the same thirty days, with prompt and version id per call if that is recorded
- how many named operators started a run themselves, and how many runs came from me instead
- any week where the spend cap blocked or downgraded a request

Label every number **metered** (it came from billing or a log I can open), **counted** (I tallied it by hand), or **estimated** (my recollection). Put the label beside each figure in the comparison and never mix an estimated number into a per-job cost without saying so.

If I have no starting figures, or the starting figures are only estimated, say plainly that there is no comparison to make. Do not build one anyway. Tell me to record today's thirty-day numbers as the baseline, change nothing about the pack this round, and set the next review date thirty days out.

Set the rhythm so this is repeatable: same day of the month, same four numbers in the same sheet — spend, runs, distinct operators who started a run, blocked or downgraded calls. Same order every time, so two rows can be read side by side without re-reading the headings.

If I ask how my adoption compares to the industry, say the published figures disagree — a Housecall Pro survey put roughly 70% of home-service pros as having tried AI and about 40% as actively using it, while ServiceTitan's 2026 trades report counted 12% with AI embedded in operations plus 34% experimenting (both summarised at fieldtics.com/blog/ai-in-field-service-2026). Say that neither number is a target for a single business and that my own thirty-day count is the only figure that decides anything here.

This review only stays useful if it keeps happening. End with a standing note in plain words: this same table gets filled again at every thirty-day mark, and again after any publish that changes the pack.

Finish with one page: a two-column table of start versus now for each number, each with its evidence label, the cost per finished job if it can be computed from metered figures, and a short list of numbers I could not get.
Open chat ↗
28

Grade Output Quality By Hand

You read a sample of live results yourself and rate whether the saved routes were actually usable.

RecurringOff screenNumbers
Help me read a sample of real results from the last thirty days and rate whether the saved routes were actually usable.

Ask me for these first:
- the review rule I wrote for this workflow, pasted in
- how many runs happened in the thirty days, and whether I can open the saved results themselves
- the exception log: every run that failed the review rule or was reworked by hand
- who received each route, and whether they used it as saved or changed it

If I cannot open the actual saved results, stop there. Do not grade from memory or from what I remember operators saying. Tell me to change nothing this round, turn on whatever storage keeps the finished outputs, and come back after thirty days of records exist.

When I do have them, set the sample: every run in the exception log, plus enough ordinary runs to reach twenty in total, picked by taking every nth run down the list rather than the ones I remember. Then grade each one on the same three-way scale, in the same order, one line each: **usable as saved**, **usable after an operator edit** (say which field they changed), or **not usable** (say what was wrong in one sentence). Do not invent a fourth rating mid-way. If I want to stop at ten, that is fine, but say on the page that only ten were read.

Keep the rhythm fixed so scores compare across reviews: same sample size, same three ratings, same wording of the question — would a non-technical operator have driven this route without calling me?

Say once, plainly, that I am the only reviewer and that this is the known weak spot: automated and model-as-judge scoring scales but human review is still held to be necessary for high-stakes output (getmaxim.ai/articles/prompt-versioning-best-practices-for-ai-engineering-teams). So hide the version id from yourself while reading if you can, and rate the route before reading what the model said about it.

Finish with the graded table, the count in each of the three ratings, and the most common single reason behind the not-usable rows.
Open chat ↗
29

Decide Keep Or Change

You get a written call on whether this workflow earns a second stage or needs rework.

DecidesWritesNumbers
Help me write the call on whether this workflow earns a second stage, needs rework, or stops here.

Ask me for all of these before you decide anything:
- my start-versus-now comparison of spend, runs and operators, pasted in
- my hand-graded sample of saved routes with the three ratings, pasted in
- the one-line reason I chose this workflow first
- what I would build next if this one is done

Then apply this rule and show your working line by line:
1. Of the routes I graded, did more come out usable as saved than not usable?
2. Is the cost per finished job a metered number, and is it one I would pay again next month?
3. Did operators start runs themselves, without me prompting them?

All three yes is **keep and move on** — the workflow earns a second stage. One no with a named cause is **rework** — say which of the three failed, and name the single change that would move it, not a list. Two or more no is **hold** — keep the pack pinned as it is, change nothing, and re-run this review in another thirty days with the missing numbers collected.

If any of the three answers is unknown because the evidence is not there, write unknown. Do not read unknown as a yes. A call of "not yet decided, and here is the number I am missing" is a finished call and belongs on the page.

If my numbers point to rework or hold and I still want to start a second workflow now, say that once, in one short paragraph, with the reason: a second stage doubles what I have to review and I am the only reviewer. If I still want it after hearing you, record my call and write the risk in one line underneath it.

Finish with one page I can keep: the decision in a single sentence, the three answers with their evidence labels, the one change I am making next if any, the date of the next review, and the list of things I am explicitly not starting yet.
Open chat ↗