seed-terms — Claude Code skill: SAFE and term sheet analysis
The seed-terms Claude Code skill calculates ownership and dilution from SAFE and priced-round terms. It runs when asked to assess a deal or flag clauses for legal review.
MIT ★ 197 updated 2026-11-01
/plugin marketplace add Jakeschincariol/seed-skill
/plugin install seed-skill@seed-skillWhat seed-terms does
seed-terms calculates an investor’s ownership under a post-money SAFE and models a priced-round cap table with an option-pool increase. It reports the share price, newly issued shares, effective pre-money valuation and holder dilution. The calculations run through terms.py, which uses Python 3.
The scan command checks term-sheet text for clauses such as liquidation preference above 1x, board control and short deadlines. Each flagged clause gets a severity level and a question to raise with a lawyer. The scanner follows set rules and catches only terms it recognises; it is not legal advice. To scan a PDF, first extract its text into a .txt file.
With --write, results go into seed/terms/. The skill recommends having a startup lawyer review documents before signing.
What it helps with
- calculate ownership under a post-money SAFE cap
- model dilution from a priced round and a larger option pool
- compare conversion prices under a cap and a discount
- scan term-sheet text for flagged clauses
- prepare questions for a lawyer about deal terms
Example prompts for the agent
- Calculate my SAFE ownership for a 500k investment at a 10m cap.
- Model a priced round with 6m pre-money, a 1.5m raise and a 10% option pool.
- Scan
term-sheet.txtand explain the clauses that need legal review.
How to install seed-terms
1Plugin marketplace
/plugin marketplace add Jakeschincariol/seed-skill/plugin install seed-skill@seed-skillThis installs the whole seed-skill plugin with all its skills
2Skills CLI (Vercel)
npx skills add Jakeschincariol/seed-skill --skill seed-terms -a claude-code3Manually: put the files in place
~/.claude/skills/seed-terms/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/seed-terms/
1Skills CLI (Vercel)
npx skills add Jakeschincariol/seed-skill --skill seed-terms -a codex2Manually: put the files in place
.agents/skills/seed-terms/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add Jakeschincariol/seed-skill --skill seed-terms -a cursor2Manually: put the files in place
.cursor/skills/seed-terms/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install Jakeschincariol/seed-skill seed-terms2Manually: put the files in place
.github/skills/seed-terms/SKILL.md1Skills CLI (Vercel)
npx skills add Jakeschincariol/seed-skill --skill seed-terms -a gemini-cli2Platform CLI
gemini skills install https://github.com/Jakeschincariol/seed-skill --path seed-termsManually: put the files in place
.devin/skills/seed-terms/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about seed-terms
How do I install seed-terms in Claude Code?
Add the marketplace with /plugin marketplace add Jakeschincariol/seed-skill, then install the skill with /plugin install seed-skill@seed-skill.
What does seed-terms do?
It calculates SAFE conversion and priced-round cap tables, then scans term-sheet text for recognised clauses that may need review. It also drafts a question for a lawyer; it does not provide legal advice.
What does seed-terms need to run?
The calculations require Python 3. To scan a PDF, extract its text into a .txt file first. The skill recommends a startup lawyer review documents before signing.
Source text
SKILL.md · MIT
---
name: seed-terms
description: >-
Term Sheet Reader. Reads a SAFE or a term sheet in plain English, does the
dilution math and flags the clauses to ask a lawyer about. Works out what a
post-money SAFE owns at its cap and what it converts into at a priced round
(cap price vs discount price, whichever is lower), builds a priced round's
cap table with the option-pool shuffle (price per share, new shares, the
pool top-up, the effective pre-money, everyone's dilution), and scans a
pasted term sheet for the traps: liquidation preference over 1x,
participating preferred, full ratchet, redemption, cumulative dividends,
board control, operating vetoes, pay-to-play, drag-along, long no-shops,
exploding deadlines, founder vesting resets, super pro rata and MFN, each
with a severity and a question for the lawyer. Not legal advice. Writes
seed/terms/ with --write. Use when the user says "read this term sheet",
"is this a good deal", "what does this SAFE mean", "how much do I own
after", "how much dilution", "what's the option pool shuffle", "what is a
post-money cap", "any red flags in this", or when an investor sends terms
after a /seed-closer call.
argument-hint: "[safe | round | scan FILE]"
---
# seed-terms
The Term Sheet Reader is for the day an investor says yes and sends paper.
It does two jobs. First the arithmetic: what a SAFE really owns, what a
priced round does to the cap table, and how much of "the valuation" is
quietly paid by the founders through a bigger option pool. Then the reading:
it walks through the document and flags the clauses founders most often
regret, in plain words, with the exact question to put to a lawyer.
**Not legal advice, and not investment advice.** It is arithmetic and a
keyword reader. A startup lawyer should read every document before the user
signs anything, and the scanner only flags clauses it knows.
`${CLAUDE_SKILL_DIR}` below is this skill's folder (where this SKILL.md lives).
```bash
python3 "${CLAUDE_SKILL_DIR}/terms.py" safe --investment 500k --cap 10m # 5.00% at the cap
python3 "${CLAUDE_SKILL_DIR}/terms.py" safe --investment 500k --cap 10m --other 1m@10m # the whole SAFE round
python3 "${CLAUDE_SKILL_DIR}/terms.py" safe --investment 500k --cap 10m --discount 20 --round-pre 24m --round-raise 6m --pool 10
python3 "${CLAUDE_SKILL_DIR}/terms.py" round --pre 6m --raise 1.5m --pool 10 --shares 7000000
python3 "${CLAUDE_SKILL_DIR}/terms.py" round --pre 24m --raise 6m --pool 10 --cap-table seed/terms/cap-table.json
python3 "${CLAUDE_SKILL_DIR}/terms.py" scan term-sheet.txt # exit 3 = a high flag
```
Amounts: `500k`, `1.5m`, `$1,500,000`. Percentages: `20` or `20%`. A SAFE:
`[name=]investment[@cap][:discount]`, like `Northlight=500k@10m` or
`250k@8m:20`. Add `--write` to save `seed/terms/safe.json`,
`seed/terms/round.json` or `seed/terms/scan-<name>.md`; `--json` on scan.
## What it reads and writes
| file | what |
| --- | --- |
| a term sheet or SAFE as text | for `scan`: paste the PDF's text into a .txt file first |
| `--cap-table FILE.json` | optional: `{"holders": [{"name", "shares"}], "pool_unissued", "safes": [{"name", "investment", "cap", "discount"}]}` |
| `seed/terms/safe.json`, `round.json` | with `--write`: every input and every number shown |
| `seed/terms/scan-<name>.md` | with `--write`: the flags, the excerpts and the questions |
## The method
- **Post-money SAFE** (Y Combinator's standard form). Ownership at the cap =
investment / post-money cap. It converts at the lower of the cap price
(cap / company capitalization: every share, option, the unissued pool and
all converting SAFEs, but not the new money or a pool top-up made for the
round) and the discount price (the round price x (1 - discount)). With
post-money caps, every extra SAFE dilutes the founders, not the other SAFE
holders.
- **Priced round.** Price per share = pre-money / fully diluted pre-money
shares, where that count already includes the converted SAFEs and the new
pool. The pool target is the unissued pool as a share of the post-money
count. That is the option-pool shuffle: the pool is carved out before the
money comes in, so only existing holders pay for it. The tool prints the
effective pre-money (pre-money minus the pool top-up at the round price).
- The math is exact (fractions), shares are rounded down to whole shares at
the end. Real documents round the price first; expect a few shares of drift.
- **The scanner** splits the text into clauses and flags, by rules: a
liquidation preference over 1x, participating preferred (capped or not),
full-ratchet or narrow-based anti-dilution, redemption rights, cumulative
dividends, investor control of the board (it counts the seats), protective
provisions that reach into the budget, hiring or debt, pay-to-play, a
drag-along the preferred alone can trigger, a no-shop over 30 days (60 or
more is high), a deadline of 48 hours or less, a founder vesting reset,
super pro rata, MFN, and a new pool counted in the pre-money. Severity is
high (push back), medium (understand it, likely negotiate) or low (common,
know it). The standard versions (1x non-participating, broad-based weighted
average, no redemption, founder board majority, a 30-day no-shop) are listed
as standard.
## Steps
1. Ask for the document and the numbers (the raise, the valuation or cap,
the pool, the current shares). For a PDF, extract the text into a .txt.
2. `terms.py scan FILE`. Read every flag back in plain words: what it means,
then the question for the lawyer. Never tell the user a clause is fine to
sign; say what is standard and what is not.
3. Run the math: `safe` for a SAFE (with `--other` for the rest of the round),
`round` for a priced round. Show the founders' percentage before and after
and the effective pre-money. Try the counter-offer too (a smaller pool, a
higher cap) so the user sees what each ask is worth.
4. Write the questions into a short list for the lawyer. Recommend a startup
lawyer before signing, every time.
5. Hand off: /seed-dataroom for the confirmatory diligence that follows a
signed term sheet (`share-list --stage after`), and /seed-updates to keep
the other investors posted.
## Example: the reel
Leashly (fictional) raises its $1.5M seed. As post-money SAFEs at an
illustrative $10M cap, `safe --investment 500k --cap 10m --name Northlight
--other 1m@10m` shows Northlight's $500,000 owning 5.00% at the cap, the whole
$1.5M owning 15.00%, and the founders keeping 85.00% before the next round.
Priced instead, at $6M pre-money with a 10% pool: `round --pre 6m --raise 1.5m
--pool 10 --shares 7000000` gives $0.7500 a share, 2,000,000 new shares for the
investors (20.00%), a 1,000,000-share pool (10.00%), and the founders at
70.00%. The pool's $750,000 comes out of the founders' side: the effective
pre-money is $6,000,000 - $750,000 = $5,250,000.
A tough (synthetic) term sheet with a 2x participating preference, a full
ratchet, investor board control, a 60-day no-shop and a 48-hour deadline comes
back with 11 high flags; the founder-friendly version comes back with standard
terms and two low notes.
## What it never does
- Never says "sign it", never calls a term sheet good or bad overall.
- Never presents its math as the official cap table: the company's lawyer and
cap-table records are the source of truth.
- Never treats a clause it did not flag as safe. Not legal advice; not
investment advice.
© Jake Schincariol · MIT · Jakeschincariol/seed-skill