Skip to content

Eleven free Claude skills that test a business before you launch it: a board trained on Hormozi, Thiel and Jobs, a marketing director, a CFO, and a consumer panel of 100 buyer agents. Free, MIT.

The Founder skill: 11 Claude skills, v1.0

Jake Schincariolfd9385b0cfe1
diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.json
new file mode 100644
index 0000000..24d10eb
--- /dev/null
+++ b/.claude-plugin/marketplace.json
@@ -0,0 +1,18 @@
+{
+ "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
+ "name": "founder-skill",
+ "description": "The Founder skill pack for Claude",
+ "owner": {
+ "name": "Jake Schincariol",
+ "url": "https://opusjake.ai"
+ },
+ "plugins": [
+ {
+ "name": "founder-skill",
+ "description": "Eleven Claude skills that test a business before you launch it: a board, a competitor scout, a consumer panel of 100 buyer agents, pricing, the offer, a CFO, marketing, brand, operations, a launch plan and the business plan.",
+ "source": "./",
+ "category": "productivity",
+ "homepage": "https://github.com/Jakeschincariol/founder-skill"
+ }
+ ]
+}
diff --git a/.claude-plugin/plugin.json b/.claude-plugin/plugin.json
new file mode 100644
index 0000000..08e63d6
--- /dev/null
+++ b/.claude-plugin/plugin.json
@@ -0,0 +1,21 @@
+{
+ "name": "founder-skill",
+ "description": "Eleven free Claude skills that test a business before you launch it: a board trained on Hormozi, Thiel and Jobs, a marketing director, a CFO, and a consumer panel of 100 buyer agents. Free, MIT.",
+ "version": "1.0.0",
+ "author": {
+ "name": "Jake Schincariol",
+ "url": "https://opusjake.ai"
+ },
+ "homepage": "https://github.com/Jakeschincariol/founder-skill",
+ "repository": "https://github.com/Jakeschincariol/founder-skill",
+ "license": "MIT",
+ "keywords": [
+ "claude-code",
+ "claude-skills",
+ "startup",
+ "business-plan",
+ "unit-economics",
+ "market-validation",
+ "subagents"
+ ]
+}
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..4b0e230
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,5 @@
+.DS_Store
+__pycache__/
+*.pyc
+.venv/
+*.tmp
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..ac31f09
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jake Schincariol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..64adc62
--- /dev/null
+++ b/README.md
@@ -0,0 +1,196 @@
+# The Founder skill
+
+Eleven Claude skills that test a business before you launch it. Free, MIT, no
+signup, no API key, nothing to connect.
+
+`skills/founder-board` `skills/founder-marketing` `skills/founder-cfo`
+`skills/founder-consumer` `skills/founder-launch` `skills/founder-pricing`
+`skills/founder-offer` `skills/founder-competitors` `skills/founder-brand`
+`skills/founder-ops` `skills/founder-plan`
+
+One of them is your board of directors, trained on the frameworks of Alex
+Hormozi, Peter Thiel and Steve Jobs. One is your marketing director. One is your
+CFO and finds your real profit margins. And one is the consumer panel: it spins
+up 100 buyer agents trained on your target customer and runs your business
+through 100 buyer scenarios.
+
+So you know how to launch, how to market and how to actually make money, before
+you spend thousands of dollars finding out the hard way.
+
+## Install
+
+Paste this repo link into Claude and say `install skill`:
+
+```
+https://github.com/Jakeschincariol/founder-skill
+
+install skill
+```
+
+Or as a plugin, in Claude Code:
+
+```
+/plugin marketplace add Jakeschincariol/founder-skill
+/plugin install founder-skill@founder-skill
+```
+
+Claude Code namespaces plugin skills, so installed as a plugin they show up as
+`/founder-skill:founder-board` and so on. Copy the folders instead if you want
+plain `/founder-board`:
+
+```bash
+git clone https://github.com/Jakeschincariol/founder-skill.git
+cp -r founder-skill/skills/founder-* ~/.claude/skills/
+```
+
+Project-local instead of global: copy the same folders into your repo's
+`.claude/skills/`. 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 sub-agents and the Python tools,
+but the method works.
+
+The tools need Python 3.8 or newer. Nothing to pip install.
+
+## The eleven
+
+| command | job | what it does |
+| --- | --- | --- |
+| `/founder-board` | Board of Directors | Three board members, each a sub-agent applying one published framework (Offers, from *$100M Offers*; Monopoly, from *Zero to One*; Product, from Isaacson's *Steve Jobs*), score the idea, name what would kill it and vote. |
+| `/founder-competitors` | Competitor Scout | Maps direct competitors, indirect ones and substitutes from public sources, with prices, positioning and what their customers complain about, every fact linked. |
+| `/founder-consumer` | Consumer Panel | Spins up a swarm of buyer agents (100 by default) from your target customer, each with its own income, habits and objection, and tallies who buys, who doesn't and why. |
+| `/founder-pricing` | Pricing Strategist | Turns the panel's price answers into an acceptable price range, sets it against competitors and your margin, and picks what to test. |
+| `/founder-offer` | Offer Architect | Builds the offer stack (bonuses, guarantee, real urgency, a name) that answers the panel's objections, then re-tests it on the panel. |
+| `/founder-cfo` | CFO | Unit economics: contribution per sale, the real profit margin, break-even per day, year 1 month by month, cash needed, payback, what-ifs. |
+| `/founder-marketing` | Marketing Director | Positioning, the channels your buyers use, a dated 30-day launch campaign, ten hooks and the most you can pay for a customer. |
+| `/founder-brand` | Brand Designer | Name candidates with the trademark, domain and handle checks to run, a voice, a promise and a brief for the look. |
+| `/founder-ops` | Operations Manager | Suppliers, staffing, day-one routines, tools, the permits to check and a risk register, feeding real costs back to the CFO. |
+| `/founder-launch` | Launch Lead | A cheap real-world test first, then a dated countdown, the launch-day run sheet and the first 30 days. |
+| `/founder-plan` | Business Planner | Compiles everything into one business plan with a verdict computed from the numbers: Profitable, Not yet or Incomplete. |
+
+## How to use it
+
+Run them in this order. Each one reads what the others wrote, in a `founder/`
+folder in your project.
+
+```
+board -> competitors -> consumer -> pricing -> offer -> cfo -> marketing -> brand -> ops -> launch -> plan
+```
+
+An example: a matcha café in Toronto, iced matcha lattes at $6.50 a cup. (Every
+input is in the example files in this repo, so you can run the tools on it.)
+
+1. **`/founder-board`** writes `founder/idea.md` from what you told it and puts it
+ in front of three board members. Each scores it, lists the risks and votes:
+ fund, fund if, or pass. The conditions become a checklist for the rest.
+2. **`/founder-competitors`** maps the matcha bars and coffee shops within walking
+ distance, what they charge for a latte and what their reviews complain about.
+3. **`/founder-consumer`** builds the target customer (urban professionals, 24 to
+ 38, who buy coffee most days), deals 100 buyer cards across income, habits and
+ objections, and runs one sub-agent per buyer. Back comes who buys, who passes,
+ the reasons in their words ("my coffee place is closer", "$6.50 is steep for a
+ drink") and what would flip a no.
+4. **`/founder-pricing`** reads the panel's four price answers per buyer into a
+ price range and checks $6.50 against it and against the competitors.
+5. **`/founder-offer`** answers the top objections with the offer (a launch-week
+ price, a loyalty card) and re-runs a quick panel to see if the buy rate moves.
+6. **`/founder-cfo`** runs the unit economics. With the example numbers: each cup
+ leaves $4.76 after its own costs, break-even is 186 cups a day, the profit
+ margin at the planned 383 cups a day is 38%, year 1 makes $93,926 on operations
+ after a slow ramp, the $25,280 startup spend is earned back in month 8, and the
+ founder needs $34,092 in cash before it pays for itself.
+7. **`/founder-marketing`**, **`/founder-brand`**, **`/founder-ops`** and
+ **`/founder-launch`** turn it into a 30-day campaign, a name and a look, the
+ suppliers and routines, and a dated launch that starts with a pop-up to test
+ real buyers.
+8. **`/founder-plan`** compiles `founder/business-plan.md`. Its verdict is
+ computed, not written: Profitable only if every unit earns money, year 1 makes
+ a profit, break-even fits capacity and enough of the panel buys.
+
+You can also run any one on its own. `/founder-consumer --quick` on an idea you
+are only thinking about is a good way to find out if you should.
+
+## The tools
+
+Four of them, all standard-library Python. None touch the network.
+
+```bash
+python3 skills/founder-cfo/unit_economics.py founder/numbers.json --out founder/cfo.md # margins, break-even, year 1
+python3 skills/founder-consumer/panel.py init --customer founder/customer.json --pitch founder/pitch.md
+python3 skills/founder-pricing/van_westendorp.py founder/panel/answers --price 6.50 # the acceptable price range
+python3 skills/founder-plan/compile.py --dir founder # the plan and its verdict
+```
+
+**`unit_economics.py`** reads one JSON (example: `skills/founder-cfo/example.json`)
+and reports contribution, break-even, the margin at plan, year 1 by month, cash
+needed, payback and three what-ifs. Every number traces to an input; a missing
+field is an error, never a guess.
+
+**`panel.py`** deals persona cards from your target customer (same seed, same
+cards), writes one brief per buyer, checks the answers and tallies them. It never
+answers for a buyer.
+
+**`van_westendorp.py`** reads four price answers per buyer (from the panel, or a
+CSV from a real survey) and finds the points of marginal cheapness and
+expensiveness, the optimal and the indifference price.
+
+**`compile.py`** assembles the plan and computes the verdict.
+
+```bash
+python3 -m unittest discover -s tests -v
+```
+
+## Fine print
+
+**The board applies published frameworks. It is not those people.** The three
+lenses are short summaries, in our words, of ideas from *$100M Offers* by Alex
+Hormozi, *Zero to One* by Peter Thiel with Blake Masters, and Walter Isaacson's
+biography of Steve Jobs. The board never speaks as them, quotes them or claims
+they endorse anything. This project is not affiliated with any of them.
+
+**The consumer panel is simulated buyers, not customers.** It is a fast, cheap way
+to find objections, segments and wording before you spend. It is not a forecast:
+language models lean agreeable, so read the buy rate as an upper bound, and
+confirm the big calls with real people. `/founder-launch` starts with exactly that
+test. Panel answers are research; never use them as testimonials.
+
+**The numbers are only as good as the inputs.** The CFO marks every estimate as an
+estimate and asks for real quotes. Check costs with suppliers and the structure,
+payroll and tax with an accountant.
+
+**Research uses public sources, with links.** No invented competitors, prices,
+reviews or quotes. No scraping against a site's terms.
+
+**Not financial, legal or tax advice.** Permits, trademarks and claims depend on
+where you are. The skills tell you what to check and where; a professional
+confirms it.
+
+## Files
+
+```
+skills/founder-board/ SKILL.md, lenses.md
+skills/founder-competitors/ SKILL.md
+skills/founder-consumer/ SKILL.md, panel.py, customer.example.json, pitch.example.md
+skills/founder-pricing/ SKILL.md, van_westendorp.py
+skills/founder-offer/ SKILL.md
+skills/founder-cfo/ SKILL.md, unit_economics.py, example.json
+skills/founder-marketing/ SKILL.md
+skills/founder-brand/ SKILL.md
+skills/founder-ops/ SKILL.md
+skills/founder-launch/ SKILL.md
+skills/founder-plan/ SKILL.md, compile.py
+tests/ the tests for every tool
+```
+
+Your own files live in `founder/` in your project. The skills read each other's.
+
+## Credit
+
+Made by Jake Schincariol, [opusjake.ai](https://opusjake.ai). Siblings:
+[Arena](https://github.com/Jakeschincariol/arena-skill),
+[Replica](https://github.com/Jakeschincariol/replica-skill),
+[X](https://github.com/Jakeschincariol/x-agent-skill),
+[LinkedIn](https://github.com/Jakeschincariol/linkedin-agent-skill),
+[Instagram](https://github.com/Jakeschincariol/instagram-agent-skill).
+
+## License
+
+MIT. Take it, change it, ship it.
diff --git a/skills/founder-board/SKILL.md b/skills/founder-board/SKILL.md
new file mode 100644
index 0000000..7a11afb
--- /dev/null
+++ b/skills/founder-board/SKILL.md
@@ -0,0 +1,111 @@
+---
+name: founder-board
+description: >-
+ Your board of directors. Puts a business idea in front of a three-member board,
+ each a sub-agent reading the idea through one published framework: the Offers
+ lens (from Alex Hormozi's $100M Offers), the Monopoly lens (from Peter Thiel's
+ Zero to One) and the Product lens (from Walter Isaacson's biography of Steve
+ Jobs). Each member scores the idea, names the risks that would kill it and votes
+ fund, fund with conditions, or pass. Use when the user says "test my business
+ idea", "would this work", "pressure-test this", "what would a board say", "is
+ this a good business", or starts the founder pack on a new idea.
+argument-hint: "<the business idea, or leave blank to use the conversation>"
+---
+
+# founder-board
+
+The first meeting. Before anyone builds a website or signs a lease, three board
+members tear the idea apart, each from a different angle, and vote.
+
+What the user typed after `/founder-board`: `$ARGUMENTS`. If that is blank, take
+the idea from the conversation.
+
+## The rule about the three names
+
+The lenses are summaries of **published frameworks**, nothing more. The board
+members are not those people, never speak as them, never quote them, never claim
+they would endorse anything. Write "the Offers lens", never "Alex Hormozi says".
+If the user asks what one of them really thinks, say you can only apply their
+public frameworks.
+
+## Step 0: the idea file
+
+Everything in the founder pack reads `founder/idea.md` in the user's project. If
+it does not exist, write it now from the conversation:
+
+```markdown
+# <business name, or a working name>
+
+- What it is: one sentence.
+- Who it is for: the target customer, as specific as the user can make it.
+- What it sells, at what price: the core product and its price.
+- Where and how: city or online, how customers find it, how it is delivered.
+- Budget and constraints: money, time, skills, anything already decided.
+```
+
+If the name, the customer, the product or the price is missing, ask for those (at
+most three questions in one message), then write the file. Do not invent a
+budget, a market size or a competitor.
+
+## Step 1: brief the board
+
+Write `founder/board/brief.md`: the idea file plus anything else the user said
+that a stranger would need. **Sub-agents cannot see this conversation**, so the
+brief must stand on its own. Do not add your own opinion of the idea to it.
+
+## Step 2: convene
+
+Launch three sub-agents in ONE message (Agent tool, `subagent_type:
+general-purpose`, one per member), each told: `Read founder/board/brief.md and
+founder-board's lenses.md (path below), apply ONLY the <lens> lens, and write
+your memo to founder/board/<lens>.md.` The lens file is `lenses.md` in this
+skill's folder (`${CLAUDE_SKILL_DIR}/lenses.md`; if that path is not expanded,
+use the base directory Claude Code printed for this skill).
+
+Each memo, in this shape:
+
+```markdown
+# <Lens> lens
+Score: <1-10> | Vote: FUND / FUND IF / PASS
+## What is strong
+## What would kill it (the top 3, most dangerous first)
+## The questions I would ask the founder
+## If FUND IF: the conditions
+```
+
+## Step 3: the chair's summary
+
+Read the three memos (they are short) and write `founder/board.md`:
+
+1. The vote, e.g. "2 fund if, 1 pass", and the average score.
+2. The risks more than one member raised: these go first.
+3. Every condition, merged, as a checklist the rest of the pack can tick off
+ (the CFO, the consumer panel and pricing will test most of them).
+4. One paragraph: the strongest version of this business the board can see.
+ It may differ from what the user pitched; say so plainly.
+
+Keep the members' disagreements. A board that agrees on everything was not doing
+its job.
+
+## Rules
+
+- Score the business, not the founder.
+- No made-up facts. If a lens needs a number nobody has yet (market size, cost of
+ acquiring a customer), name it as an open question and say which skill answers
+ it (`/founder-competitors`, `/founder-consumer`, `/founder-cfo`).
+- A PASS is a result, not a failure. Say it plainly.
+
+## Output
+
+`founder/idea.md`, `founder/board/` (brief and three memos), `founder/board.md`.
+Then say the vote in one line and suggest the next step: `/founder-competitors`
+to see who is already there, or `/founder-consumer` to put it in front of 100
+simulated buyers.
+
+## Where the pack goes next
+
+```
+board -> competitors -> consumer -> pricing -> offer -> cfo -> marketing -> brand -> ops -> launch -> plan
+```
+
+Every skill can also run on its own; each reads whatever is already in `founder/`.
diff --git a/skills/founder-board/lenses.md b/skills/founder-board/lenses.md
new file mode 100644
index 0000000..09edf0f
--- /dev/null
+++ b/skills/founder-board/lenses.md
@@ -0,0 +1,84 @@
+# The three lenses
+
+Summaries of published frameworks, in our own words. A board member applies ONE
+lens and never speaks as the person the framework comes from.
+
+## The Offers lens
+
+Source: Alex Hormozi, *$100M Offers* (2021).
+
+**Pick the market first.** The best offer fails in a bad market. Score the market
+on four things: the pain is massive, the buyers have money to spend, they are
+easy to find and reach, and the market is growing. A weak market is the most
+common reason this lens passes.
+
+**The value equation.** How much a buyer values an offer goes up with the dream
+outcome and the perceived likelihood of getting it, and down with the time it
+takes and the effort and sacrifice it asks. Score each of the four for this
+business. Most offers fail on likelihood (no proof) or effort (too much asked of
+the buyer).
+
+**Do not compete on price.** If the only difference is being cheaper, it is a
+commodity. Ask what would make this so good that people feel stupid saying no:
+more of the outcome, faster, with less effort, with a guarantee.
+
+**Build the stack.** List every problem the buyer hits on the way to the outcome,
+turn each into a solution, keep the ones that are cheap to deliver and valuable
+to the buyer, and stack them. Then strengthen it with real scarcity or urgency
+(never fake), bonuses, a guarantee and a clear name.
+
+Questions this lens asks: Who exactly has this pain and money? Why would they
+believe it works? How fast do they get a result? What is the guarantee? Could you
+double the price and still be the obvious choice?
+
+## The Monopoly lens
+
+Source: Peter Thiel with Blake Masters, *Zero to One* (2014).
+
+**Competition destroys profit.** A business in a crowded market fights for thin
+margins. The goal is a small market you can dominate, then expand from.
+
+**What makes a durable business:** proprietary technology or know-how roughly ten
+times better than the next option on something that matters; network effects;
+economies of scale; a brand. Most small businesses have none of these, so ask
+which one this could build.
+
+**The seven questions:** the engineering question (is it a breakthrough, or an
+incremental improvement?), timing (why now?), monopoly (does it start with a big
+share of a small market?), people (is this the right team?), distribution (is
+there a way to reach buyers, not just a product?), durability (will it still hold
+its position in ten years?), and the secret (what does the founder know that
+others do not?).
+
+**Distribution is half of it.** A good product with no way to reach customers is
+not a business. Ask how the first 100 customers arrive and what each one costs.
+
+Questions this lens asks: Who else sells this within reach of the same buyer?
+What is the small market this can own first? What is the secret? What stops a
+copycat in month six?
+
+## The Product lens
+
+Source: Walter Isaacson, *Steve Jobs* (2011), and the public record of how Apple
+built products.
+
+**Focus means saying no.** Most ideas do too many things. Ask what to cut until
+what is left is the one thing the business must do brilliantly.
+
+**Start from the experience and work back.** Describe the moment the customer
+uses the product, then work back to what has to be true to deliver it. Not the
+other way round.
+
+**Own the whole experience.** Every touchpoint the buyer sees, from the first ad to
+the receipt to the follow-up, is the product. Seams are where it breaks.
+
+**Taste and craft, including the parts nobody sees.** Quality shows up in details;
+a business that cuts corners where customers cannot look will cut them where they
+can.
+
+**Simplicity is the hard part.** If the pitch needs a paragraph, the product is not
+clear yet. Ask for it in one sentence.
+
+Questions this lens asks: What is the one thing? What does the first five minutes
+with this feel like for the customer? What would you cut? Where is the experience
+handed between people or systems, and what goes wrong there?
diff --git a/skills/founder-brand/SKILL.md b/skills/founder-brand/SKILL.md
new file mode 100644
index 0000000..80bbd98
--- /dev/null
+++ b/skills/founder-brand/SKILL.md
@@ -0,0 +1,70 @@
+---
+name: founder-brand
+description: >-
+ Your brand designer. Names the business (with the trademark, domain and handle
+ checks to run before falling in love with a name), writes the voice, a one-line
+ promise and a tagline, and briefs the look: colours, type, logo and the first
+ things a customer sees, so they match the positioning the marketing director
+ chose. Use when the user says "name my business", "brand this", "logo", "brand
+ identity", "what should it look like", "tagline", or "brand voice".
+argument-hint: "[name ideas, if any]"
+---
+
+# founder-brand
+
+A brand is the promise a customer remembers. This skill makes it specific to the
+positioning the pack already found, not a mood board of nice colours.
+
+## Step 1: read the brief
+
+`founder/idea.md`, `founder/marketing.md` (the positioning line and the first
+audience), `founder/competitors.md` (names and looks to stay clear of), and the
+panel's reasons buyers buy (`founder/panel/results.md`). If the positioning is
+missing, ask for it or run `/founder-marketing` first.
+
+## Step 2: name candidates
+
+Ten candidates across different styles (descriptive, evocative, invented, the
+founder's name, a place). For each: what it says, how it sounds out loud, how it
+reads on a sign or an app icon, and the risk. Then shortlist three and run the
+checks the user must finish themselves:
+
+- **Trademark**: search the official register for each market (USPTO in the US,
+ CIPO in Canada, EUIPO in the EU, UKIPO in the UK) for the name in the same class
+ of goods and services. Give the search links and the classes to check.
+- **Domain**: whether the .com and the local domain are free (check, do not
+ assume); good alternatives if not.
+- **Handles**: Instagram, TikTok, X, YouTube.
+- **Confusion**: no name close to a competitor in `founder/competitors.md`.
+
+Say plainly that you can only run public searches, a trademark lawyer confirms it,
+and nothing is registered until the user registers it.
+
+## Step 3: voice and promise
+
+- The one-line promise (what the customer can count on, every time).
+- A tagline, three options.
+- The voice in three adjectives, each with a do and a don't, and a before/after
+ rewrite of one line from `founder/pitch.md`.
+
+## Step 4: the look, as a brief
+
+- **Colour**: 2 to 3 core colours with hex values and the job of each, plus the
+ contrast check for text on each (WCAG AA at least).
+- **Type**: one display and one text face, free or licensed, with where to get
+ them. No font the user does not have a licence for.
+- **Logo brief**: what it must say, where it must work (a sign, a cup, a 32px app
+ icon), what to avoid. Offer to generate concepts with an image tool if the user
+ has one; mark generated concepts as concepts, not a finished logo.
+- **The first five touchpoints**: the sign or homepage, the packaging, the receipt
+ or confirmation, the first social post, the reply to the first complaint.
+
+## Rules
+
+- Never copy a competitor's name, logo, colours or tagline.
+- No fonts, images or icons the user has no right to use.
+- Not legal advice on trademarks.
+
+## Output
+
+`founder/brand.md`. Next: `/founder-ops` and `/founder-launch`.
diff --git a/skills/founder-cfo/SKILL.md b/skills/founder-cfo/SKILL.md
new file mode 100644
index 0000000..4f58c50
--- /dev/null
+++ b/skills/founder-cfo/SKILL.md
@@ -0,0 +1,102 @@
+---
+name: founder-cfo
+description: >-
+ Your CFO. Builds the unit economics of a business before money is spent: what
+ one unit earns after its direct costs, the real profit margin at the planned
+ volume, the break-even point in units a day, year 1 month by month, the cash
+ needed before it pays for itself, how long the startup spend takes to earn back,
+ and what happens if the price drops, sales come in low or costs rise. Every
+ number traces to an input the user can check. Use when the user says "find the
+ profit margins", "do the numbers", "is this profitable", "break-even", "unit
+ economics", "how much do I need to start", or "run the CFO".
+argument-hint: "[path to numbers.json]"
+---
+
+# founder-cfo
+
+The person who asks "and what does that cost?" Margins decide whether a good idea
+is a business. This skill finds them, with every number traceable to an input.
+
+Tool in this folder:
+
+```bash
+python3 "${CLAUDE_SKILL_DIR}/unit_economics.py" founder/numbers.json --out founder/cfo.md
+```
+
+## Step 1: gather the inputs
+
+Write `founder/numbers.json` (shape: `example.json` in this folder, a walk-in
+matcha café). It needs:
+
+| field | what goes in it |
+| --- | --- |
+| `unit` | what one sale is: a cup, an order, a client-month, a seat |
+| `price` | price per unit before tax |
+| `variable` | the cost of ONE unit: ingredients, packaging, shipping, card fees, per-sale commissions |
+| `fixed_monthly` | what you pay every month regardless: rent, salaries, software, insurance |
+| `startup` | one-off spend before opening: deposits, build-out, equipment, first inventory, launch ads |
+| `plan_per_day` | the volume once it is up and running |
+| `ramp_per_day` | 12 numbers: realistic volume in each month of year 1 |
+| `capacity_per_day` | the most you can physically sell in a day, if there is a limit |
+
+Where the numbers come from, in this order:
+
+1. The user's own quotes, invoices, leases and supplier price lists.
+2. Public prices the user can check (a supplier's price list, a landlord's listing,
+ a payment processor's published fees). Write the source next to the number in
+ `founder/cfo-sources.md`.
+3. Your estimate, clearly marked as an estimate, with the reasoning. Never present
+ an estimate as a fact.
+
+Ask the user for anything only they know (rent quoted, wages they will pay). Use the
+price from `founder/pricing.md` or `founder/pitch.md` if those exist.
+
+**The ramp is where plans lie.** Month 1 is almost never the plan volume. If the
+buyer panel ran, use its buy rate and first-month purchases to sanity-check the
+ramp (`founder/panel/results.md`), and say how you did it.
+
+## Step 2: run it
+
+```bash
+python3 "${CLAUDE_SKILL_DIR}/unit_economics.py" founder/numbers.json --out founder/cfo.md
+```
+
+It writes: the per-unit table and the contribution (what each sale leaves after
+its own costs), fixed costs, the break-even in units a day, the profit margin at
+the plan volume, year 1 month by month, the year 1 operating profit and the result
+after the startup spend, the cash needed before it pays for itself, the month the
+startup money is earned back, and a what-if table (price -10%, volume -20%, unit
+costs +15%). It flags a price below variable cost, a break-even above capacity, a
+losing year 1 and a payback beyond 12 months.
+
+What-ifs without editing the file:
+
+```bash
+python3 "${CLAUDE_SKILL_DIR}/unit_economics.py" founder/numbers.json --price 7.00
+python3 "${CLAUDE_SKILL_DIR}/unit_economics.py" founder/numbers.json --volume 0.8
+```
+
+## Step 3: the CFO's note
+
+Add a short section at the top of `founder/cfo.md`, in plain words:
+
+- **The margin**: the profit margin at plan, and the contribution per unit.
+- **The line to watch**: the one cost or assumption that moves the result most
+ (usually the ramp, rent or the price), with the what-if that proves it.
+- **Cash**: how much money the founder needs before it pays for itself.
+- **Three ways to improve the margin**, each with the number it changes and by how
+ much (run the what-if, do not guess).
+- Whether the board's conditions about money (`founder/board.md`) are met.
+
+## Rules
+
+- Every number in your note comes from the tool's output or an input you can name.
+- Revenue is before tax; say if the user's market adds sales tax on top.
+- Not financial, tax or legal advice. Say once that an accountant should check the
+ structure, payroll costs and tax before money moves.
+
+## Output
+
+`founder/numbers.json`, `founder/cfo.md`, `founder/cfo-sources.md`. Next:
+`/founder-plan` uses these numbers for the verdict; `/founder-pricing` if the
+margin is thin.
diff --git a/skills/founder-cfo/example.json b/skills/founder-cfo/example.json
new file mode 100644
index 0000000..456e7f2
--- /dev/null
+++ b/skills/founder-cfo/example.json
@@ -0,0 +1,27 @@
+{
+ "business": "Moss Matcha Bar (an example: a walk-in matcha café)",
+ "unit": "cup",
+ "price": 6.50,
+ "variable": [
+ {"label": "Matcha (ceremonial, 2g)", "cost": 0.92},
+ {"label": "Oat milk", "cost": 0.38},
+ {"label": "Cup, lid, straw", "cost": 0.24},
+ {"label": "Card fees", "cost": 0.20}
+ ],
+ "fixed_monthly": [
+ {"label": "Labour", "cost": 15500},
+ {"label": "Rent + utilities", "cost": 11040}
+ ],
+ "startup": [
+ {"label": "Lease deposit", "cost": 8400},
+ {"label": "Build-out", "cost": 6900},
+ {"label": "Equipment", "cost": 4250},
+ {"label": "Signage", "cost": 1850},
+ {"label": "Opening inventory", "cost": 2380},
+ {"label": "Launch ads", "cost": 1500}
+ ],
+ "days_per_month": 30,
+ "capacity_per_day": 600,
+ "plan_per_day": 383,
+ "ramp_per_day": [140, 170, 195, 215, 235, 250, 262, 272, 280, 287, 290, 292]
+}
diff --git a/skills/founder-cfo/unit_economics.py b/skills/founder-cfo/unit_economics.py
new file mode 100644
index 0000000..2221d37
--- /dev/null
+++ b/skills/founder-cfo/unit_economics.py
@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+"""Unit economics for founder-cfo. Standard library only, no network.
+
+Takes one JSON file describing the business and prints the numbers a CFO would
+check before a single dollar is spent: what one unit earns, the real margin at
+the volume you plan, how many units a day you need to break even, what year 1
+looks like month by month, and how long it takes to earn the startup money back.
+
+ python3 unit_economics.py founder/numbers.json
+ python3 unit_economics.py founder/numbers.json --out founder/cfo.md
+ python3 unit_economics.py founder/numbers.json --json
+ python3 unit_economics.py founder/numbers.json --price 7.00 --volume 0.8
+
+The input (see example.json in this folder):
+
+ business name, for the report
+ unit what you sell one of: "cup", "order", "client-month"
+ price price per unit, before tax
+ variable [{label, cost}] cost of ONE unit: ingredients, packaging,
+ shipping, card fees, a per-unit commission
+ fixed_monthly [{label, cost}] costs you pay every month whatever you sell:
+ rent, salaries, software, insurance
+ startup [{label, cost}] one-off spend before you open
+ days_per_month selling days in a month (default 30)
+ capacity_per_day the most units a day you can physically sell (optional)
+ plan_per_day the volume you plan for once you are up and running
+ ramp_per_day 12 numbers: units a day in each month of year 1
+ (optional; default = plan_per_day every month)
+
+Every number in the report comes from that file. Nothing is looked up or
+guessed. If a field is missing the tool says so instead of filling it in.
+
+--price and --volume run a what-if without editing the file: --price replaces
+the price, --volume scales every volume (0.8 = 20 percent fewer sales).
+"""
+
+import argparse
+import json
+import math
+import sys
+
+
+class NumbersError(Exception):
+ pass
+
+
+def _money(v):
+ sign = "-" if v < 0 else ""
+ return "%s$%s" % (sign, "{:,.2f}".format(abs(v)))
+
+
+def _whole(v):
+ sign = "-" if v < 0 else ""
+ return "%s$%s" % (sign, "{:,.0f}".format(abs(round(v))))
+
+
+def _sum(items, field):
+ total = 0.0
+ for i, it in enumerate(items or []):
+ if not isinstance(it, dict) or "cost" not in it:
+ raise NumbersError("%s[%d] needs a 'cost'" % (field, i))
+ try:
+ total += float(it["cost"])
+ except (TypeError, ValueError):
+ raise NumbersError("%s[%d].cost is not a number: %r" % (field, i, it["cost"]))
+ return total
+
+
+def load(path):
+ try:
+ with open(path, encoding="utf-8") as fh:
+ return json.load(fh)
+ except FileNotFoundError:
+ raise NumbersError("no such file: %s" % path)
+ except json.JSONDecodeError as e:
+ raise NumbersError("%s is not valid JSON: %s" % (path, e))
+
+
+def analyse(spec, price=None, volume=1.0):
+ """Return a dict of every number in the report. Pure function, easy to test."""
+ if "price" not in spec and price is None:
+ raise NumbersError("'price' is missing")
+ p = float(price if price is not None else spec["price"])
+ if p <= 0:
+ raise NumbersError("price must be above zero")
+ days = float(spec.get("days_per_month", 30))
+ var = _sum(spec.get("variable"), "variable")
+ fixed = _sum(spec.get("fixed_monthly"), "fixed_monthly")
+ startup = _sum(spec.get("startup"), "startup")
+
+ if "plan_per_day" not in spec and "ramp_per_day" not in spec:
+ raise NumbersError("give 'plan_per_day' or 'ramp_per_day' (12 numbers)")
+ plan = float(spec.get("plan_per_day", 0)) * volume
+ ramp = spec.get("ramp_per_day")
+ if ramp is None:
+ ramp = [plan] * 12
+ else:
+ if len(ramp) != 12:
+ raise NumbersError("'ramp_per_day' needs 12 numbers, one per month (got %d)" % len(ramp))
+ ramp = [float(v) * volume for v in ramp]
+ if not plan:
+ plan = ramp[-1]
+
+ contribution = p - var
+ contribution_pct = contribution / p
+ breakeven_day = math.inf if contribution <= 0 else fixed / (contribution * days)
+ plan_units_month = plan * days
+ margin_at_plan = (contribution - (fixed / plan_units_month if plan_units_month else math.inf)) / p
+
+ months = []
+ cumulative = -startup
+ payback_month = None
+ for m, per_day in enumerate(ramp, start=1):
+ units = per_day * days
+ revenue = units * p
+ variable_cost = units * var
+ profit = revenue - variable_cost - fixed
+ cumulative += profit
+ if payback_month is None and cumulative >= 0:
+ payback_month = m
+ months.append({"month": m, "per_day": per_day, "units": units, "revenue": revenue,
+ "variable": variable_cost, "fixed": fixed, "profit": profit,
+ "cumulative": cumulative})
+ year_profit = sum(m["profit"] for m in months)
+ year_revenue = sum(m["revenue"] for m in months)
+ # the cash you need: startup plus the deepest hole the monthly losses dig
+ lowest = min([-startup] + [m["cumulative"] for m in months])
+ cash_needed = -lowest
+
+ capacity = spec.get("capacity_per_day")
+ flags = []
+ if contribution <= 0:
+ flags.append("Each unit loses money before rent and salaries: the price is below the variable cost.")
+ if capacity is not None and breakeven_day > float(capacity):
+ flags.append("Break-even needs %.0f %ss a day but capacity is %s." % (breakeven_day, spec.get("unit", "unit"), capacity))
+ if capacity is not None and plan > float(capacity):
+ flags.append("The plan (%.0f a day) is above capacity (%s)." % (plan, capacity))
+ if year_profit < 0:
+ flags.append("Year 1 loses money on operations (%s)." % _whole(year_profit))
+ if payback_month is None:
+ flags.append("The startup spend is not earned back within year 1.")
+
+ return {
+ "business": spec.get("business", ""), "unit": spec.get("unit", "unit"),
+ "price": p, "variable_per_unit": var, "contribution": contribution,
+ "contribution_pct": contribution_pct, "fixed_monthly": fixed, "startup": startup,
+ "plan_per_day": plan, "margin_at_plan": margin_at_plan, "breakeven_per_day": breakeven_day,
+ "capacity_per_day": capacity, "year1_revenue": year_revenue, "year1_profit": year_profit,
+ "year1_after_startup": year_profit - startup, "payback_month": payback_month,
+ "cash_needed": cash_needed, "months": months, "flags": flags,
+ "variable_items": spec.get("variable", []), "fixed_items": spec.get("fixed_monthly", []),
+ "startup_items": spec.get("startup", []),
+ }
+
+
+def sensitivity(spec):
+ """The three what-ifs every plan should survive."""
+ base = analyse(spec)
+ rows = [("Base plan", base)]
+ rows.append(("Price -10%", analyse(spec, price=base["price"] * 0.9)))
+ rows.append(("Volume -20%", analyse(spec, volume=0.8)))
+ worse = json.loads(json.dumps(spec))
+ for it in worse.get("variable", []):
+ it["cost"] = float(it["cost"]) * 1.15
+ rows.append(("Unit costs +15%", analyse(worse)))
+ return rows
+
+
+def report(spec, a):
+ u = a["unit"]
+ L = []
+ L.append("# Unit economics: %s" % (a["business"] or "your business"))
+ L.append("")
+ L.append("Every number below comes from the input file. Nothing is looked up or guessed.")
+ L.append("")
+ L.append("## One %s" % u)
+ L.append("")
+ L.append("| line | per %s |" % u)
+ L.append("| --- | ---: |")
+ L.append("| Price | %s |" % _money(a["price"]))
+ for it in a["variable_items"]:
+ L.append("| %s | -%s |" % (it.get("label", "cost"), _money(float(it["cost"]))))
+ L.append("| **Contribution** (what each %s leaves to pay the fixed costs) | **%s** (%.0f%%) |"
+ % (u, _money(a["contribution"]), a["contribution_pct"] * 100))
+ L.append("")
+ L.append("## The margin that matters")
+ L.append("")
+ L.append("Fixed costs: %s a month (%s)." % (_whole(a["fixed_monthly"]), ", ".join(
+ "%s %s" % (it.get("label", "cost"), _whole(float(it["cost"]))) for it in a["fixed_items"]) or "none given"))
+ L.append("")
+ be = a["breakeven_per_day"]
+ L.append("- **Break-even: %s %ss a day.** Below that you lose money every month." % (
+ "never (each unit loses money)" if math.isinf(be) else "{:,.0f}".format(math.ceil(be)), u))
+ L.append("- **Profit margin at your plan** (%s a day): **%.0f%%** of every sale, after every cost." % (
+ "{:,.0f}".format(a["plan_per_day"]), a["margin_at_plan"] * 100))
+ if a["capacity_per_day"] is not None:
+ L.append("- Capacity: %s a day." % a["capacity_per_day"])
+ L.append("")
+ L.append("## Year 1, month by month")
+ L.append("")
+ L.append("| month | %ss a day | revenue | profit | cumulative (after %s startup) |" % (u, _whole(a["startup"])))
+ L.append("| ---: | ---: | ---: | ---: | ---: |")
+ for m in a["months"]:
+ L.append("| %d | %s | %s | %s | %s |" % (m["month"], "{:,.0f}".format(m["per_day"]), _whole(m["revenue"]),
+ _whole(m["profit"]), _whole(m["cumulative"])))
+ L.append("")
+ L.append("- **Year 1 operating profit: %s** on %s of revenue." % (_whole(a["year1_profit"]), _whole(a["year1_revenue"])))
+ L.append("- After the %s startup spend: %s." % (_whole(a["startup"]), _whole(a["year1_after_startup"])))
+ L.append("- Startup money earned back: %s." % ("month %d" % a["payback_month"] if a["payback_month"] else "not within year 1"))
+ L.append("- Cash you need before it pays for itself: **%s**." % _whole(a["cash_needed"]))
+ L.append("")
+ L.append("## What if")
+ L.append("")
+ L.append("| scenario | margin at plan | break-even a day | year 1 profit |")
+ L.append("| --- | ---: | ---: | ---: |")
+ for name, s in sensitivity(spec):
+ be = s["breakeven_per_day"]
+ L.append("| %s | %.0f%% | %s | %s |" % (name, s["margin_at_plan"] * 100,
+ "never" if math.isinf(be) else "{:,.0f}".format(math.ceil(be)),
+ _whole(s["year1_profit"])))
+ L.append("")
+ if a["flags"]:
+ L.append("## Red flags")
+ L.append("")
+ for f in a["flags"]:
+ L.append("- %s" % f)
+ else:
+ L.append("No red flags in these numbers. They are only as good as the inputs: check every cost against a real quote.")
+ return "\n".join(L) + "\n"
+
+
+def main(argv=None):
+ ap = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+ ap.add_argument("numbers", help="the business's numbers.json")
+ ap.add_argument("--out", help="write the report here (markdown)")
+ ap.add_argument("--json", action="store_true", help="print the numbers as JSON")
+ ap.add_argument("--price", type=float, help="what-if price")
+ ap.add_argument("--volume", type=float, default=1.0, help="what-if volume multiplier")
+ args = ap.parse_args(argv)
+ try:
+ spec = load(args.numbers)
+ if args.price is not None:
+ spec = dict(spec, price=args.price)
+ if args.volume != 1.0:
+ spec = dict(spec)
+ if "plan_per_day" in spec:
+ spec["plan_per_day"] = float(spec["plan_per_day"]) * args.volume
+ if "ramp_per_day" in spec:
+ spec["ramp_per_day"] = [float(v) * args.volume for v in spec["ramp_per_day"]]
+ a = analyse(spec)
+ except NumbersError as e:
+ print("error: %s" % e, file=sys.stderr)
+ return 2
+ if args.json:
+ out = {k: v for k, v in a.items() if not k.endswith("_items")}
+ out["breakeven_per_day"] = None if math.isinf(out["breakeven_per_day"]) else out["breakeven_per_day"]
+ print(json.dumps(out, indent=1))
+ return 0
+ text = report(spec, a)
+ if args.out:
+ with open(args.out, "w", encoding="utf-8") as fh:
+ fh.write(text)
+ print("wrote %s" % args.out)
+ else:
+ sys.stdout.write(text)
+ return 0
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/skills/founder-competitors/SKILL.md b/skills/founder-competitors/SKILL.md
new file mode 100644
index 0000000..8bb02d0
--- /dev/null
+++ b/skills/founder-competitors/SKILL.md
@@ -0,0 +1,77 @@
+---
+name: founder-competitors
+description: >-
+ Maps every competitor and the gap they leave. Finds the direct competitors,
+ indirect ones and the substitutes a buyer would use instead, from public
+ sources only, and records what each sells, at what price, how they position
+ themselves and what their customers complain about in public reviews, every fact
+ with a link. Ends with a positioning map and the gap the new business can own.
+ Use when the user says "who are my competitors", "is this market crowded", "what
+ else is out there", "competitor analysis", "find the gap", or "who am I up
+ against".
+argument-hint: "[city or market]"
+---
+
+# founder-competitors
+
+Every buyer already solves this problem somehow. This skill finds out how, what
+they pay, and what they hate about it, so the new business starts with a gap
+instead of a guess.
+
+## The rules
+
+- **Public sources only, every fact linked.** Websites, price pages, menus, app
+ store and Google Maps listings, review sites, Reddit, news. If a source cannot be
+ reached, say so. Never invent a competitor, a price, a rating or a review.
+- **Read, do not scrape.** Read pages as a person would. Respect each site's terms.
+- **Quotes are verbatim**, short, with the link. They are research, never
+ testimonials.
+
+## Step 1: who is there
+
+From `founder/idea.md` (write it first if missing; see `/founder-board` step 0):
+
+| type | what it means | example for a matcha café |
+| --- | --- | --- |
+| Direct | sells the same thing to the same buyer | other matcha bars within walking distance |
+| Indirect | a different product for the same job | the coffee shops on the same street |
+| Substitute | how buyers solve it without a business | matcha powder at home, canned drinks |
+
+Aim for 5 to 10 direct and indirect, plus the main substitutes. For a local
+business, search the map for the exact area; for online, search how a buyer would
+("best <thing> for <who>", "<thing> alternative").
+
+## Step 2: the facts
+
+One row per competitor in `founder/competitors.csv`:
+
+`name,type,url,location_or_channel,price_of_comparable_item,what_it_sells,positioning_line,rating,review_count,source_date`
+
+`positioning_line` is their own headline or tagline, copied. Price is for the item
+closest to what the new business sells, with what it includes.
+
+## Step 3: what their customers say
+
+For the top 3 to 5, read their reviews (1 to 3 stars first, then the "love it,
+but..." 4 stars). Note recurring complaints as themes with counts and one or two
+linked quotes each. Mark a theme thin if it has under three reviews.
+
+## Step 4: the map and the gap
+
+Write `founder/competitors.md`:
+
+1. The table (from the CSV), sorted by how directly each competes.
+2. Price range: lowest, median, highest for the comparable item.
+3. A positioning map in text: two axes that matter to this buyer (price and
+ convenience, quality and speed...), where each competitor sits.
+4. The complaints, ranked, with links.
+5. **The gap**: what nobody does well that this business could, tied to the
+ evidence. If there is no gap, say so plainly; that is the most useful result
+ this skill can give.
+6. The threat: who could copy the new business fastest, and how.
+
+## Output
+
+`founder/competitors.csv`, `founder/competitors.md`. Next: `/founder-consumer`
+uses the complaints to write real objections; `/founder-pricing` uses the price
+range.
diff --git a/skills/founder-consumer/SKILL.md b/skills/founder-consumer/SKILL.md
new file mode 100644
index 0000000..790de6c
--- /dev/null
+++ b/skills/founder-consumer/SKILL.md
@@ -0,0 +1,126 @@
+---
+name: founder-consumer
+description: >-
+ The consumer panel. Spins up a swarm of buyer sub-agents (default 100, --quick
+ for 20) trained on the user's target customer, each with a different income,
+ age, buying behaviour and objection, shows every one the same pitch, and runs
+ the business through 100 buyer scenarios to see who buys, who doesn't, and why.
+ Tallies the answers into buy rates by segment, the reasons people pass in their
+ own words, what would flip a no, and price answers for founder-pricing. Use when
+ the user says "would people buy this", "test it on customers", "run the
+ consumer panel", "simulate buyers", "who is my customer", or "validate demand".
+argument-hint: "[--n 100 | --quick] [--seed S]"
+---
+
+# founder-consumer
+
+The craziest part of the pack. Instead of guessing whether people will buy, you
+ask a hundred of them, each one a sub-agent playing a specific buyer drawn from
+your target customer. You are the moderator. You never answer for a buyer.
+
+What the user typed after `/founder-consumer`: `$ARGUMENTS`
+
+## The tool
+
+All bookkeeping goes through `panel.py` in this skill's folder:
+
+```bash
+python3 "${CLAUDE_SKILL_DIR}/panel.py" <command>
+```
+
+Below, `PANEL` means exactly that. If the path is not expanded, use the base
+directory Claude Code printed for this skill. State lives in `founder/panel/`.
+
+## Step 1: the target customer
+
+Write `founder/customer.json` (shape: `customer.example.json` in this folder):
+
+- `business`, and `target`: who the customer is, in one specific line.
+- `segments`: 2 to 4 groups with a `share` and an `income` range [low, high].
+- `behaviours`: 4 to 8 buying behaviours with a `share` and a `how` line
+ (daily regular, deal hunter, reads every review, loyal to a competitor...).
+- `objections`: the 4 to 8 doubts this kind of buyer really has.
+- `habits` (optional): everyday context lines that make a buyer concrete.
+
+Ground it in something real. Use what the user knows about their customers, and
+if `/founder-competitors` ran, the complaints in `founder/competitors.md`. If the
+user has real customer data (interviews, reviews, survey answers), prefer it to
+your guesses and say which parts are guesses. Show the user the profile in a few
+lines and let them correct it before you deal: a wrong customer makes the whole
+panel wrong.
+
+## Step 2: the pitch
+
+Write `founder/pitch.md`: what a buyer would actually see. The product, the price,
+where and how to get it, any opening offer. Three to six plain lines, no
+superlatives, nothing the business cannot deliver. Every buyer sees exactly this.
+
+## Step 3: deal and run
+
+```bash
+PANEL init --customer founder/customer.json --pitch founder/pitch.md --n 100
+PANEL prompts
+```
+
+`init` deals the persona cards (same seed, same cards; the seed is recorded).
+`prompts` writes one brief per buyer and lists them in waves of 10. For each wave,
+send ONE message with one Agent tool call per buyer in that wave (the Agent tool
+is called Task in older Claude Code versions):
+
+- `subagent_type`: `general-purpose`
+- `description`: `panel <id>`
+- `prompt`: `Read <brief path> and follow it exactly. It is your whole brief.`
+
+Wait for the whole wave before the next one. Claude Code runs about 10 tool calls
+at once by default, so 100 buyers is 10 waves. After the last wave:
+
+```bash
+PANEL check # lists missing or broken answers
+PANEL prompts # rewrites briefs for those only; run them once more
+PANEL tally
+```
+
+If a buyer printed its JSON in its reply instead of writing the file (it happens),
+file its own reply with `PANEL save <id>` and the reply on stdin; `save` refuses
+anything that is not a valid answer. A buyer that fails twice is left out and
+counted in the results. Never write an answer for a buyer yourself.
+
+Before a 100-buyer run, tell the user it is 100 sub-agent calls and suggest
+`--quick` (20 buyers) for a first look. Sub-agents write one file each into
+`founder/panel/answers/`; in the default permission mode that is one approval per
+file, so suggest accept-edits mode (Shift+Tab) for the run.
+
+## Step 4: read it to the user
+
+`PANEL tally` writes `founder/panel/results.md` and `results.json`. Give the user:
+
+1. The headline: "40 buy · 60 pass" and the buy rate.
+2. Who buys and who doesn't: the segment and behaviour rows that differ most.
+3. Why they pass: the top three reasons with one quote each, as written.
+4. What would flip a no: the most repeated answers.
+5. One sentence on what to change before spending money, and which skill does it
+ (pricing, offer, marketing).
+
+## Honest limits, say them once
+
+These are simulated buyers. They are good at surfacing objections, segments and
+wording you had not thought of, and bad at predicting real conversion: language
+models lean agreeable, so treat the buy rate as an upper bound. Confirm the big
+calls with real people (a waitlist, a pre-sale, a landing page with a price)
+before signing anything. Do not present panel quotes as customer testimonials.
+
+## The brief every buyer gets
+
+`panel.py` fills the card into a fixed template (see `BRIEF` in the script): who
+the buyer is (name, age, segment, income, buying behaviour, a habit, the doubt
+that comes to mind), the pitch word for word, an instruction not to be agreeable
+and not to invent facts, and the exact JSON to write: buys, purchases in the first
+month, a reason code, the reason in their own voice, their main objection, what
+would change their mind, and four price answers (too cheap, a bargain, getting
+expensive, too expensive). Never edit a brief for one buyer.
+
+## Output
+
+`founder/customer.json`, `founder/pitch.md`, `founder/panel/` (cards, briefs,
+answers, results). Next: `/founder-pricing` reads the price answers,
+`/founder-offer` and `/founder-marketing` read the objections.
diff --git a/skills/founder-consumer/customer.example.json b/skills/founder-consumer/customer.example.json
new file mode 100644
index 0000000..beaaad3
--- /dev/null
+++ b/skills/founder-consumer/customer.example.json
@@ -0,0 +1,34 @@
+{
+ "business": "Moss Matcha Bar (an example: a walk-in matcha café)",
+ "target": "Urban professionals, 24 to 38, who buy coffee 4+ times a week",
+ "where": "Toronto, around King St W",
+ "age": [24, 38],
+ "segments": [
+ {"name": "Early-career professional", "share": 0.45, "income": [38000, 85000]},
+ {"name": "Mid-career professional", "share": 0.40, "income": [85000, 150000]},
+ {"name": "High earner", "share": 0.15, "income": [150000, 210000]}
+ ],
+ "behaviours": [
+ {"name": "Daily regular", "share": 0.20, "how": "Buys the same drink at the same place most mornings."},
+ {"name": "Health-first", "share": 0.18, "how": "Reads labels, swaps coffee for anything that feels cleaner."},
+ {"name": "Trend chaser", "share": 0.15, "how": "Tries whatever is new and posts about it."},
+ {"name": "Weekend treat", "share": 0.15, "how": "Cheap coffee on weekdays, something nicer on Saturday."},
+ {"name": "Deal hunter", "share": 0.12, "how": "Waits for an offer, uses loyalty apps."},
+ {"name": "Loyal to their café", "share": 0.10, "how": "Has a favourite spot and the staff know their order."},
+ {"name": "Reads every review", "share": 0.10, "how": "Checks Google ratings before trying anywhere new."}
+ ],
+ "objections": [
+ "$6.50 is steep for a drink",
+ "My coffee place is closer",
+ "Does matcha actually taste good?",
+ "Is it really healthier than coffee?",
+ "I need somewhere to sit and work",
+ "I'd try it once, not daily"
+ ],
+ "habits": [
+ "you walk past King St W on the way to the office",
+ "you work from home three days a week",
+ "you meet friends for coffee on Saturdays",
+ "you go to a gym near Spadina before work"
+ ]
+}
diff --git a/skills/founder-consumer/panel.py b/skills/founder-consumer/panel.py
new file mode 100644
index 0000000..b59d0a7
--- /dev/null
+++ b/skills/founder-consumer/panel.py
@@ -0,0 +1,424 @@
+#!/usr/bin/env python3
+"""The buyer panel for founder-consumer. Standard library only, no network.
+
+It does the bookkeeping for a swarm of simulated buyers: it deals one persona card
+per buyer from your target-customer profile (income, age, behaviour, objection),
+writes one brief per buyer for a sub-agent to answer, checks the answers, and
+tallies who buys, who doesn't, and why.
+
+ python3 panel.py init --customer founder/customer.json --pitch founder/pitch.md [--n 100] [--seed 7]
+ python3 panel.py prompts [--wave 10] # one brief per buyer still to run, listed in waves
+ python3 panel.py check # which answers are missing or broken
+ python3 panel.py save P003 < reply.txt # file a buyer's own JSON that it printed instead of writing
+ python3 panel.py tally [--out founder/panel/results.md]
+ python3 panel.py status
+
+State lives in founder/panel/ (--dir to change it): panel.json, personas.json,
+briefs/<id>.md, answers/<id>.json, results.md, results.json.
+
+The tool never answers for a buyer. Every number in results.md is counted from
+the answer files the sub-agents wrote. Simulated buyers are a fast, cheap way to
+find objections and weak spots. They are not customers: confirm what matters
+with real ones (a pre-sale, a waitlist, a landing page with a price on it).
+"""
+
+import argparse
+import json
+import os
+import random
+import sys
+
+FIRST_NAMES = [
+ "Maya", "Jordan", "Priya", "Marcus", "Sofia", "Ethan", "Aisha", "Liam", "Chloe", "Daniel", "Nadia", "Owen",
+ "Grace", "Ravi", "Emma", "Kenji", "Zoe", "Luca", "Hana", "Noah", "Fatima", "Caleb", "Isla", "Mateo", "Leah",
+ "Omar", "Ava", "Theo", "Mei", "Jonah", "Sara", "Diego", "Ruby", "Kofi", "Nora", "Felix", "Amara", "Ben", "Lina",
+ "Sam", "Aria", "Julian", "Keisha", "Marco", "Ines", "Tariq", "Elena", "Hugo", "Yara", "Callum", "Rosa", "Idris",
+ "Freya", "Andre", "Leila", "Mason", "Talia", "Rohan", "Esme", "Victor", "Anya", "Kai", "Beatriz", "Declan",
+ "Sana", "Jasper", "Min", "Gabriel", "Olivia", "Arjun", "Clara", "Malik", "Iris", "Wes", "Noor", "Rafael", "Ivy",
+ "Dev", "Maeve", "Tomas", "Celine", "Adrian", "Lucia", "Hamza", "Poppy", "Ezra", "Sienna", "Darius", "Quinn",
+ "Selin", "Rhys", "Nia", "Oscar", "Tess", "Bilal", "Jade", "Luis", "Harper", "Emil", "Kira", "Pablo", "Alma",
+ "Seth", "Zara", "Nico", "Farah", "Levi", "June", "Eli", "Ana", "Yusuf", "Lena", "Cole", "Mira", "Raj", "Elle",
+ "Finn", "Dana", "Sol", "Ada",
+]
+REASONS = ["price", "habit", "need", "trust", "quality", "convenience", "timing", "values", "other"]
+ANSWER_FIELDS = {"id", "buys", "reason_code", "reason"}
+WAVE = 10
+
+
+class PanelError(Exception):
+ pass
+
+
+# ── dealing ─────────────────────────────────────────────────────────────────────
+def _quota(items, n, key="share"):
+ """Split n across items by their shares, exactly (largest remainder)."""
+ total = sum(float(it.get(key, 1)) for it in items) or 1.0
+ raw = [n * float(it.get(key, 1)) / total for it in items]
+ counts = [int(r) for r in raw]
+ order = sorted(range(len(items)), key=lambda i: raw[i] - counts[i], reverse=True)
+ for i in order[: n - sum(counts)]:
+ counts[i] += 1
+ return counts
+
+
+def validate_customer(c):
+ for k in ("business", "target", "segments", "behaviours", "objections"):
+ if k not in c or c[k] in ("", [], None):
+ raise PanelError("customer.json needs '%s'" % k)
+ for s in c["segments"]:
+ if "name" not in s or "income" not in s or len(s["income"]) != 2:
+ raise PanelError("every segment needs a name and an income [low, high]")
+ for b in c["behaviours"]:
+ if "name" not in b:
+ raise PanelError("every behaviour needs a name")
+
+
+def deal(customer, n=100, seed=7):
+ """Deal n persona cards. Same customer + n + seed = the same cards, every time."""
+ validate_customer(customer)
+ if n < 1:
+ raise PanelError("--n must be at least 1")
+ rng = random.Random(seed)
+ age = customer.get("age", [25, 45])
+ segs = []
+ for s, k in zip(customer["segments"], _quota(customer["segments"], n)):
+ segs += [s] * k
+ behs = []
+ for b, k in zip(customer["behaviours"], _quota(customer["behaviours"], n)):
+ behs += [b] * k
+ rng.shuffle(segs)
+ rng.shuffle(behs)
+ names = FIRST_NAMES[:]
+ rng.shuffle(names)
+ while len(names) < n:
+ names += ["%s %d" % (x, len(names) // len(FIRST_NAMES) + 1) for x in FIRST_NAMES]
+ objections = customer["objections"]
+ habits = customer.get("habits") or []
+ cards = []
+ for i in range(n):
+ s, b = segs[i], behs[i]
+ lo, hi = float(s["income"][0]), float(s["income"][1])
+ cards.append({
+ "id": "P%03d" % (i + 1),
+ "name": names[i],
+ "age": rng.randint(int(age[0]), int(age[1])),
+ "segment": s["name"],
+ "income": int(round(rng.uniform(lo, hi), -3)),
+ "behaviour": b["name"],
+ "behaviour_how": b.get("how", ""),
+ "objection": objections[rng.randrange(len(objections))],
+ "habit": habits[rng.randrange(len(habits))] if habits else "",
+ })
+ return cards
+
+
+# ── state ───────────────────────────────────────────────────────────────────────
+def _path(d, *p):
+ return os.path.join(d, *p)
+
+
+def _read_json(path):
+ with open(path, encoding="utf-8") as fh:
+ return json.load(fh)
+
+
+def _write_json(path, obj):
+ os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
+ with open(path, "w", encoding="utf-8") as fh:
+ json.dump(obj, fh, indent=1, ensure_ascii=False)
+ fh.write("\n")
+
+
+def init(d, customer_path, pitch_path, n=100, seed=None):
+ try:
+ customer = _read_json(customer_path)
+ except FileNotFoundError:
+ raise PanelError("no such file: %s" % customer_path)
+ try:
+ with open(pitch_path, encoding="utf-8") as fh:
+ pitch = fh.read().strip()
+ except FileNotFoundError:
+ raise PanelError("no such file: %s (write the pitch first: what you sell, the price, where)" % pitch_path)
+ if not pitch:
+ raise PanelError("the pitch is empty")
+ if seed is None:
+ seed = random.SystemRandom().randrange(1, 10 ** 6)
+ cards = deal(customer, n, seed)
+ _write_json(_path(d, "panel.json"), {"n": n, "seed": seed, "customer": customer, "pitch": pitch})
+ _write_json(_path(d, "personas.json"), cards)
+ os.makedirs(_path(d, "briefs"), exist_ok=True)
+ os.makedirs(_path(d, "answers"), exist_ok=True)
+ return cards
+
+
+def load_state(d):
+ try:
+ return _read_json(_path(d, "panel.json")), _read_json(_path(d, "personas.json"))
+ except FileNotFoundError:
+ raise PanelError("no panel in %s: run init first" % d)
+
+
+BRIEF = """You are a simulated buyer on a consumer panel. A founder wants to know, before spending any money, whether real people like you would buy. Your answer is only useful if it is honest: most people do not buy most things, and a polite yes is worse than a clear no.
+
+=== WHO YOU ARE ===
+{name}, {age}. {segment}. You earn about ${income:,} a year.
+How you buy: {behaviour}. {behaviour_how}
+{habit_line}The first thing that comes to mind when you hear an offer like this: "{objection}"
+You are one of these people: {target}.
+=== END ===
+
+=== WHAT IS BEING OFFERED (you see it for the first time, the way a passer-by or a scroller would) ===
+{pitch}
+=== END ===
+
+Decide as {name} would, with {name}'s money, habits and doubts, in a normal week. Do not be agreeable. Do not invent facts about the business beyond what is written above.
+
+Create the file {out} with your file-writing tool (do not just print the answer in your reply) containing ONLY this JSON, no markdown fence, nothing else:
+{{
+ "id": "{id}",
+ "buys": true or false,
+ "purchases_first_month": how many times you would buy in the first month (0 if you would not buy),
+ "reason_code": one of {reasons},
+ "reason": "why, in one or two sentences, in your own voice",
+ "objection": "the doubt that weighs most for you, in your own words",
+ "would_change_my_mind": "the one thing that would flip your answer, or empty",
+ "price_too_cheap": the price at which it would seem too cheap to be any good (a number),
+ "price_cheap": the price at which it would feel like a bargain (a number),
+ "price_expensive": the price at which it starts to feel expensive but you might still buy (a number),
+ "price_too_expensive": the price at which you would not buy it at all (a number)
+}}
+"""
+
+
+def write_briefs(d, wave=WAVE):
+ state, cards = load_state(d)
+ target = state["customer"]["target"]
+ todo = []
+ for c in cards:
+ out = _path(d, "answers", c["id"] + ".json")
+ if _answer_ok(out, c["id"]) is None:
+ continue
+ brief = BRIEF.format(pitch=state["pitch"], target=target, out=os.path.abspath(out),
+ habit_line=("Your day: %s.\n" % c["habit"]) if c.get("habit") else "",
+ reasons=" / ".join(REASONS), **c)
+ bp = _path(d, "briefs", c["id"] + ".md")
+ with open(bp, "w", encoding="utf-8") as fh:
+ fh.write(brief)
+ todo.append((c["id"], os.path.abspath(bp)))
+ waves = [todo[i:i + wave] for i in range(0, len(todo), wave)]
+ return waves
+
+
+def _answer_ok(path, pid):
+ """None if the answer file is good, else a short problem string."""
+ if not os.path.exists(path):
+ return "missing"
+ try:
+ a = _read_json(path)
+ except (json.JSONDecodeError, UnicodeDecodeError):
+ return "not valid JSON"
+ missing = ANSWER_FIELDS - set(a)
+ if missing:
+ return "missing " + ", ".join(sorted(missing))
+ if a.get("id") != pid:
+ return "id is %r, expected %s" % (a.get("id"), pid)
+ if not isinstance(a.get("buys"), bool):
+ return "'buys' must be true or false"
+ if a.get("reason_code") not in REASONS:
+ return "reason_code %r is not one of %s" % (a.get("reason_code"), ", ".join(REASONS))
+ return None
+
+
+def save(d, pid, text):
+ """File a buyer's OWN answer that it printed instead of writing. Never used to answer for a buyer."""
+ _, cards = load_state(d)
+ if pid not in {c["id"] for c in cards}:
+ raise PanelError("no buyer %s on this panel" % pid)
+ start = text.find("{")
+ if start < 0:
+ raise PanelError("no JSON object in the reply")
+ try:
+ obj, _ = json.JSONDecoder().raw_decode(text[start:])
+ except json.JSONDecodeError as e:
+ raise PanelError("the reply's JSON does not parse: %s" % e)
+ path = _path(d, "answers", pid + ".json")
+ _write_json(path, obj)
+ prob = _answer_ok(path, pid)
+ if prob:
+ os.remove(path)
+ raise PanelError("%s's answer is not valid (%s); re-run its brief instead" % (pid, prob))
+ return path
+
+
+def check(d):
+ _, cards = load_state(d)
+ probs = []
+ for c in cards:
+ p = _answer_ok(_path(d, "answers", c["id"] + ".json"), c["id"])
+ if p:
+ probs.append((c["id"], p))
+ return probs
+
+
+# ── tally ───────────────────────────────────────────────────────────────────────
+def _rate(rows):
+ return (sum(1 for r in rows if r["buys"]) / len(rows)) if rows else 0.0
+
+
+def _num(v):
+ try:
+ return float(v)
+ except (TypeError, ValueError):
+ return None
+
+
+def tally(d):
+ state, cards = load_state(d)
+ by_id = {c["id"]: c for c in cards}
+ rows, skipped = [], []
+ for c in cards:
+ path = _path(d, "answers", c["id"] + ".json")
+ p = _answer_ok(path, c["id"])
+ if p:
+ skipped.append((c["id"], p))
+ continue
+ a = _read_json(path)
+ rows.append(dict(by_id[c["id"]], **{k: v for k, v in a.items() if k != "id"}, id=c["id"]))
+ if not rows:
+ raise PanelError("no valid answers yet: run the briefs first (panel.py prompts)")
+
+ def group(key):
+ out = {}
+ for r in rows:
+ out.setdefault(r[key], []).append(r)
+ return sorted(((k, len(v), _rate(v)) for k, v in out.items()), key=lambda t: -t[2])
+
+ # income in thirds of the dealt range, so the bands mean the same thing every run
+ incomes = sorted(r["income"] for r in rows)
+ cut1, cut2 = incomes[len(incomes) // 3], incomes[2 * len(incomes) // 3]
+ for r in rows:
+ r["income_band"] = ("under $%s" % "{:,}".format(cut1)) if r["income"] < cut1 else (
+ ("$%s and up" % "{:,}".format(cut2)) if r["income"] >= cut2 else "$%s to $%s" % ("{:,}".format(cut1), "{:,}".format(cut2)))
+
+ no = [r for r in rows if not r["buys"]]
+ yes = [r for r in rows if r["buys"]]
+
+ def reasons(rs):
+ out = {}
+ for r in rs:
+ out.setdefault(r["reason_code"], []).append(r)
+ return sorted(((k, v) for k, v in out.items()), key=lambda kv: -len(kv[1]))
+
+ def mean(vals):
+ vals = [v for v in vals if v is not None]
+ return sum(vals) / len(vals) if vals else None
+
+ res = {
+ "business": state["customer"]["business"], "seed": state["seed"], "dealt": len(cards),
+ "answered": len(rows), "skipped": skipped, "buys": len(yes), "passes": len(no),
+ "buy_rate": len(yes) / len(rows),
+ "by_segment": group("segment"), "by_behaviour": group("behaviour"), "by_income": group("income_band"),
+ "why_not": [(k, len(v), [r["reason"] for r in v[:2]], [r["id"] for r in v[:2]]) for k, v in reasons(no)],
+ "why_yes": [(k, len(v), [r["reason"] for r in v[:2]], [r["id"] for r in v[:2]]) for k, v in reasons(yes)],
+ "flip": [r["would_change_my_mind"] for r in no if (r.get("would_change_my_mind") or "").strip()],
+ "purchases_first_month_per_buyer": mean([_num(r.get("purchases_first_month")) for r in yes]),
+ "price_answers": sum(1 for r in rows if all(_num(r.get(k)) is not None for k in
+ ("price_too_cheap", "price_cheap", "price_expensive", "price_too_expensive"))),
+ }
+ return res
+
+
+def results_md(res):
+ pct = lambda v: "%.0f%%" % (v * 100)
+ L = ["# Buyer panel: %s" % res["business"], ""]
+ L.append("**%d buy · %d pass** (%s buy) out of %d simulated buyers. Seed %s, so the same cards can be dealt again."
+ % (res["buys"], res["passes"], pct(res["buy_rate"]), res["answered"], res["seed"]))
+ if res["skipped"]:
+ L.append("")
+ L.append("%d of %d buyers have no valid answer and are left out: %s." % (
+ len(res["skipped"]), res["dealt"], ", ".join("%s (%s)" % s for s in res["skipped"][:10])))
+ L.append("")
+ L.append("These are simulated buyers, not customers. Use this to find objections and weak spots, then confirm the"
+ " big ones with real people before you spend.")
+ for title, key in (("By segment", "by_segment"), ("By buying behaviour", "by_behaviour"), ("By income", "by_income")):
+ L += ["", "## %s" % title, "", "| group | buyers | buy rate |", "| --- | ---: | ---: |"]
+ for k, n, r in res[key]:
+ L.append("| %s | %d | %s%s |" % (k, n, pct(r), " (thin)" if n < 8 else ""))
+ L += ["", "## Why they pass", "", "| reason | buyers | in their words |", "| --- | ---: | --- |"]
+ for k, n, quotes, ids in res["why_not"]:
+ L.append("| %s | %d | %s |" % (k, n, " · ".join('"%s" (%s)' % (q.replace("|", "/"), i) for q, i in zip(quotes, ids))))
+ L += ["", "## Why they buy", "", "| reason | buyers | in their words |", "| --- | ---: | --- |"]
+ for k, n, quotes, ids in res["why_yes"]:
+ L.append("| %s | %d | %s |" % (k, n, " · ".join('"%s" (%s)' % (q.replace("|", "/"), i) for q, i in zip(quotes, ids))))
+ if res["flip"]:
+ L += ["", "## What would flip a no", ""]
+ for f in res["flip"][:12]:
+ L.append("- %s" % f)
+ if res["purchases_first_month_per_buyer"] is not None:
+ L += ["", "Buyers say they would buy **%.1f times** in the first month on average." % res["purchases_first_month_per_buyer"]]
+ if res["price_answers"]:
+ L += ["", "%d buyers gave all four price answers. Run founder-pricing's van_westendorp.py on the answers folder." % res["price_answers"]]
+ return "\n".join(L) + "\n"
+
+
+def main(argv=None):
+ ap = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+ ap.add_argument("--dir", default=os.path.join("founder", "panel"))
+ sub = ap.add_subparsers(dest="cmd", required=True)
+ i = sub.add_parser("init")
+ i.add_argument("--customer", required=True)
+ i.add_argument("--pitch", required=True)
+ i.add_argument("--n", type=int, default=100)
+ i.add_argument("--seed", type=int)
+ p = sub.add_parser("prompts")
+ p.add_argument("--wave", type=int, default=WAVE)
+ sub.add_parser("check")
+ sv = sub.add_parser("save")
+ sv.add_argument("id")
+ t = sub.add_parser("tally")
+ t.add_argument("--out")
+ sub.add_parser("status")
+ a = ap.parse_args(argv)
+ try:
+ if a.cmd == "init":
+ cards = init(a.dir, a.customer, a.pitch, a.n, a.seed)
+ st, _ = load_state(a.dir)
+ print("dealt %d buyers (seed %s) into %s. Next: panel.py prompts" % (len(cards), st["seed"], a.dir))
+ elif a.cmd == "prompts":
+ waves = write_briefs(a.dir, a.wave)
+ n = sum(len(w) for w in waves)
+ if not n:
+ print("every buyer has a valid answer. Next: panel.py tally")
+ else:
+ print("%d briefs in %d waves of up to %d. Launch one wave at a time:" % (n, len(waves), a.wave))
+ for k, w in enumerate(waves, 1):
+ print("wave %d: %s" % (k, " ".join("%s=%s" % job for job in w)))
+ elif a.cmd == "check":
+ probs = check(a.dir)
+ if not probs:
+ print("all answers present and valid")
+ for pid, prob in probs:
+ print("%s: %s" % (pid, prob))
+ return 1 if probs else 0
+ elif a.cmd == "save":
+ print("saved %s" % save(a.dir, a.id, sys.stdin.read()))
+ elif a.cmd == "tally":
+ res = tally(a.dir)
+ text = results_md(res)
+ out = a.out or _path(a.dir, "results.md")
+ with open(out, "w", encoding="utf-8") as fh:
+ fh.write(text)
+ _write_json(_path(a.dir, "results.json"), res)
+ print("%d buy · %d pass (%.0f%%). Wrote %s" % (res["buys"], res["passes"], res["buy_rate"] * 100, out))
+ elif a.cmd == "status":
+ st, cards = load_state(a.dir)
+ probs = check(a.dir)
+ print("%d buyers dealt (seed %s), %d answered, %d to go" % (len(cards), st["seed"], len(cards) - len(probs), len(probs)))
+ except PanelError as e:
+ print("error: %s" % e, file=sys.stderr)
+ return 2
+ return 0
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/skills/founder-consumer/pitch.example.md b/skills/founder-consumer/pitch.example.md
new file mode 100644
index 0000000..eb91908
--- /dev/null
+++ b/skills/founder-consumer/pitch.example.md
@@ -0,0 +1,3 @@
+Moss Matcha Bar, a new matcha café opening on King St W in Toronto.
+Iced and hot matcha lattes made with ceremonial-grade matcha and oat milk, $6.50 a cup.
+Open 7am to 6pm. A counter and six stools, mostly takeaway. Opening week: $4.95.
diff --git a/skills/founder-launch/SKILL.md b/skills/founder-launch/SKILL.md
new file mode 100644
index 0000000..81342f8
--- /dev/null
+++ b/skills/founder-launch/SKILL.md
@@ -0,0 +1,65 @@
+---
+name: founder-launch
+description: >-
+ Your launch lead. Builds a dated, step-by-step launch plan: a cheap real-world
+ test first (a waitlist, a pre-sale or a pop-up with a real price, so real buyers
+ confirm what the simulated panel said), then the countdown to opening day with
+ owners and deadlines, the launch-day run sheet, and the first 30 days of what to
+ measure and what to change. Use when the user says "how do I launch", "launch
+ plan", "when can I open", "launch checklist", "go live", or "soft open".
+argument-hint: "[target launch date]"
+---
+
+# founder-launch
+
+Launching is a project with a date. This skill turns everything else in the pack
+into a dated plan, and starts with the cheapest way to find out if real people
+will pay before the big money goes out.
+
+## Step 1: test before you spend
+
+Pick the cheapest real test that fits the business, and run it before signing the
+big costs in `founder/numbers.json`:
+
+| business | the test |
+| --- | --- |
+| physical shop or café | a pop-up, a market stall or a pre-order list with a price and a date |
+| online product | a landing page with the price and a "pre-order" or "join the waitlist" button |
+| service or agency | three paid pilot clients at the planned price |
+| subscription | a founding-member offer, paid up front |
+
+Write the success line before running it (for example: 50 pre-orders in two weeks
+at $6.50), and compare the result with the panel's buy rate. If real buyers fall
+well short of the panel, trust the real buyers and go back to `/founder-offer` or
+`/founder-pricing`.
+
+## Step 2: the countdown
+
+From today to launch day, with real dates (ask for the target date; default to the
+earliest realistic one given lead times in `founder/ops.md`). Weekly blocks, each
+task with an owner and a deadline:
+
+- Legal and money: registration, bank account, permits from `founder/ops.md`.
+- Build: fit-out or website, suppliers ordered by their lead times.
+- Brand: sign, packaging, profiles from `founder/brand.md`.
+- Marketing: the calendar in `founder/marketing.md` from launch minus 14 days.
+- Team: hiring and training on the SOPs.
+- A soft open or friends-and-family day before the public launch.
+
+Mark the critical path: the tasks that move the launch date if they slip.
+
+## Step 3: launch day
+
+An hour-by-hour run sheet: who is where, what goes out on which channel, the
+opening offer, what to do if something breaks (from the risk register).
+
+## Step 4: the first 30 days
+
+The weekly numbers to track (from the CFO: units a day against break-even; from
+marketing: the channel numbers), the level that triggers a change, and a review on
+days 7, 14 and 30 with the questions to answer.
+
+## Output
+
+`founder/launch.md` with the test, the countdown, the run sheet and the 30-day
+review. Next: `/founder-plan` compiles everything into the business plan.
diff --git a/skills/founder-marketing/SKILL.md b/skills/founder-marketing/SKILL.md
new file mode 100644
index 0000000..c61a454
--- /dev/null
+++ b/skills/founder-marketing/SKILL.md
@@ -0,0 +1,80 @@
+---
+name: founder-marketing
+description: >-
+ Your marketing director. Turns the buyer panel and the competitor map into
+ positioning, the channels the target customer actually uses, a 30-day launch
+ campaign with dated posts and ads, the first ten hooks, a budget split and the
+ numbers to watch. Every message answers an objection real or simulated buyers
+ raised. Use when the user says "how do I market this", "marketing plan", "launch
+ campaign", "how do I get customers", "where do I advertise", "write my ads", or
+ "positioning".
+argument-hint: "[budget]"
+---
+
+# founder-marketing
+
+A business no one hears about does not exist. This skill plans how the first
+customers hear about it, using what the rest of the pack already learned instead
+of a generic playbook.
+
+## Step 1: read the evidence
+
+- `founder/panel/results.md`: who buys, who doesn't, and why. The segments with the
+ highest buy rate are the first audience. The top objections are what the
+ marketing must answer.
+- `founder/competitors.md`: how competitors position themselves (so you do not
+ sound like them) and the gap.
+- `founder/offer.md` and `founder/pricing.md`: what is being sold, at what price.
+- `founder/numbers.json`: what a customer is worth, which caps what you can spend to
+ win one.
+
+If none of these exist, say what is missing and offer to run `/founder-consumer
+--quick` first. Do not invent an audience.
+
+## Step 2: positioning
+
+One line, then the reasons:
+
+```
+For <the segment that buys most>, who <their problem in their words>,
+<business> is the <category> that <the gap>, unlike <the nearest alternative>.
+```
+
+Give three versions, recommend one, and say which panel evidence supports it.
+
+## Step 3: channels
+
+List where the first audience actually spends attention, specific to the business
+type and place: foot traffic and window signage, Google Maps, Instagram and TikTok,
+local creators, neighbourhood groups, partnerships with nearby businesses, email,
+paid search, paid social. For each: why it fits this buyer, rough cost, and how you
+will know it worked. Pick two or three to start; say what you are not doing and why.
+
+## Step 4: the 30-day campaign
+
+`founder/marketing.md` gets a dated calendar from launch minus 14 days to launch
+plus 16: what goes out each day, on which channel, with the message. Include:
+
+- **Ten hooks**, each answering one panel objection or using one buyer reason,
+ written for the format (a 3-second opening line for video, a headline for an ad,
+ a sign in the window).
+- The launch-week offer from `founder/pricing.md` and when it ends.
+- What to post when there is nothing new to say (behind the scenes, the making of).
+
+## Step 5: budget and numbers
+
+- The budget split across the chosen channels.
+- The most you can pay to win a customer: from the CFO's contribution per unit and
+ the panel's purchases per buyer, show the sum.
+- The three numbers to watch weekly and the level that means "change something".
+
+## Rules
+
+- No fake reviews, follower counts, testimonials, before/afters or "as seen on".
+- Panel quotes are research; never use them as customer quotes in ads.
+- Disclose paid partnerships. Follow the advertising rules for claims in the user's
+ market (health and earnings claims especially). Not legal advice.
+
+## Output
+
+`founder/marketing.md`. Next: `/founder-brand`, then `/founder-launch`.
diff --git a/skills/founder-offer/SKILL.md b/skills/founder-offer/SKILL.md
new file mode 100644
index 0000000..d5e12c9
--- /dev/null
+++ b/skills/founder-offer/SKILL.md
@@ -0,0 +1,75 @@
+---
+name: founder-offer
+description: >-
+ Builds an offer too good to refuse. Lists every problem the buyer hits on the way
+ to the result they want, turns each into a solution, trims to what is cheap to
+ deliver and valuable to the buyer, and stacks it with honest bonuses, a guarantee
+ the CFO can afford, real urgency and a clear name. Scores it on the value
+ equation (outcome, likelihood, time, effort) and re-tests it on a quick buyer
+ panel. Use when the user says "make my offer better", "why won't people buy",
+ "what should I include", "guarantee", "bonuses", "grand slam offer", or after the
+ panel shows people passing.
+argument-hint: "[what you sell]"
+---
+
+# founder-offer
+
+Most businesses sell a product. Good ones sell an offer: the product plus
+everything that makes buying it an easy yes. This skill builds that, using the
+Offers lens in `../founder-board/lenses.md` as the method (a summary of the
+framework in Alex Hormozi's *$100M Offers*; never present it as his words).
+
+## Step 1: read what is already known
+
+- `founder/idea.md` and `founder/pitch.md`: what is sold today.
+- `founder/panel/results.md`: why buyers pass, in their words. This is the raw
+ material: every top objection should be answered by something in the offer.
+- `founder/numbers.json`: what each extra costs, so the stack stays profitable.
+- `founder/board.md`: the board's conditions.
+
+## Step 2: the problem list
+
+Write every obstacle between the buyer and the result they want, in the buyer's
+words: before buying (doubt, price, effort to switch), during (waiting, learning,
+inconvenience), after (does it last, what if it fails). Aim for 15 to 30. Pull
+from the panel objections and the competitor complaints first.
+
+## Step 3: solutions, trimmed and stacked
+
+Turn each problem into a solution (a feature, a service, a guarantee, a format).
+Score each on value to the buyer (1 to 5) and cost to deliver (1 to 5, from the
+CFO's numbers). Keep high value, low cost. Stack what is left into:
+
+- **The core**: the thing itself, described by the outcome, not the ingredients.
+- **Bonuses**: two or three, each killing one specific objection.
+- **The guarantee**: what happens if it does not deliver. Model what it costs at a
+ realistic claim rate with the CFO's tool before promising it.
+- **Urgency and scarcity**: only if they are true (a launch week, a limited first
+ batch). Never fake a countdown or a "only 3 left".
+- **The name**: a clear, specific name for the offer, not the company.
+
+## Step 4: score it
+
+On the value equation, before and after, 1 to 10 each: dream outcome, perceived
+likelihood of getting it, time to the result, effort and sacrifice. Say which
+element of the stack moves which score.
+
+## Step 5: re-test it
+
+Write the new offer into `founder/pitch.md` (keep the old one as
+`founder/pitch-v1.md`) and run `/founder-consumer --quick` with the same seed.
+Report the buy rate before and after and which objections dropped. If nothing
+moved, say so: the problem may be the market or the price, not the offer.
+
+## Rules
+
+- Every promise must be deliverable and affordable; check costs with the CFO.
+- No fake reviews, testimonials, scarcity, discounts or "as seen on".
+- Follow the advertising and consumer-protection rules of the user's market for
+ guarantees and claims (health claims especially). Not legal advice.
+
+## Output
+
+`founder/offer.md` (problem list, the stack, costs, the value-equation scores, the
+re-test result) and the updated `founder/pitch.md`. Next: `/founder-cfo` to re-run
+the numbers with the stack, then `/founder-marketing`.
diff --git a/skills/founder-ops/SKILL.md b/skills/founder-ops/SKILL.md
new file mode 100644
index 0000000..649d56c
--- /dev/null
+++ b/skills/founder-ops/SKILL.md
@@ -0,0 +1,70 @@
+---
+name: founder-ops
+description: >-
+ Your operations manager. Works out how the business actually runs on day one:
+ suppliers and what they cost, who works when, the step-by-step routines for
+ opening, serving or shipping and closing, the tools to run it, the licences and
+ permits to check, and a risk register with what to do when each thing goes
+ wrong. Feeds real costs back to the CFO. Use when the user says "how do I run
+ this", "operations", "suppliers", "staffing", "SOPs", "what do I need to open",
+ "permits", or "day one".
+argument-hint: "[city or country]"
+---
+
+# founder-ops
+
+A plan that works on paper fails at 7am on a Monday. This skill makes sure the
+first day, week and month can actually be run, and that the CFO's numbers include
+what running it really costs.
+
+## Step 1: what the business has to do every day
+
+From `founder/idea.md`, `founder/offer.md` and `founder/numbers.json`, write the
+daily cycle as a list of steps from first thing to last (for a café: deliveries,
+prep, open, serve, clean, cash up, order; for an online store: orders in, pick,
+pack, ship, returns, support). Mark which steps a customer sees.
+
+## Step 2: suppliers
+
+For every input in the CFO's variable costs and every piece of equipment: two or
+three real suppliers the user can contact, their public prices or how to get a
+quote, minimum orders, lead times and payment terms. Link the sources. Where only
+a quote will tell, say so and add it to the open questions. If a real price
+differs from `founder/numbers.json`, update it and say the CFO should re-run.
+
+## Step 3: people
+
+Who does what, when: a weekly rota for the planned volume and for the slow first
+month. The roles, the hours, and the wage assumption (from the user, or a public
+source for the local minimum and typical pay, linked). Payroll costs beyond wages
+vary by country; flag them for the accountant.
+
+## Step 4: routines (SOPs)
+
+Short, numbered routines for the moments that make or break the business: opening,
+the core service or fulfilment, handling a complaint, closing, and a weekly
+reorder. Each fits on one page someone could follow on their first day.
+
+## Step 5: tools
+
+The smallest stack that runs it: payments, point of sale or store, scheduling,
+bookkeeping, inventory. Real products with their published prices, and why each.
+
+## Step 6: licences, permits and insurance
+
+A checklist of what businesses of this type usually need in the user's city or
+country (registration, tax numbers, health or food permits, signage permits,
+insurance), each with the official page to confirm it. Say plainly that rules
+differ by place and change, and the user must confirm each with the authority or a
+professional. Not legal advice.
+
+## Step 7: risk register
+
+The ten things most likely to go wrong (a supplier runs out, a key person is sick,
+the card terminal fails, a bad review, a slow month), each with how likely, how
+bad, and the plan.
+
+## Output
+
+`founder/ops.md`, plus updated `founder/numbers.json` if real costs changed. Next:
+`/founder-launch`.
diff --git a/skills/founder-plan/SKILL.md b/skills/founder-plan/SKILL.md
new file mode 100644
index 0000000..a774c94
--- /dev/null
+++ b/skills/founder-plan/SKILL.md
@@ -0,0 +1,88 @@
+---
+name: founder-plan
+description: >-
+ Your business planner. Compiles everything the other founder skills wrote (the
+ board's verdict, the competitors, the buyer panel, pricing, the offer, the CFO's
+ numbers, marketing, brand, operations and the launch plan) into one business
+ plan with a verdict at the top that is computed from the numbers, never written
+ by hand: Profitable, Not yet (with the failing numbers) or Incomplete. Adds an
+ executive summary and a one-page version for a partner, lender or investor. Use
+ when the user says "write my business plan", "put it all together", "is it
+ profitable", "give me the plan", or at the end of the founder pack.
+argument-hint: "[--min-buy-rate 0.25]"
+---
+
+# founder-plan
+
+The last step. One document a founder can act on, or hand to a partner or a
+lender, built only from what the pack found.
+
+Tool in this folder:
+
+```bash
+python3 "${CLAUDE_SKILL_DIR}/compile.py" --dir founder
+```
+
+## Step 1: see what is there
+
+```bash
+python3 "${CLAUDE_SKILL_DIR}/compile.py" --dir founder --check
+```
+
+prints the verdict and each check. The checks, all computed:
+
+1. Each unit earns money before fixed costs (`founder/numbers.json`).
+2. Year 1 makes an operating profit.
+3. The break-even fits inside capacity, if a capacity was given.
+4. Enough simulated buyers buy (`founder/panel/results.json`; default bar 25%,
+ change it with `--min-buy-rate` and say why).
+
+If there are no numbers, the verdict is Incomplete: offer to run `/founder-cfo`.
+List the other missing sections with the skill that fills each. Do not fill a
+missing section yourself from guesses.
+
+## Step 2: the summary
+
+Write `founder/summary.md`, half a page, plain words:
+
+- What the business is and who it is for, in two sentences.
+- The verdict and the three numbers behind it (margin, break-even, year 1).
+- What the buyer panel and the board agreed on, and where they disagreed.
+- The biggest risk and what will be done about it.
+- What the founder needs to start (cash from the CFO, the first test from launch).
+- The one thing to do this week.
+
+If the verdict is Not yet, the summary leads with what has to change and which skill
+changes it. Never soften a failing check.
+
+## Step 3: compile
+
+```bash
+python3 "${CLAUDE_SKILL_DIR}/compile.py" --dir founder
+```
+
+writes `founder/business-plan.md`: title, the verdict and its checks, the key numbers
+table, the idea, then every section the pack produced (summary, board, competition,
+panel, pricing, offer, numbers, marketing, brand, operations, launch), and what is
+not done yet.
+
+## Step 4: the one-pager
+
+Write `founder/one-pager.md` for someone deciding in two minutes: the problem, the
+customer, the offer and price, the numbers table, the evidence (panel result,
+competitor gap, any real test), what the money is for, and the ask. Same numbers as
+the plan, word for word.
+
+## Rules
+
+- The verdict comes from `compile.py`. Never write Profitable by hand, and never
+ round a failing number into a passing one.
+- Say once, clearly: the panel is simulated buyers and the numbers are projections;
+ real customers and real quotes confirm them. Not financial, legal or tax advice.
+- If the user wants a PDF or a deck, offer to export the plan, but keep the
+ markdown as the source of truth.
+
+## Output
+
+`founder/summary.md`, `founder/business-plan.md`, `founder/one-pager.md`. Then give
+the user the verdict in one line and the one thing to do this week.
diff --git a/skills/founder-plan/compile.py b/skills/founder-plan/compile.py
new file mode 100644
index 0000000..dd8b60b
--- /dev/null
+++ b/skills/founder-plan/compile.py
@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""Compiles the business plan for founder-plan. Standard library only, no network.
+
+Reads everything the other ten skills wrote into founder/ and assembles one
+document, founder/business-plan.md, with a verdict at the top. The verdict is
+computed from the numbers, never written by hand:
+
+ Profitable every check that has data passes
+ Not yet at least one check fails (each failure is listed with its number)
+ Incomplete there are no numbers yet (run founder-cfo first)
+
+The checks:
+ 1. each unit earns money before fixed costs (founder/numbers.json)
+ 2. year 1 makes an operating profit (founder/numbers.json)
+ 3. break-even fits inside capacity, if capacity is given
+ 4. enough of the buyer panel buys (founder/panel/results.json, --min-buy-rate, default 25%)
+
+ python3 compile.py # reads ./founder, writes ./founder/business-plan.md
+ python3 compile.py --dir path/to/founder --min-buy-rate 0.3
+ python3 compile.py --check # print the verdict and exit 0 (Profitable) or 1
+"""
+
+import argparse
+import importlib.util
+import json
+import math
+import os
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+SECTIONS = [ # (file in founder/, heading, which skill writes it)
+ ("summary.md", "Summary", "founder-plan"),
+ ("board.md", "What the board said", "founder-board"),
+ ("competitors.md", "The competition", "founder-competitors"),
+ ("panel/results.md", "The buyer panel", "founder-consumer"),
+ ("pricing.md", "Pricing", "founder-pricing"),
+ ("offer.md", "The offer", "founder-offer"),
+ ("cfo.md", "The numbers", "founder-cfo"),
+ ("marketing.md", "Marketing", "founder-marketing"),
+ ("brand.md", "Brand", "founder-brand"),
+ ("ops.md", "Operations", "founder-ops"),
+ ("launch.md", "Launch plan", "founder-launch"),
+]
+
+
+def _load_unit_economics():
+ path = os.path.join(HERE, "..", "founder-cfo", "unit_economics.py")
+ spec = importlib.util.spec_from_file_location("founder_unit_economics", path)
+ mod = importlib.util.module_from_spec(spec)
+ spec.loader.exec_module(mod)
+ return mod
+
+
+def _read(path):
+ try:
+ with open(path, encoding="utf-8") as fh:
+ return fh.read().strip()
+ except FileNotFoundError:
+ return None
+
+
+def _strip_h1(text):
+ lines = text.splitlines()
+ if lines and lines[0].startswith("# "):
+ lines = lines[1:]
+ # demote headings one level so they nest under the section heading
+ return "\n".join(("#" + l) if l.startswith("#") else l for l in lines).strip()
+
+
+def verdict(d, min_buy_rate=0.25):
+ """Return (verdict, checks, numbers, panel). checks = [(ok, text)]."""
+ checks = []
+ numbers = panel = None
+ raw = _read(os.path.join(d, "numbers.json"))
+ if raw:
+ ue = _load_unit_economics()
+ numbers = ue.analyse(json.loads(raw))
+ u = numbers["unit"]
+ c = numbers["contribution"]
+ checks.append((c > 0, "Each %s earns $%.2f before fixed costs (%.0f%% contribution)." % (u, c, numbers["contribution_pct"] * 100)
+ if c > 0 else "Each %s LOSES $%.2f before fixed costs." % (u, -c)))
+ y = numbers["year1_profit"]
+ checks.append((y > 0, "Year 1 operating profit: $%s." % "{:,.0f}".format(y) if y > 0
+ else "Year 1 operating LOSS: $%s." % "{:,.0f}".format(-y)))
+ be, cap = numbers["breakeven_per_day"], numbers["capacity_per_day"]
+ if cap is not None:
+ fits = not math.isinf(be) and be <= float(cap)
+ checks.append((fits, "Break-even is %s %ss a day against a capacity of %s." % (
+ "never reached" if math.isinf(be) else "{:,.0f}".format(math.ceil(be)), u, cap)))
+ raw = _read(os.path.join(d, "panel", "results.json"))
+ if raw:
+ panel = json.loads(raw)
+ r = panel["buy_rate"]
+ checks.append((r >= min_buy_rate, "%d of %d simulated buyers buy (%.0f%%, the bar is %.0f%%)." % (
+ panel["buys"], panel["answered"], r * 100, min_buy_rate * 100)))
+ if numbers is None:
+ v = "Incomplete"
+ elif all(ok for ok, _ in checks):
+ v = "Profitable"
+ else:
+ v = "Not yet"
+ return v, checks, numbers, panel
+
+
+def compile_plan(d, min_buy_rate=0.25):
+ idea = _read(os.path.join(d, "idea.md"))
+ name = None
+ if idea:
+ first = idea.splitlines()[0]
+ name = first[2:].strip() if first.startswith("# ") else None
+ v, checks, numbers, panel = verdict(d, min_buy_rate)
+ title = name or (numbers["business"] if numbers and numbers.get("business") else "Your business")
+ L = ["# %s · Business plan" % title, ""]
+ L.append("**Verdict: %s**" % v)
+ L.append("")
+ for ok, text in checks:
+ L.append("- %s %s" % ("✓" if ok else "✗", text))
+ if v == "Incomplete":
+ L.append("- No numbers yet. Run /founder-cfo, then compile again.")
+ L.append("")
+ if numbers:
+ be = numbers["breakeven_per_day"]
+ L += ["| key number | |", "| --- | ---: |",
+ "| Price | $%.2f a %s |" % (numbers["price"], numbers["unit"]),
+ "| Profit margin at plan | %.0f%% per %s |" % (numbers["margin_at_plan"] * 100, numbers["unit"]),
+ "| Break-even | %s %ss a day |" % ("never" if math.isinf(be) else "{:,.0f}".format(math.ceil(be)), numbers["unit"]),
+ "| Year 1 operating profit | $%s |" % "{:,.0f}".format(numbers["year1_profit"]),
+ "| Startup spend | $%s |" % "{:,.0f}".format(numbers["startup"]),
+ "| Cash needed before it pays for itself | $%s |" % "{:,.0f}".format(numbers["cash_needed"]),
+ "| Startup money earned back | %s |" % ("month %d" % numbers["payback_month"] if numbers["payback_month"] else "not in year 1")]
+ if panel:
+ L.append("| Buyer panel | %d buy · %d pass |" % (panel["buys"], panel["passes"]))
+ L.append("")
+ if idea:
+ L += ["## The idea", "", _strip_h1(idea), ""]
+ missing = []
+ for fname, heading, skill in SECTIONS:
+ text = _read(os.path.join(d, fname))
+ if text:
+ L += ["## %s" % heading, "", _strip_h1(text), ""]
+ else:
+ missing.append((heading, skill))
+ if missing:
+ L += ["## Not done yet", ""]
+ for heading, skill in missing:
+ L.append("- %s: run /%s" % (heading, skill))
+ L.append("")
+ L.append("_The panel is simulated buyers and the numbers are projections from your inputs. Confirm demand with real"
+ " customers and costs with real quotes before you spend. Not financial, legal or tax advice._")
+ return v, "\n".join(L) + "\n"
+
+
+def main(argv=None):
+ ap = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+ ap.add_argument("--dir", default="founder")
+ ap.add_argument("--min-buy-rate", type=float, default=0.25)
+ ap.add_argument("--check", action="store_true", help="print the verdict only; exit 0 if Profitable")
+ ap.add_argument("--out", help="default: <dir>/business-plan.md")
+ a = ap.parse_args(argv)
+ if not os.path.isdir(a.dir):
+ print("error: no %s/ folder here. Run the other founder skills first." % a.dir, file=sys.stderr)
+ return 2
+ v, text = compile_plan(a.dir, a.min_buy_rate)
+ if a.check:
+ _, checks, _, _ = verdict(a.dir, a.min_buy_rate)
+ print("Verdict: %s" % v)
+ for ok, t in checks:
+ print(" %s %s" % ("✓" if ok else "✗", t))
+ return 0 if v == "Profitable" else 1
+ out = a.out or os.path.join(a.dir, "business-plan.md")
+ with open(out, "w", encoding="utf-8") as fh:
+ fh.write(text)
+ print("Verdict: %s. Wrote %s" % (v, out))
+ return 0
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/skills/founder-pricing/SKILL.md b/skills/founder-pricing/SKILL.md
new file mode 100644
index 0000000..3f8ba70
--- /dev/null
+++ b/skills/founder-pricing/SKILL.md
@@ -0,0 +1,85 @@
+---
+name: founder-pricing
+description: >-
+ Finds the price buyers will actually pay. Reads the consumer panel's four price
+ answers per buyer into a Van Westendorp price-sensitivity range (too cheap, a
+ bargain, getting expensive, too expensive), sets it against what competitors
+ really charge and against the CFO's margin, and recommends a price, a price
+ ladder (good / better / best) and an opening offer to test. Use when the user
+ says "how much should I charge", "price this", "is $X too expensive", "pricing
+ strategy", "what price", or after the consumer panel.
+argument-hint: "[current price]"
+---
+
+# founder-pricing
+
+Price is the fastest lever on the margin and the one founders guess most. This
+skill sets it from three things you can check: what buyers said, what competitors
+charge, and what the business needs to earn.
+
+Tool in this folder:
+
+```bash
+python3 "${CLAUDE_SKILL_DIR}/van_westendorp.py" founder/panel/answers --price 6.50 --out founder/pricing-curve.md
+```
+
+## Step 1: what buyers said
+
+If `/founder-consumer` ran, every buyer answered four price questions. Run the
+tool on `founder/panel/answers` (or a CSV with the columns `too_cheap, cheap,
+expensive, too_expensive` from real surveys, which beat simulated answers every
+time). It reports:
+
+| point | meaning |
+| --- | --- |
+| PMC | below this, too many think it is too cheap to be good |
+| OPP | the price with the least resistance either way |
+| IPP | where as many call it a bargain as call it expensive |
+| PME | above this, too many will not buy at all |
+
+PMC to PME is the acceptable range. If the panel has not run, say so and offer to
+run `/founder-consumer --quick` first. Do not invent a range.
+
+## Step 2: what competitors charge
+
+From `founder/competitors.md` (or look them up now, from their own public price
+pages, with links): the price of the nearest substitutes for the same job. Note
+what each price includes, so you compare like with like. A matcha latte is
+compared with other matcha lattes and with the coffee it replaces, not with a tea
+bag.
+
+## Step 3: what the business needs
+
+From `founder/numbers.json`: the variable cost per unit and the break-even. Run the
+CFO's tool at two or three candidate prices to see the margin and break-even at
+each:
+
+```bash
+python3 "${CLAUDE_SKILL_DIR}/../founder-cfo/unit_economics.py" founder/numbers.json --price 7.00
+```
+
+## Step 4: decide
+
+Write `founder/pricing.md`:
+
+1. **The price**, and why: where it sits in the acceptable range, against the
+ competitors, and the margin it gives (from the tool, not a guess).
+2. **The ladder**, if the business can have one: a good / better / best (size,
+ bundle, subscription, membership) with a reason to step up each rung.
+3. **The opening offer**: an intro price or bonus for launch that does not train
+ buyers to wait for discounts, with an end date.
+4. **What to test with real buyers**: two prices inside the range and how to test
+ them (two landing pages, a pre-sale at each, A/B on the menu board).
+5. The panel's verbatim price objections (top three), so marketing can answer them.
+
+## Rules
+
+- Price answers from simulated buyers pick what to test. They are not proof.
+- Never price below variable cost to "buy" customers without saying so, and how
+ long the CFO says the business can afford it.
+- No fake anchors: no "was $X" price that was never charged.
+
+## Output
+
+`founder/pricing-curve.md`, `founder/pricing.md`. If the price changed, update
+`founder/numbers.json` and re-run `/founder-cfo`. Next: `/founder-offer`.
diff --git a/skills/founder-pricing/van_westendorp.py b/skills/founder-pricing/van_westendorp.py
new file mode 100644
index 0000000..618e605
--- /dev/null
+++ b/skills/founder-pricing/van_westendorp.py
@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""Price sensitivity (Van Westendorp) for founder-pricing. Standard library only.
+
+Every buyer on the panel answers four questions: at what price would it be too
+cheap to trust, a bargain, getting expensive, and too expensive to buy. Plotted
+together, those four answers give you an acceptable price range and the price
+that leaves the fewest people unhappy.
+
+ python3 van_westendorp.py founder/panel/answers
+ python3 van_westendorp.py prices.csv --out founder/pricing-curve.md
+ python3 van_westendorp.py founder/panel/answers --json
+
+Input is either the panel's answers folder (one JSON per buyer, written by
+founder-consumer) or a CSV with the columns too_cheap, cheap, expensive,
+too_expensive (one row per respondent; extra columns are ignored). A respondent
+missing any of the four numbers, or giving them out of order (too cheap must be
+the lowest, too expensive the highest), is dropped and counted.
+
+The four points it reports:
+
+ PMC point of marginal cheapness below this, too many think it's too cheap
+ PME point of marginal expensiveness above this, too many think it's too expensive
+ OPP optimal price point as many say "too cheap" as "too expensive"
+ IPP indifference price point as many say "a bargain" as "expensive"
+
+PMC to PME is the acceptable range. These are answers from simulated buyers:
+use the range to choose what to TEST, then test it with real ones.
+"""
+
+import argparse
+import csv
+import glob
+import json
+import os
+import sys
+
+KEYS = ("too_cheap", "cheap", "expensive", "too_expensive")
+
+
+class PricingError(Exception):
+ pass
+
+
+def _f(v):
+ try:
+ x = float(str(v).replace("$", "").replace(",", "").strip())
+ except (TypeError, ValueError):
+ return None
+ return x if x > 0 else None
+
+
+def read(path):
+ """Return (rows, dropped) where rows are (too_cheap, cheap, expensive, too_expensive)."""
+ raw = []
+ if os.path.isdir(path):
+ for fp in sorted(glob.glob(os.path.join(path, "*.json"))):
+ try:
+ with open(fp, encoding="utf-8") as fh:
+ a = json.load(fh)
+ except (json.JSONDecodeError, UnicodeDecodeError):
+ raw.append(None)
+ continue
+ raw.append(tuple(_f(a.get("price_" + k)) for k in KEYS))
+ elif path.endswith(".csv"):
+ with open(path, newline="", encoding="utf-8") as fh:
+ for r in csv.DictReader(fh):
+ raw.append(tuple(_f(r.get(k)) for k in KEYS))
+ else:
+ raise PricingError("give the panel's answers folder or a .csv")
+ rows, dropped = [], 0
+ for r in raw:
+ if r is None or any(v is None for v in r) or not (r[0] <= r[1] <= r[2] <= r[3]):
+ dropped += 1
+ continue
+ rows.append(r)
+ return rows, dropped
+
+
+def curves(rows, grid):
+ n = float(len(rows))
+ tc = [sum(1 for r in rows if r[0] >= p) / n for p in grid] # too cheap at p (falls)
+ ch = [sum(1 for r in rows if r[1] >= p) / n for p in grid] # a bargain at p (falls)
+ ex = [sum(1 for r in rows if r[2] <= p) / n for p in grid] # expensive at p (rises)
+ te = [sum(1 for r in rows if r[3] <= p) / n for p in grid] # too expensive at p (rises)
+ return tc, ch, ex, te
+
+
+def cross(grid, falling, rising):
+ """First price where the rising curve meets the falling one (linear interpolation)."""
+ for i in range(1, len(grid)):
+ d0 = rising[i - 1] - falling[i - 1]
+ d1 = rising[i] - falling[i]
+ if d0 <= 0 <= d1 and d1 != d0:
+ t = -d0 / (d1 - d0)
+ return grid[i - 1] + t * (grid[i] - grid[i - 1])
+ if d0 == 0:
+ return grid[i - 1]
+ return None
+
+
+def analyse(rows, step=None):
+ if len(rows) < 5:
+ raise PricingError("need at least 5 complete answers (got %d)" % len(rows))
+ lo = min(r[0] for r in rows)
+ hi = max(r[3] for r in rows)
+ step = step or max(0.01, round((hi - lo) / 400, 2))
+ grid, p = [], lo
+ while p <= hi + 1e-9:
+ grid.append(round(p, 4))
+ p += step
+ tc, ch, ex, te = curves(rows, grid)
+ not_cheap = [1 - v for v in ch]
+ not_exp = [1 - v for v in ex]
+ pts = {
+ "PMC": cross(grid, tc, not_cheap),
+ "PME": cross(grid, not_exp, te),
+ "OPP": cross(grid, tc, te),
+ "IPP": cross(grid, ch, ex),
+ }
+ return {"n": len(rows), "points": pts, "range": [pts["PMC"], pts["PME"]],
+ "median": {k: sorted(r[i] for r in rows)[len(rows) // 2] for i, k in enumerate(KEYS)}}
+
+
+def report(res, dropped, price=None):
+ m = lambda v: "n/a" if v is None else "$%.2f" % v
+ p = res["points"]
+ L = ["# Price sensitivity", "",
+ "%d complete answers%s. Simulated buyers: use this to pick what to test, not as the final word." % (
+ res["n"], (", %d dropped (incomplete or out of order)" % dropped) if dropped else ""), "",
+ "| point | price | what it means |", "| --- | ---: | --- |",
+ "| PMC | %s | below this, too many think it is too cheap to be good |" % m(p["PMC"]),
+ "| OPP | %s | as many say too cheap as too expensive: the least resistance |" % m(p["OPP"]),
+ "| IPP | %s | as many call it a bargain as call it expensive |" % m(p["IPP"]),
+ "| PME | %s | above this, too many say it is too expensive to buy |" % m(p["PME"]), "",
+ "**Acceptable range: %s to %s.**" % (m(p["PMC"]), m(p["PME"])), ""]
+ md = res["median"]
+ L.append("Median answers: too cheap %s, a bargain %s, getting expensive %s, too expensive %s." % (
+ m(md["too_cheap"]), m(md["cheap"]), m(md["expensive"]), m(md["too_expensive"])))
+ if price is not None and p["PMC"] is not None and p["PME"] is not None:
+ where = "inside" if p["PMC"] <= price <= p["PME"] else ("below" if price < p["PMC"] else "above")
+ L += ["", "Your current price, %s, is **%s** the acceptable range." % (m(price), where)]
+ return "\n".join(L) + "\n"
+
+
+def main(argv=None):
+ ap = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+ ap.add_argument("source", help="the panel's answers folder, or a CSV")
+ ap.add_argument("--price", type=float, help="your current price, to place it on the range")
+ ap.add_argument("--out", help="write the report here (markdown)")
+ ap.add_argument("--json", action="store_true")
+ a = ap.parse_args(argv)
+ try:
+ rows, dropped = read(a.source)
+ res = analyse(rows)
+ except (PricingError, FileNotFoundError) as e:
+ print("error: %s" % e, file=sys.stderr)
+ return 2
+ if a.json:
+ print(json.dumps(dict(res, dropped=dropped), indent=1))
+ return 0
+ text = report(res, dropped, a.price)
+ if a.out:
+ with open(a.out, "w", encoding="utf-8") as fh:
+ fh.write(text)
+ print("wrote %s" % a.out)
+ else:
+ sys.stdout.write(text)
+ return 0
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/tests/_load.py b/tests/_load.py
new file mode 100644
index 0000000..9b14080
--- /dev/null
+++ b/tests/_load.py
@@ -0,0 +1,19 @@
+"""Load a tool from a skill folder (the folder names have hyphens)."""
+
+import importlib.util
+import os
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+SKILLS_DIR = os.path.join(ROOT, "skills")
+
+
+def load(folder, name):
+ path = os.path.join(SKILLS_DIR, folder, name + ".py")
+ spec = importlib.util.spec_from_file_location("founder_" + name, path)
+ mod = importlib.util.module_from_spec(spec)
+ spec.loader.exec_module(mod)
+ return mod
+
+
+def example(folder, name):
+ return os.path.join(SKILLS_DIR, folder, name)
diff --git a/tests/test_compile.py b/tests/test_compile.py
new file mode 100644
index 0000000..98d0eff
--- /dev/null
+++ b/tests/test_compile.py
@@ -0,0 +1,62 @@
+import json
+import os
+import shutil
+import tempfile
+import unittest
+
+from _load import load, example
+
+plan = load("founder-plan", "compile")
+
+
+class Compile(unittest.TestCase):
+ def setUp(self):
+ self.d = tempfile.mkdtemp()
+ with open(os.path.join(self.d, "idea.md"), "w") as fh:
+ fh.write("# Moss Matcha Bar\n\nA walk-in matcha cafe on King St W.\n")
+
+ def tearDown(self):
+ shutil.rmtree(self.d)
+
+ def numbers(self, **change):
+ with open(example("founder-cfo", "example.json")) as fh:
+ s = json.load(fh)
+ s.update(change)
+ with open(os.path.join(self.d, "numbers.json"), "w") as fh:
+ json.dump(s, fh)
+
+ def panel(self, buys, n=100):
+ os.makedirs(os.path.join(self.d, "panel"), exist_ok=True)
+ with open(os.path.join(self.d, "panel", "results.json"), "w") as fh:
+ json.dump({"buys": buys, "passes": n - buys, "answered": n, "buy_rate": buys / float(n)}, fh)
+
+ def test_no_numbers_is_incomplete(self):
+ v, text = plan.compile_plan(self.d)
+ self.assertEqual(v, "Incomplete")
+ self.assertIn("run /founder-cfo", text)
+
+ def test_good_numbers_and_panel_is_profitable(self):
+ self.numbers()
+ self.panel(40)
+ v, text = plan.compile_plan(self.d)
+ self.assertEqual(v, "Profitable")
+ self.assertTrue(text.startswith("# Moss Matcha Bar · Business plan"))
+ self.assertIn("| Profit margin at plan | 38% per cup |", text)
+ self.assertIn("40 buy · 60 pass", text)
+ self.assertIn("- The buyer panel: run /founder-consumer", text.replace("## Not done yet", ""))
+
+ def test_a_weak_panel_means_not_yet(self):
+ self.numbers()
+ self.panel(12)
+ v, text = plan.compile_plan(self.d)
+ self.assertEqual(v, "Not yet")
+ self.assertIn("✗ 12 of 100 simulated buyers buy", text)
+
+ def test_losing_money_means_not_yet(self):
+ self.numbers(price=3.00)
+ v, _ = plan.compile_plan(self.d)
+ self.assertEqual(v, "Not yet")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_panel.py b/tests/test_panel.py
new file mode 100644
index 0000000..0ef2346
--- /dev/null
+++ b/tests/test_panel.py
@@ -0,0 +1,107 @@
+import json
+import os
+import shutil
+import tempfile
+import unittest
+
+from _load import load, example
+
+panel = load("founder-consumer", "panel")
+
+
+def customer():
+ with open(example("founder-consumer", "customer.example.json"), encoding="utf-8") as fh:
+ return json.load(fh)
+
+
+class Deal(unittest.TestCase):
+ def test_same_seed_same_cards(self):
+ self.assertEqual(panel.deal(customer(), 100, 7), panel.deal(customer(), 100, 7))
+ self.assertNotEqual(panel.deal(customer(), 100, 7), panel.deal(customer(), 100, 8))
+
+ def test_quotas_are_exact_and_names_unique(self):
+ cards = panel.deal(customer(), 100, 3)
+ segs = {}
+ for c in cards:
+ segs[c["segment"]] = segs.get(c["segment"], 0) + 1
+ self.assertEqual(segs, {"Early-career professional": 45, "Mid-career professional": 40, "High earner": 15})
+ self.assertEqual(len({c["name"] for c in cards}), 100)
+ self.assertEqual(cards[0]["id"], "P001")
+ self.assertEqual(cards[-1]["id"], "P100")
+ for c in cards:
+ seg = next(s for s in customer()["segments"] if s["name"] == c["segment"])
+ self.assertTrue(seg["income"][0] - 500 <= c["income"] <= seg["income"][1] + 500)
+ self.assertIn(c["objection"], customer()["objections"])
+
+ def test_bad_profile_is_refused(self):
+ c = customer()
+ del c["objections"]
+ with self.assertRaises(panel.PanelError):
+ panel.deal(c)
+
+
+class Flow(unittest.TestCase):
+ def setUp(self):
+ self.d = tempfile.mkdtemp()
+ panel.init(self.d, example("founder-consumer", "customer.example.json"),
+ example("founder-consumer", "pitch.example.md"), n=20, seed=5)
+
+ def tearDown(self):
+ shutil.rmtree(self.d)
+
+ def answer(self, pid, buys, code="price", **extra):
+ a = {"id": pid, "buys": buys, "reason_code": code, "reason": "because %s" % pid,
+ "purchases_first_month": 4 if buys else 0, "would_change_my_mind": "" if buys else "a lower price"}
+ a.update(extra)
+ with open(os.path.join(self.d, "answers", pid + ".json"), "w") as fh:
+ json.dump(a, fh)
+
+ def test_briefs_carry_the_card_and_the_pitch(self):
+ waves = panel.write_briefs(self.d, wave=10)
+ self.assertEqual([len(w) for w in waves], [10, 10])
+ with open(waves[0][0][1], encoding="utf-8") as fh:
+ brief = fh.read()
+ self.assertIn("Moss Matcha Bar", brief)
+ self.assertIn('"id": "P001"', brief)
+ self.assertIn("Do not be agreeable", brief)
+
+ def test_answered_buyers_get_no_new_brief(self):
+ self.answer("P001", True, "quality")
+ ids = [j[0] for w in panel.write_briefs(self.d) for j in w]
+ self.assertNotIn("P001", ids)
+ self.assertEqual(len(ids), 19)
+
+ def test_check_and_tally(self):
+ for i in range(1, 21):
+ pid = "P%03d" % i
+ self.answer(pid, i <= 8, "quality" if i <= 8 else ("price" if i <= 15 else "habit"))
+ # one broken answer: wrong reason code
+ self.answer("P020", False, "vibes")
+ probs = dict(panel.check(self.d))
+ self.assertEqual(list(probs), ["P020"])
+ res = panel.tally(self.d)
+ self.assertEqual((res["buys"], res["passes"], res["answered"]), (8, 11, 19))
+ self.assertEqual(res["why_not"][0][0], "price")
+ self.assertEqual(res["why_not"][0][1], 7)
+ self.assertEqual(res["skipped"][0][0], "P020")
+ text = panel.results_md(res)
+ self.assertIn("**8 buy · 11 pass**", text)
+ self.assertIn("not customers", text)
+
+ def test_save_files_a_printed_answer_and_refuses_junk(self):
+ reply = 'Here is my answer:\n```json\n{"id": "P002", "buys": false, "reason_code": "price", "reason": "too much"}\n```'
+ panel.save(self.d, "P002", reply)
+ self.assertNotIn("P002", dict(panel.check(self.d)))
+ with self.assertRaises(panel.PanelError):
+ panel.save(self.d, "P003", '{"id": "P003", "buys": "maybe", "reason_code": "price", "reason": "x"}')
+ self.assertEqual(dict(panel.check(self.d))["P003"], "missing")
+ with self.assertRaises(panel.PanelError):
+ panel.save(self.d, "P999", '{"id": "P999"}')
+
+ def test_tally_with_no_answers_refuses(self):
+ with self.assertRaises(panel.PanelError):
+ panel.tally(self.d)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_pricing.py b/tests/test_pricing.py
new file mode 100644
index 0000000..ad8a9ba
--- /dev/null
+++ b/tests/test_pricing.py
@@ -0,0 +1,54 @@
+import csv
+import os
+import tempfile
+import unittest
+
+from _load import load
+
+vw = load("founder-pricing", "van_westendorp")
+
+
+def rows(n=40):
+ out = []
+ for i in range(n):
+ k = i / float(n - 1)
+ out.append((2.5 + k, 4.0 + k, 6.0 + 1.5 * k, 7.5 + 2 * k))
+ return out
+
+
+class Pricing(unittest.TestCase):
+ def test_points_are_ordered_and_inside_the_answers(self):
+ res = vw.analyse(rows())
+ p = res["points"]
+ for k in ("PMC", "PME", "OPP", "IPP"):
+ self.assertIsNotNone(p[k], k)
+ self.assertTrue(2.5 <= p[k] <= 9.5, (k, p[k]))
+ self.assertLess(p["PMC"], p["PME"])
+ self.assertLessEqual(p["PMC"], p["OPP"])
+ self.assertLessEqual(p["OPP"], p["PME"])
+
+ def test_out_of_order_and_incomplete_rows_are_dropped(self):
+ d = tempfile.mkdtemp()
+ path = os.path.join(d, "p.csv")
+ with open(path, "w", newline="") as fh:
+ w = csv.writer(fh)
+ w.writerow(vw.KEYS)
+ for r in rows(10):
+ w.writerow(r)
+ w.writerow((9, 4, 6, 8)) # too cheap above a bargain: out of order
+ w.writerow((3, "", 6, 8)) # incomplete
+ got, dropped = vw.read(path)
+ self.assertEqual((len(got), dropped), (10, 2))
+
+ def test_too_few_answers_is_refused(self):
+ with self.assertRaises(vw.PricingError):
+ vw.analyse(rows(4))
+
+ def test_report_places_the_price(self):
+ res = vw.analyse(rows())
+ self.assertIn("**inside** the acceptable range", vw.report(res, 0, price=6.5))
+ self.assertIn("**above** the acceptable range", vw.report(res, 0, price=40))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_repo.py b/tests/test_repo.py
new file mode 100644
index 0000000..cc365f5
--- /dev/null
+++ b/tests/test_repo.py
@@ -0,0 +1,95 @@
+import json
+import os
+import re
+import unittest
+
+from _load import ROOT, SKILLS_DIR
+
+SKILLS = ["founder-board", "founder-marketing", "founder-cfo", "founder-consumer", "founder-launch",
+ "founder-pricing", "founder-offer", "founder-competitors", "founder-brand", "founder-ops", "founder-plan"]
+ABOUT = ("Eleven free Claude skills that test a business before you launch it: a board trained on Hormozi, "
+ "Thiel and Jobs, a marketing director, a CFO, and a consumer panel of 100 buyer agents. Free, MIT.")
+
+
+def frontmatter(path):
+ with open(path, encoding="utf-8") as fh:
+ text = fh.read()
+ m = re.match(r"^---\n(.*?)\n---\n", text, re.S)
+ return (m.group(1) if m else ""), text
+
+
+EM = chr(0x2014) # built in code so this file does not trip its own check
+
+
+def text_files():
+ for base, dirs, files in os.walk(ROOT):
+ dirs[:] = [d for d in dirs if d not in (".git", "__pycache__")]
+ for f in files:
+ if f.endswith((".md", ".py", ".json", ".txt")) or f in ("LICENSE", ".gitignore"):
+ yield os.path.join(base, f)
+
+
+class Repo(unittest.TestCase):
+ def test_eleven_skill_folders(self):
+ found = sorted(d for d in os.listdir(SKILLS_DIR) if os.path.isfile(os.path.join(SKILLS_DIR, d, "SKILL.md")))
+ self.assertEqual(found, sorted(SKILLS))
+
+ def test_frontmatter_name_and_description(self):
+ for s in SKILLS:
+ fm, text = frontmatter(os.path.join(SKILLS_DIR, s, "SKILL.md"))
+ self.assertIn("name: %s\n" % s, fm + "\n", s)
+ self.assertRegex(fm, r"description: ", s)
+ self.assertGreater(len(fm), 300, "%s description is too thin" % s)
+ self.assertGreater(len(text.splitlines()), 60, s)
+
+ def test_tools_named_in_skills_exist(self):
+ for s in SKILLS:
+ _, text = frontmatter(os.path.join(SKILLS_DIR, s, "SKILL.md"))
+ for tool in re.findall(r"\$\{CLAUDE_SKILL_DIR\}/([\w.\-/]+\.(?:py|md))", text):
+ self.assertTrue(os.path.exists(os.path.normpath(os.path.join(SKILLS_DIR, s, tool))), "%s: %s" % (s, tool))
+
+ def test_plugin_manifests(self):
+ with open(os.path.join(ROOT, ".claude-plugin", "plugin.json")) as fh:
+ plugin = json.load(fh)
+ self.assertEqual(plugin["name"], "founder-skill")
+ self.assertEqual(plugin["description"], ABOUT)
+ self.assertEqual(plugin["license"], "MIT")
+ with open(os.path.join(ROOT, ".claude-plugin", "marketplace.json")) as fh:
+ market = json.load(fh)
+ self.assertEqual(market["name"], "founder-skill")
+ self.assertEqual(market["plugins"][0]["name"], "founder-skill")
+ self.assertEqual(market["plugins"][0]["source"], "./")
+
+ def test_readme_carries_the_reel_copy(self):
+ with open(os.path.join(ROOT, "README.md"), encoding="utf-8") as fh:
+ readme = " ".join(fh.read().split())
+ self.assertTrue(readme.startswith("# The Founder skill"))
+ for line in (
+ "Eleven Claude skills that test a business before you launch it. Free, MIT, no signup, no API key, "
+ "nothing to connect.",
+ "One of them is your board of directors, trained on the frameworks of Alex Hormozi, Peter Thiel and "
+ "Steve Jobs. One is your marketing director. One is your CFO and finds your real profit margins. And "
+ "one is the consumer panel: it spins up 100 buyer agents trained on your target customer and runs your "
+ "business through 100 buyer scenarios.",
+ "Paste this repo link into Claude and say `install skill`",
+ "/plugin marketplace add Jakeschincariol/founder-skill",
+ "/plugin install founder-skill@founder-skill",
+ "## Fine print",
+ ):
+ self.assertIn(line, readme)
+ for s in SKILLS:
+ self.assertIn("`skills/%s`" % s, readme)
+
+ def test_examples_parse(self):
+ for rel in ("founder-cfo/example.json", "founder-consumer/customer.example.json"):
+ with open(os.path.join(SKILLS_DIR, rel), encoding="utf-8") as fh:
+ json.load(fh)
+
+ def test_no_em_dashes(self):
+ for path in text_files():
+ with open(path, encoding="utf-8") as fh:
+ self.assertNotIn(EM, fh.read(), os.path.relpath(path, ROOT))
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/test_unit_economics.py b/tests/test_unit_economics.py
new file mode 100644
index 0000000..e203c15
--- /dev/null
+++ b/tests/test_unit_economics.py
@@ -0,0 +1,71 @@
+import json
+import math
+import unittest
+
+from _load import load, example
+
+ue = load("founder-cfo", "unit_economics")
+
+
+def spec():
+ with open(example("founder-cfo", "example.json"), encoding="utf-8") as fh:
+ return json.load(fh)
+
+
+class UnitEconomics(unittest.TestCase):
+ def test_example_reproduces_the_plan(self):
+ a = ue.analyse(spec())
+ self.assertAlmostEqual(a["contribution"], 4.76, places=2)
+ self.assertEqual(round(a["margin_at_plan"] * 100), 38)
+ self.assertEqual(math.ceil(a["breakeven_per_day"]), 186)
+ self.assertEqual(round(a["year1_profit"]), 93926)
+ self.assertEqual(a["startup"], 25280)
+ self.assertEqual(a["payback_month"], 8)
+ self.assertEqual(round(a["cash_needed"]), 34092)
+ self.assertEqual(a["flags"], [])
+
+ def test_price_below_variable_cost_is_flagged(self):
+ s = spec()
+ s["price"] = 1.50
+ a = ue.analyse(s)
+ self.assertTrue(math.isinf(a["breakeven_per_day"]))
+ self.assertTrue(any("loses money" in f for f in a["flags"]))
+
+ def test_breakeven_above_capacity_is_flagged(self):
+ s = spec()
+ s["capacity_per_day"] = 150
+ a = ue.analyse(s)
+ self.assertTrue(any("capacity is 150" in f for f in a["flags"]))
+
+ def test_what_ifs_move_the_right_way(self):
+ base = ue.analyse(spec())
+ cheaper = ue.analyse(spec(), price=base["price"] * 0.9)
+ fewer = ue.analyse(spec(), volume=0.8)
+ self.assertLess(cheaper["year1_profit"], base["year1_profit"])
+ self.assertGreater(cheaper["breakeven_per_day"], base["breakeven_per_day"])
+ self.assertLess(fewer["year1_profit"], base["year1_profit"])
+ self.assertEqual(len(ue.sensitivity(spec())), 4)
+
+ def test_bad_input_is_refused_not_guessed(self):
+ s = spec()
+ s["ramp_per_day"] = [100] * 11
+ with self.assertRaises(ue.NumbersError):
+ ue.analyse(s)
+ s = spec()
+ del s["price"]
+ with self.assertRaises(ue.NumbersError):
+ ue.analyse(s)
+ s = spec()
+ s["variable"][0]["cost"] = "lots"
+ with self.assertRaises(ue.NumbersError):
+ ue.analyse(s)
+
+ def test_report_mentions_the_key_numbers(self):
+ s = spec()
+ text = ue.report(s, ue.analyse(s))
+ for needle in ("$4.76", "186 cups a day", "**38%**", "$93,926", "month 8"):
+ self.assertIn(needle, text)
+
+
+if __name__ == "__main__":
+ unittest.main()