Skills

The repeatable-offer skill: stop quoting every job from scratch

4 minute readUpdated August 2026Explore more

TL;DR

repeatable-offer finds the 80% of your custom work that repeats on every job and puts a box around it: one deliverable, one timeline, one price, a written list of what's not included, and the checklist you run on every order. It saves a one-pager that works as both your sales page and your delivery guide. It installs in three lines.

Every sale starts at zero. You re-explain what you do, guess a number off the top of your head, and then the job quietly grows past what you agreed to. Three months of that and you're busy and tired and nothing compounds.

The repeatable-offer skill fixes the part underneath all of it. It walks you through your last two or three jobs, finds what was the same every single time, and wraps that part in a fixed name, a fixed deliverable, a fixed timeline, a fixed price, and a written list of what you're not doing. Productizing is the word for it: taking a service and giving it edges, like a thing on a shelf.

One of the 55 free skills in our freeskills repo. The one-pager it writes does double duty, because it's the thing you send a buyer and the checklist you follow while you deliver.

repeatable-offer

Finding the repeatable core, fixing the deliverable and timeline, drawing the scope box, and the delivery checklist.

Install the repeatable-offer skill

Skills sit in a directory Claude Code checks when it starts. Copy this one across with the three lines below and it turns into a slash command.

bashgit clone https://github.com/duncan-buildroom/freeskills.git
mkdir -p ~/.claude/skills
cp -r freeskills/repeatable-offer ~/.claude/skills/

Open a fresh Claude Code session, or restart it, and the skill is live. That's the entire setup. Nothing to configure and no API keys.

Run it the first time

Type /repeatable-offer. It asks you to walk through the last two or three times you did this work, job by job, and then looks for what was identical across all of them. Expect it to push here. It wants your core written as one sentence, in the shape of taking one kind of input and turning it into one outcome, and it won't move on while that sentence is still vague.

Then it does the step most people skip: writing down what is not included. It caps the variables with real numbers and turns the extras people keep asking for into named add-ons with their own prices. A paid add-on is a yes, and a free extra is a leak.

A good first result: a file in ~/offers/ named after the product, holding the core sentence, the deliverable, what "done" means, the timeline, the included and not-included and add-on lists, the name and one-line promise and price, how it gets delivered, and the standard checklist you run on every order. Then send that one-line promise to one person who fits and see what they ask about. The questions are the parts of the box that aren't clear yet.

Find the repeatable part of your custom work

The raw material is your last few jobs. Describe them the way you'd describe them to a friend.

/repeatable-offer

I do [the kind of work] for [who]. Here are the last three jobs:
1. [what they wanted, what you actually did, what you charged]
2. [same]
3. [same]

Every job is different and I quote off the top of my head. Find the part that's the same every time and box it up.

Close the gap where the job keeps growing

If the work always expands after they've paid, bring the specific requests that do it. Those become the not-included list and the add-ons.

The scope keeps growing after I've agreed the price. The things clients ask for that weren't in the deal: [list them, in the words they use].

Tell me which of these belong inside the fixed offer, which become paid add-ons with a number on them, and which I should be saying no to. Then write the not-included list I can put in front of a buyer.

Name it so people understand it in ten seconds

A name that says the outcome sells better than one that says the process. Ask for the naming pass on its own if the rest is already settled.

The offer is: [deliverable] in [timeline] for [price], for [who it's for].

Give me five names that say what the buyer ends up with, not what I do to get there. Short enough to say out loud. Then write the one-line promise underneath the one you'd pick.

The 60-second version

Here's what it does to your service, said the way you'd say it to a friend who's drowning in custom work.

  1. 1Hook: if you quote every job from scratch, you're doing it wrong. This free skill turns your repeat work into one named package with a fixed price.
  2. 2Step 1: you walk it through your last two or three jobs.
  3. 3Step 2: it finds the part you did on every single one, which is the actual product, and writes it as one sentence.
  4. 4Here's the move that makes it repeatable.
  5. 5Step 3: it fixes the deliverable, the timeline, and the price, and writes down what you're not doing so the job can't quietly grow.
  6. 6There's one more piece, and you'll use it on every order.
  7. 7Step 4: it writes the delivery checklist you run each time, which is what makes this repeatable in real life instead of on paper.
  8. 8Transformation: the next person who asks what it costs gets a number and a delivery date in one message. And you deliver it the same way you delivered the last one, which is when this work finally stops being exhausting.
  9. 9Close: it's free, and it's one of 55 in that repo. Getting the offer live and getting people in front of it is Claude Code Club, $9 a month. Link's below.

Tonight: run it on the request you get most often, not on your whole service. One narrow offer that sells twice beats a flexible one that never sells the same way once.

Common questions

  • Do I need to know how to code?

    No. Three copy-paste lines install it. After that you're describing jobs you've already done, in plain English.

  • Is it really free?

    Yes. Public repo, no API keys, no account. Claude Code Club at $9 a month is the separate paid thing.

  • What if nothing repeats across my jobs?

    Then you're not ready to productize the whole service yet, and the skill says so. Pick the single request you get most often and box that one up first.

  • What if I've only done this work once?

    You'd be guessing at the core. Do the next job, take notes on what you actually did, then run this again with real material behind it.

  • How is this different from offer-builder?

    offer-builder makes an offer harder to say no to, with a stack and a guarantee. This one makes it repeatable, so you deliver the same thing the same way every time. Run this first if the problem is that every job is custom.

Want the whole productized service system?

Get 650+ plug-and-play skills, MCPs & prompts, plus 7,000+ members - $9/mo, cancel anytime.

Join the Club