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.jsonnew file mode 100644index 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.jsonnew file mode 100644index 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/.gitignorenew file mode 100644index 0000000..4b0e230--- /dev/null+++ b/.gitignore@@ -0,0 +1,5 @@+.DS_Store+__pycache__/+*.pyc+.venv/+*.tmpdiff --git a/LICENSE b/LICENSEnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.jsonnew file mode 100644index 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.pynew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.jsonnew file mode 100644index 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.pynew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.pynew file mode 100644index 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.mdnew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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.pynew file mode 100644index 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()