⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

v1.0.0

founder-board

jakeschincariol@jakeschincariol⭐ 3.7k stars· last commit 1mo ago· 6 open issues

>-

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐⭐⭐ 3.7k on GitHubGitHub ↗

Very popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

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:

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

commandjobwhat it does
/founder-boardBoard of DirectorsThree 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-competitorsCompetitor ScoutMaps direct competitors, indirect ones and substitutes from public sources, with prices, positioning and what their customers complain about, every fact linked.
/founder-consumerConsumer PanelSpins 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-pricingPricing StrategistTurns the panel's price answers into an acceptable price range, sets it against competitors and your margin, and picks what to test.
/founder-offerOffer ArchitectBuilds the offer stack (bonuses, guarantee, real urgency, a name) that answers the panel's objections, then re-tests it on the panel.
/founder-cfoCFOUnit economics: contribution per sale, the real profit margin, break-even per day, year 1 month by month, cash needed, payback, what-ifs.
/founder-marketingMarketing DirectorPositioning, the channels your buyers use, a dated 30-day launch campaign, ten hooks and the most you can pay for a customer.
/founder-brandBrand DesignerName candidates with the trademark, domain and handle checks to run, a voice, a promise and a brief for the look.
/founder-opsOperations ManagerSuppliers, staffing, day-one routines, tools, the permits to check and a risk register, feeding real costs back to the CFO.
/founder-launchLaunch LeadA cheap real-world test first, then a dated countdown, the launch-day run sheet and the first 30 days.
/founder-planBusiness PlannerCompiles 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.

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.

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

// HOW IT'S BUILT

// FILES

3 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • skills/founder-board/SKILL.md4.4 KB7a11afb60931upstream ↗
    ---
    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/`.
    
  • skills/founder-board/lenses.md3.8 KB09edf0f14683upstream ↗
    # 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?
    
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/jakeschincariol-founder-skill-skills-founder-board.md

// REPO STATS

3.7k stars
6 open issues
Last commit: 1mo ago