Skip to main content
skill CX Codex

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

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add Jakeschincariol/seed-skill
/plugin install seed-skill@seed-skill
Open on GitHub

What 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.txt and 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-skill

This installs the whole seed-skill plugin with all its skills

2Skills CLI (Vercel)

npx skills add Jakeschincariol/seed-skill --skill seed-terms -a claude-code

3Manually: put the files in place

~/.claude/skills/seed-terms/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/seed-terms/

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

Similar skills

All skills for Finance and business →

From the same set12

The whole set →
seed-dataroom The seed-dataroom Claude Code skill organizes an investor data room and checks its files against a checklist. It activates on requests to prepare diligence materials or after a successful investor call. CX Codex +1 ★ 197repo stars seed-market seed-market — a skill for Claude Code estimates TAM, SAM, and SOM. It activates on market-sizing requests or after /seed-scout, before /seed-model and /seed-plan. CX Codex +1 ★ 197repo stars seed-updates The seed-updates Claude Code skill drafts monthly investor updates with metric changes and a runway calculation. It can also prepare a shorter version for prospects who previously said “not now.” CX Codex +1 ★ 197repo stars seed-deck The seed-deck Claude Code skill turns a business plan into a 10-slide pitch deck. It creates an HTML presentation and checks its content and figures. CX Codex +1 ★ 197repo stars seed-plan The seed-plan Claude Code skill builds a nine-section business plan from a startup idea. It runs when asked to draft or check a plan, work out unit economics, or prepare for /seed-deck. CX Codex +1 ★ 197repo stars seed-scout The seed-scout Claude Code skill examines competitors’ App Store reviews and groups recurring complaints. It runs for competitor research based on an idea or before drafting a plan and pitch deck. CX Codex +1 ★ 197repo stars seed-model seed-model — a Claude Code skill that builds a 36-month financial model from business assumptions. It runs for questions about runway, break-even, fundraising, or before /seed-plan and /seed-deck. CX Codex +1 ★ 197repo stars seed-investors The seed-investors Claude Code skill finds investors for a startup and scores their fit. It runs on requests to find or rank investors, after /seed-plan and before /seed-closer. CX Codex +1 ★ 197repo stars

Project sponsors

Companies that keep this analytics open