# founder-board

Adopt this skill: https://proskills.md/skills/other/jakeschincariol-founder-skill-skills-founder-board

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

## File: skills/founder-board/SKILL.md
size: 4538
sha: 7a11afb60931919249814d6cf97c83d76edca1ea
upstream: https://github.com/jakeschincariol/founder-skill/blob/main/skills/founder-board/SKILL.md

````text
---
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/`.
````

## File: skills/founder-board/lenses.md
size: 3934
sha: 09edf0f146833093ed39c65266e127a9ff54c182
upstream: https://github.com/jakeschincariol/founder-skill/blob/main/skills/founder-board/lenses.md

```text
# 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?
```

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

````text
# 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, quo
````
