founder-skill runs your idea past eleven critics before you spend money

A board vote, a buyer panel and a CFO, all as text files

founder-skill is not an application with a service behind it. It is a directory of eleven skills, each one a folder under skills/ named founder-board, founder-marketing, founder-cfo, founder-consumer, founder-launch, founder-pricing, founder-offer, founder-competitors, founder-brand, founder-ops and founder-plan. Each folder holds a SKILL.md that a Claude client can read, and the repository is MIT licensed, needs no signup and no API key, and the project page states plainly that there is nothing to connect.

The problem it targets is specific: finding out whether a business idea survives contact with money, positioning and customers before spending money on it. The documentation frames this as a board of directors trained on the published frameworks of Alex Hormozi, Peter Thiel and Steve Jobs, plus a marketing director, a CFO and a consumer panel. Each command is scoped to one job, so the set works as a checklist rather than a monolith.

Who it is for is also fairly clear. The topics list business-plan, startup, subagents and unit-economics, and the worked example in the README is a small retail business, a matcha cafe in Toronto selling iced matcha lattes at $6.50 a cup. This is a solo founder or a small team doing pre-launch thinking, not an enterprise strategy department. The output is prose in a folder, which is the right shape for that user and the wrong shape for anyone who needs numbers that feed a spreadsheet pipeline.

One thing the repository does not have is a home page, and it publishes no GitHub releases. The last push was on 2026-10-07, so the code is recent, but there is no version tag to pin.

The pipeline writes into a founder/ folder and reads the last step

The mechanism is a document pipeline with a fixed order. The README gives the sequence in one line:

board -> competitors -> consumer -> pricing -> offer -> cfo -> marketing -> brand -> ops -> launch -> plan

Each skill reads what the previous ones wrote, and the working files live in a founder/ folder in your project. The board writes founder/idea.md, the consumer panel writes its own customer and panel files, the pricing tool reads the panel's answer files, and the final step compiles founder/business-plan.md. That is the whole state model, and it is inspectable: you can read every intermediate file and see which numbers came from where.

Two of the eleven are worth singling out because they decide the tone of the output. /founder-board runs three sub-agents, each applying one published framework, namely Offers from $100M Offers, Monopoly from Zero to One and Product from Isaacson's Steve Jobs, and each board member scores the idea, names what would kill it and votes fund, fund if or pass. The conditions from that vote then become a checklist for the rest of the run.

The consumer panel is the other one. It spins up buyer agents, 100 by default, built from a target customer with its own income, habits and objection, one sub-agent per buyer, and it tallies who buys, who does not and why. Pricing then reads the panel's four price answers per buyer into an acceptable price range, and the offer step re-runs a quick panel to see whether the buy rate moves after the offer changes. That feedback loop is the most interesting piece of design here, and also the most fragile, since it is a model arguing with a model.

Install: paste the link, add the plugin, or copy the folders

There is no package to build. The README gives three routes, and the first is the shortest: paste the repository link into Claude and ask it to install the skill.

https://github.com/Jakeschincariol/founder-skill

install skill

For Claude Code users there is a plugin route, where the marketplace is added and the plugin installed:

/plugin marketplace add Jakeschincariol/founder-skill
/plugin install founder-skill@founder-skill

Because Claude Code namespaces plugin skills, an installed plugin shows the commands with a prefix, for example /founder-skill:founder-board. If you would rather have plain /founder-board, the documentation tells you to copy the folders into your own skills directory instead:

git clone https://github.com/Jakeschincariol/founder-skill.git
cp -r founder-skill/skills/founder-* ~/.claude/skills/

The same folders copied into a repository's .claude/skills/ folder keep the skills project-local instead of global, which is the arrangement to prefer if two projects carry unrelated skills. The tools need Python 3.8 or newer and there is nothing to pip install.

A first run is short. The README suggests /founder-consumer --quick on an idea you are still thinking about as a cheap way to find out whether to keep going, and every input for the matcha cafe example is already in the repository, so you can run the chain over that example before spending your own details on it.

Four standard-library Python scripts do the arithmetic

Most of the eleven skills are prose instructions, but four of them come with Python tools, and all four are standard library only with no network access. The commands the README gives are:

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

This split is the sensible engineering choice in the project. Judgment stays with the model, and anything a script can compute exactly is computed by a script, so the margins do not depend on the model doing arithmetic. The pricing tool is a Van Westendorp analysis over the panel's answers, and the compile tool assembles the business plan and derives the verdict from the numbers.

The worked example in the README shows what that arithmetic produces for the matcha cafe. Each cup leaves $4.76 after its own costs, break-even is 186 cups a day, and 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 the business pays for itself.

Those are the numbers for the example, and they are only as good as the input file. The script does not validate that a costs breakdown is complete or that a volume assumption is achievable, so a confident verdict on thin inputs is the most likely failure in this project.

The verdict is computed, and it only reads the files you gave it

The final step deserves attention because it is the one place where the project claims objectivity. /founder-plan compiles everything into one business plan, and the README states that its verdict is computed rather than written. The three possible values are Profitable, Not yet and Incomplete, and the rule given is that Profitable requires every unit to earn money, year 1 to make a profit, break-even to fit capacity and enough of the panel to buy. A missing input therefore produces Incomplete rather than an optimistic guess, which is a defensible design for a tool whose output people act on with money.

The limitation follows directly. Every input to that verdict is a JSON file the user wrote or a panel result the model generated. A 100-buyer panel is a simulation of opinions, not a market: the buyers have no budget, no calendar, no alternative they actually visit, and no ability to reject you. The panel is useful for surfacing objections you had not considered, and the README even treats objections as the useful output, quoting buyer lines such as "my coffee place is closer" and "$6.50 is steep for a drink". Treating the buy rate as a demand forecast is a different claim, and the repository does not support it.

The same caution applies to the two other skills that promise external verification. /founder-competitors maps competitors from public sources with prices, positioning and review complaints, every fact linked, and /founder-brand produces name candidates with trademark, domain and handle checks to run. Note the phrasing: checks to run. The tool hands you a checklist, it does not clear your trademark or reserve your domain, and the brand skill's output is legal risk you still own.

A single pasted SKILL.md is the lighter alternative

The documentation itself points to a simpler alternative. If you have no Claude Code at all, you can paste any single SKILL.md at the top of a chat and it runs as a mode. The README is explicit about the trade: you lose the sub-agents and the Python tools, but the method works. The 100-buyer swarm and the arithmetic scripts are what disappear, which means you also lose the computed verdict in founder/business-plan.md, since that verdict is produced by compile.py over files the scripts generate.

For a single idea, that is a reasonable trade. You get the board's three frameworks and the objection handling in one conversation, with no repository, no clone, no Python version to satisfy, and no files to clean up afterwards. For a business you are seriously preparing, the full install earns its keep because the intermediate files in founder/ are what let you see that a number arrived from the panel rather than from you.

The second alternative worth naming is the one this project cannot do at all: real customer conversations. Every signal in the pipeline comes from the model. If the question is whether people will pay $6.50 for a drink in a specific Toronto neighbourhood, the honest answer comes from talking to people or from actual sales, and no arrangement of sub-agents changes that.

Editorial conclusion

founder-skill fits a solo founder who wants a structured, cheap first pass on a business idea and is willing to treat the output as a hypothesis rather than evidence. It is the wrong tool if you need market validation, legal or trademark answers, or a packaged pipeline your team can run unattended. Verify first that the four Python scripts in the skills directory run on your machine with Python 3.8, and read skills/founder-plan/compile.py, because the Profitable, Not yet or Incomplete verdict it writes into founder/business-plan.md is only as honest as the JSON you feed it.

Frequently asked questions

Official sources

1. Issues
2. Jakeschincariol/founder-skill on GitHub
3. License: MIT
4. README