# case-study

Adopt this skill: https://proskills.md/skills/other/jakeschincariol-whale-skill-case-study

Page: https://proskills.md/skills/other/jakeschincariol-whale-skill-case-study
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: case-study/SKILL.md
size: 4373
sha: a5b3ba88f37fcab18f0a2e84db0da6ba67a0df1f
upstream: https://github.com/jakeschincariol/whale-skill/blob/main/case-study/SKILL.md

````text
---
name: case-study
description: >-
  Case Study. Turns the first customer into proof, with their permission. Once the product has shipped, it
  writes a short before-and-after from their real numbers and their real words, and keeps it marked as a
  draft until they have approved that exact text in writing. Change a word and it asks again. Use when the
  user says "case study", "testimonial", "customer story", "get a quote from them", "write up the result",
  "social proof", "can I use their name", or once a customer has seen results.
argument-hint: "[draft <deal> | approve <deal> | check <deal>]"
---

# case-study

Before you have customers, you sell on the demo and the refund. After you have one, you sell on them. One real
story, with a name and a number, is worth more than anything you could write about yourself. But it's a claim
about a real company, so it has to be true and it has to be theirs to give.

`${CLAUDE_SKILL_DIR}` below is this skill's folder (where this SKILL.md lives).

```bash
python3 "${CLAUDE_SKILL_DIR}/casestudy.py" draft --deal north-pier --before "Paid \$6,400 a month to chase invoices" \
    --after "Cancelled the collections service" --source "North Pier's own numbers, Jan 2027" \
    --quote "We stopped thinking about late invoices." --quote-by "Renee Alvarez, CFO"
python3 "${CLAUDE_SKILL_DIR}/casestudy.py" approve --deal north-pier --said "Approved, go ahead." --at 2027-02-10
python3 "${CLAUDE_SKILL_DIR}/casestudy.py" check --deal north-pier
```

## Steps

1. **Wait for a result.** `draft` refuses until the deal is `delivered` (`/pre-sale deliver`). Give it long enough to have a real number.
2. **Ask first.** "Send this to Renee: would you be open to a short write-up, if you approve every word? Reply yes or no." A no is fine, and it ends here.
3. **Get the real numbers from them.** Before and after, and where they came from. Ask what changed, in their words: "What's different now?"
4. **Draft.** `casestudy.py draft`. It writes `whale/case-studies/<deal>.md` with a DRAFT line at the top. Keep it under 150 words. A quote is what they
   actually said or wrote, word for word, with their name. Don't tidy it into something they wouldn't say.
5. **Send them the exact text.** "Send this to Renee for approval? Reply yes or no."
6. **Log their approval.** `casestudy.py approve --said "<their words>"`. It removes the DRAFT line, for this text only.
7. **Check before every use.** `casestudy.py check`. If the text changed after they approved it, it says to ask again.
8. **Use it.** On the next pitch, in `/offer-builder`, on the launch page. Only then does the "you'd be one of the first" answer in `/objection-handler` change.

## What makes it believable

- **A real name and a real company,** if they agree. If they'd rather not be named, say "a regional freight company" and keep the number.
- **One number.** "Cancelled a $6,400-a-month service" beats a list of adjectives.
- **The bad part.** What was hard before, or what took longer than expected. It's how people know it's true.
- **Typical, or not.** If one customer's result is unusually good, don't suggest everyone gets it. The FTC treats testimonials as claims you must be able to back up.

## Example from the reel's board

After North Pier Logistics has the product: Before, paid $6,400 a month to chase invoices. After, cancelled the collections service. Quote: "We stopped
thinking about late invoices." Renee Alvarez, CFO. It stays a draft until Renee approves it. (Illustrative: this result and this quote are made up to show
the format, and North Pier and Renee are fictional. Your case study uses only what your customer gives you.)

## What it never does

- Never writes a case study before delivery, and never makes up a quote, a number or a logo.
- Never publishes or sends anything without a yes, and never uses a draft their approval doesn't cover.
- Never presents a pre-sale payment as a result. "They paid" is not "it worked".

## Consent and truth

- Nothing is sent or published without the user's explicit yes for that exact message, and the customer's written approval of that exact text. One yes per message. Never "yes to all".
- Stop at the first "no". Not wanting a case study never affects how the customer is treated.
- Never invent a number, a result, a client or a quote. If they withdraw their approval, take it down.
````

## File: case-study/casestudy.py
size: 6273
sha: 06a2789d31b675d6d60450f7b07a71312ff7a795
upstream: https://github.com/jakeschincariol/whale-skill/blob/main/case-study/casestudy.py

```text
#!/usr/bin/env python3
"""Turns the first customer into proof, with their permission. Standard library only.

A case study is a claim about a real company, so nothing goes in that they did not say or give
you, and it stays marked DRAFT until they have approved that exact text in writing. It only
starts once the product has shipped: proof comes after delivery, never before.

  draft    writes whale/case-studies/<deal>.md
  approve  logs the customer's written approval of the exact text
  check    what is missing before it can be used

    python3 casestudy.py draft --deal north-pier --before "Paid $6,400 a month to chase invoices" \
        --after "Paid invoices up 31% in 60 days" --source "North Pier's AR report, Jan 2027" \
        --quote "We stopped thinking about late invoices." --quote-by "Renee Alvarez, CFO"
    python3 casestudy.py approve --deal north-pier --said "Approved, go ahead." --at 2027-02-10
    python3 casestudy.py check --deal north-pier
"""

import argparse
import hashlib
import importlib.util
import os
import sys

HERE = os.path.dirname(os.path.abspath(__file__))
OUT_DIR = os.path.join("whale", "case-studies")

def _board():
    path = os.path.join(HERE, "..", "market-researcher", "board.py")
    if not os.path.exists(path):
        sys.exit("The case-study skill needs the market-researcher skill next to it (../market-researcher/board.py).")
    spec = importlib.util.spec_from_file_location("whale_board", path)
    mod = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(mod)
    return mod

B = _board()

def study_for(data, deal_id):
    return next((s for s in data["case_studies"] if s["deal_id"] == deal_id), None)

def text_of(data, study):
    deal = B.need(data["deals"], study["deal_id"], "deal")
    company = B.need(data["companies"], deal["company_id"], "company")
    me = data.get("me", {})
    lines = ["# %s and %s" % (company["name"], me.get("product") or "[fill: product]"), "",
             "**Before:** %s" % study["before"], "", "**After:** %s" % study["after"], ""]
    if study.get("quote"):
        lines += ["> \"%s\"" % study["quote"], "> %s" % study.get("quote_by"), ""]
    lines.append("Numbers from: %s" % study["source"])
    return "\n".join(lines) + "\n"

def fingerprint(text):
    return hashlib.sha256(text.encode("utf-8")).hexdigest()[:16]

def draft(data, deal_id, before, after, source, quote=None, quote_by=None):
    deal = B.need(data["deals"], deal_id, "deal")
    if deal.get("stage") != "delivered":
        raise B.BoardError("%s is at %s. Proof comes after delivery: nothing to write up yet." % (deal_id, deal.get("stage")))
    if not (before and after and source):
        raise B.BoardError("A case study needs before, after and where the numbers came from.")
    if quote and not quote_by:
        raise B.BoardError("A quote needs the name of the person who really said it.")
    study = study_for(data, deal_id)
    if study is None:
        study = {"id": B.next_id(data["case_studies"], "s"), "deal_id": deal_id}
        data["case_studies"].append(study)
    # A changed draft needs a new approval: they approved the words, not the idea.
    study.update(before=before, after=after, source=source, quote=quote, quote_by=quote_by, approval=None, approved_text=None)
    return study

def approve(data, deal_id, said, when):
    study = study_for(data, deal_id)
    if study is None:
        raise B.BoardError("No draft for %s yet." % deal_id)
    if not (said or "").strip() or B.NO_RE.search(said):
        raise B.BoardError("That is not an approval. It stays a draft.")
    study["approval"] = {"said": said, "at": when}
    study["approved_text"] = fingerprint(text_of(data, study))
    return study

def write_file(path, text):
    folder = os.path.dirname(path)
    if folder:
        os.makedirs(folder, exist_ok=True)
    with open(path, "w", encoding="utf-8") as fh:
        fh.write(text)

def problems(data, deal_id):
    study = study_for(data, deal_id)
    if study is None:
        return ["no draft yet"]
    out = []
    if not study.get("approval"):
        out.append("not approved by the customer in writing")
    elif study.get("approved_text") != fingerprint(text_of(data, study)):
        out.append("the text changed after they approved it: ask again")
    return out

def main(argv=None):
    ap = argparse.ArgumentParser(description="The first customer, as proof.")
    ap.add_argument("--file", default=B.DEFAULT_FILE)
    sub = ap.add_subparsers(dest="cmd", required=True)
    p = sub.add_parser("draft")
    p.add_argument("--deal", required=True)
    p.add_argument("--before", required=True)
    p.add_argument("--after", required=True)
    p.add_argument("--source", required=True)
    p.add_argument("--quote")
    p.add_argument("--quote-by")
    p.add_argument("--out")
    p = sub.add_parser("approve")
    p.add_argument("--deal", required=True)
    p.add_argument("--said", required=True)
    p.add_argument("--at", required=True)
    p = sub.add_parser("check")
    p.add_argument("--deal", required=True)
    args = ap.parse_args(B.file_first(argv))
    try:
        data = B.load(args.file)
        if args.cmd == "check":
            found = problems(data, args.deal)
            for line in found:
                print(line)
            print("OK to use." if not found else "Not ready: stays a draft.")
            return 1 if found else 0
        if args.cmd == "approve":
            study = approve(data, args.deal, args.said, args.at)
            B.save(data, args.file)
            write_file(os.path.join(OUT_DIR, args.deal + ".md"), text_of(data, study))
            print("Approved, for this exact text.")
            return 0
        study = draft(data, args.deal, args.before, args.after, args.source, args.quote, args.quote_by)
        B.save(data, args.file)
        text = "DRAFT: not approved by the customer. Do not publish.\n\n" + text_of(data, study)
        out = args.out or os.path.join(OUT_DIR, args.deal + ".md")
        write_file(out, text)
        print(text, end="")
        print("\nWrote %s" % out)
        return 0
    except (B.BoardError, OSError, ValueError) as err:
        print(err, file=sys.stderr)
        return 1

if __name__ == "__main__":
    sys.exit(main())
```

## File: case-study/test_casestudy.py
size: 2516
sha: f1fb413fd472e27c1f888d1e30aace6f22e2914a
upstream: https://github.com/jakeschincariol/whale-skill/blob/main/case-study/test_casestudy.py

```text
import importlib.util
import json
import os
import unittest

HERE = os.path.dirname(os.path.abspath(__file__))
spec = importlib.util.spec_from_file_location("whale_casestudy_test", os.path.join(HERE, "casestudy.py"))
C = importlib.util.module_from_spec(spec)
spec.loader.exec_module(C)
B = C.B
EXAMPLE = os.path.join(HERE, "..", "market-researcher", "whale.example.json")

def delivered():
    with open(EXAMPLE, encoding="utf-8") as fh:
        d = json.load(fh)
    deal = B.find(d["deals"], "north-pier")
    deal.update(stage="delivered", delivered_on="2026-12-01")
    return d

class CaseStudy(unittest.TestCase):
    ARGS = ("Paid $6,400 a month", "Cancelled the service", "North Pier's own numbers")

    def setUp(self):
        self.d = delivered()

    def test_proof_comes_after_delivery(self):
        with self.assertRaises(B.BoardError):
            C.draft(self.d, "saltmarsh", *self.ARGS)

    def test_needs_before_after_and_where_the_numbers_came_from(self):
        with self.assertRaises(B.BoardError):
            C.draft(self.d, "north-pier", "before", "after", "")

    def test_a_quote_needs_a_real_name(self):
        with self.assertRaises(B.BoardError):
            C.draft(self.d, "north-pier", *self.ARGS, quote="Great stuff")

    def test_stays_a_draft_until_approved(self):
        C.draft(self.d, "north-pier", *self.ARGS, quote="We stopped thinking about it.", quote_by="Renee Alvarez, CFO")
        self.assertEqual(C.problems(self.d, "north-pier"), ["not approved by the customer in writing"])
        with self.assertRaises(B.BoardError):
            C.approve(self.d, "north-pier", "Not interested.", "2027-02-10")
        C.approve(self.d, "north-pier", "Approved, go ahead.", "2027-02-10")
        self.assertEqual(C.problems(self.d, "north-pier"), [])
        self.assertEqual(B.validate(self.d)[0], [])

    def test_they_approved_the_words_not_the_idea(self):
        C.draft(self.d, "north-pier", *self.ARGS)
        C.approve(self.d, "north-pier", "Approved.", "2027-02-10")
        C.study_for(self.d, "north-pier")["after"] = "Saved a million dollars"
        self.assertIn("the text changed after they approved it: ask again", C.problems(self.d, "north-pier"))
        C.draft(self.d, "north-pier", *self.ARGS)
        self.assertIn("not approved by the customer in writing", C.problems(self.d, "north-pier"))

    def test_no_draft(self):
        self.assertEqual(C.problems(self.d, "saltmarsh"), ["no draft yet"])

if __name__ == "__main__":
    unittest.main()
```

## File: README.md
upstream: https://github.com/jakeschincariol/whale-skill/blob/main/README.md

````text
# The Whale skill

Eleven Claude skills that get you paying customers before you launch. Free, MIT, no signup, no API key.

`market-researcher` `demo-builder` `whale-hunter` `pre-sale` `requirements` `offer-builder`
`pricing` `follow-up` `objection-handler` `case-study` `launch-planner`

One acts as your market researcher, finding problems businesses already pay thousands to solve. Another
builds a demo showing how your product solves them. One finds the decision makers and pitches them. And the
craziest one is the pre-sale skill: it gets customers to pay up front and uses their requirements to build
the exact product.

So instead of building for a year and paying for marketing to find out nobody wants it, you find out with real
money first, and you build exactly what was paid for.

Nothing is ever sent or charged without your yes. Claude drafts, you approve, it goes out from your own
accounts. It can't promise that anyone will buy: only they can tell you that, and that's the point.

## Install

Paste this repo link into Claude and say `install skill`:

```
https://github.com/Jakeschincariol/whale-skill

install skill
```

Or as a plugin, in Claude Code:

```
/plugin marketplace add Jakeschincariol/whale-skill
/plugin install whale-skill@whale-skill
```

Claude Code namespaces plugin skills, so installed as a plugin they show up as
`/whale-skill:pre-sale` and so on. Copy the folders instead if you want plain `/pre-sale`:

```bash
git clone https://github.com/Jakeschincariol/whale-skill.git
cd whale-skill && cp -r market-researcher demo-builder whale-hunter pre-sale requirements offer-builder \
    pricing follow-up objection-handler case-study launch-planner ~/.claude/skills/
```

Keep all eleven together: they share `market-researcher/board.py`. No Claude Code at all? Paste any single
`SKILL.md` at the top of a chat and it runs as a mode. You lose the Python tools, but the method works.
The tools need Python 3.8 or newer. Nothing to pip install.

Works best with Claude's Gmail connector (email goes out from your own account) and the Stripe connector (the
checkout is in your own Stripe account). You need a Stripe account to take money. Stripe takes its normal fee.

## The eleven

| skill | job | what it does |
| --- | --- | --- |
| `market-researcher` | Market Researcher | Finds problems businesses already pay thousands to solve, with a source for every number, and sets up the board. |
| `demo-builder` | Demo Builder | Builds a clickable demo showing how your product solves it, with sample data and a banner that says so. |
| `whale-hunter` | Whale Hunter | Finds who signs the check at the company you want, and writes the pitch. |
| `pre-sale` | Pre-Sale | Gets customers to pay up front through your own Stripe: it isn't finished, here's the date, here's the way out. Tells you when you're validated, and holds you to the date. |
| `requirements` | Requirements | Turns what they asked for into the build list, ranked by the paid money behind each line. |
| `offer-builder` | Offer Builder | Writes the one-page offer they can say yes to, and refuses fake urgency and made-up proof. |
| `pricing` | Pricing | Sets the price from what they pay today, with the working shown. |
| `follow-up` | Follow-Up | Keeps the deal moving: a bump, something useful, a last note. Stops at the first no. |
| `objection-handler` | Objection Handler | Has an honest answer to every objection ready, and knows a no when it hears one. |
| `case-study` | Case Study | Turns the first customer into proof, from their real numbers, with their written approval of every word. |
| `launch-planner` | Launch Planner | Plans the launch once it's paid for, backwards from the dates you promised. |

## How to use it

Everything lands in a `whale/` folder in your project, and each skill reads what the last one wrote.

An example, the one in the reel: a founder with an idea for a product that chases late invoices.

1. **`market-researcher`** builds the table of problems businesses already pay for. The pick: freight companies pay
   about $6,400 a month to chase late invoices.
2. **`demo-builder`** builds Your Product: five late invoices, one button, "Chase all", $48,210.00 collected. A banner
   says it's sample data.
3. **`whale-hunter`** finds who decides at North Pier Logistics, and writes to the CFO: "North Pier pays about $6,400 a
   month to chase late invoices. We built a demo that does it automatically. Can I show you in 2 minutes?" You say yes.
4. **`follow-up`** bumps it once. She replies and books the demo.
5. **`pricing`** works it out: they pay $76,800 a year, so $24,000 is 31% of that. **`offer-builder`** writes the page.
   **`objection-handler`** has the answer when she asks, "What if you never ship it?"
6. **`pre-sale`** makes the Stripe link: $24,000.00, ships in 30 days, not finished yet, every dollar back if it doesn't ship.
   North Pier pays. Two more freight companies follow. VALIDATED: 3 paying customers, $54,000.00 in, $0.00 spent on marketing.
7. **`requirements`** turns "Sync with QuickBooks" and "Weekly report to the CFO" into the build list, and you build exactly that.
8. **`launch-planner`** works back from the first promised date. The public launch waits until customers have it.
   **`case-study`** turns the first result into proof, with their approval.

(Your Product, North Pier, everyone at it, and every dollar here are fictional.)

## The tools

All standard-library Python. Nothing here reads a website or calls an API: Claude does the research and uses your connectors, and
the tools keep the board honest.

```bash
python3 market-researcher/board.py board                               # the board
python3 market-researcher/problems.py rank                             # problems, who pays, what they pay
python3 demo-builder/demo.py build --spec whale/demo.json              # the demo, one HTML file
python3 whale-hunter/hunter.py who --company north-pier                # who decides
python3 whale-hunter/hunter.py draft --deal north-pier --demo <link>   # the pitch
python3 pre-sale/presale.py link --deal north-pier                     # what to create in Stripe
python3 pre-sale/presale.py validated                                  # paying customers against your target
python3 pre-sale/presale.py due                                        # every date you promised
python3 requirements/reqs.py build                                     # the build list
python3 offer-builder/offer.py draft --deal north-pier                 # the offer
python3 pricing/price.py check --pay-month 6400 --price 24000          # what a price means for them
python3 follow-up/followup.py due                                      # who to follow up with today
python3 objection-handler/objections.py match --text "too expensive"   # what to say
python3 case-study/casestudy.py check --deal north-pier                # may this be used yet?
python3 launch-planner/launch.py gate                                  # may this launch yet?
```

Try any of them on the reel's example board with `--file market-researcher/whale.example.json`.
The tests live next to each tool:

```bash
for d in */; do python3 -m unittest discover -s "$d" -p "test_*.py"; done
```

## Fine print

**You are taking money for something that doesn't exist yet. Treat that seriously.** The buyer always sees that it isn't finished,
the date it ships and how they get their money back, right above the pay button. Don't take money for something you don't intend
to build. Promise a date you would bet on.

**Keep the money until it ships.** Stripe's guidance on pre-orders says they carry real risk, and recommends partial deposits, limiting
orders, realistic dates and keeping enough cash for refunds and disputes. A customer can dispute a card charge, and Stripe can hold funds.
Spend it, and you may not be able to pay it back.

**When a date slips, they hear it from you first.** They get the new date and their money back if it doesn't work for them
````
