Term sheet review skill for Claude

---
name: term-sheet-review
description: Reviews a startup venture capital term sheet clause by clause and quantifies the economic terms. Works out the effective pre-money valuation after the option pool shuffle, liquidation preference payouts at several exit values and the anti-dilution adjustment in a down round, then rates each clause as founder-friendly, market standard or aggressive and lists questions for the founders' lawyer. Use when a founder shares or pastes a term sheet, a letter of intent or an investment offer, or asks about valuation, option pool, liquidation preference, participation, anti-dilution, pro-rata, board seats, protective provisions, drag-along or no-shop terms.
license: MIT
compatibility: Works on claude.ai, Claude Code and the Claude API. The script needs Python 3.8+ (standard library only) and no network access.
metadata:
  author: StartupReader
  version: "1.0"
  homepage: https://startupreader.com/claude-skills/term-sheet-review
---

# Term sheet review

Turn a term sheet into numbers the founders can see, then judge each clause against common practice. The output is a briefing for the founders and their lawyer, not legal advice. Say so once, at the end.

## Workflow

Copy this checklist and tick it off as you go:

```
- [ ] 1. Extract the terms into the term table
- [ ] 2. Ask for any missing inputs the maths needs
- [ ] 3. Run the numbers with scripts/term_sheet_math.py
- [ ] 4. Rate every clause using references/clauses.md
- [ ] 5. Write the review in the output format below
- [ ] 6. Check every figure in the review against the script output
```

### 1. Extract the terms

Read the whole document before rating anything: a definition on page 3 can change a clause on page 1. Record each term exactly as written, with its section number. Mark anything not mentioned as "not stated". Never fill a gap with a typical value without saying so.

Term table fields: instrument (preferred shares, in India usually CCPS; SAFE; convertible note), amount, pre-money or post-money valuation and which one it is, option pool size and whether it sits in the pre-money, liquidation preference (multiple, participation, cap, seniority), dividends, anti-dilution (type and carve-outs), pro-rata and super pro-rata, board composition, protective provisions or reserved matters, drag-along (threshold, minimum price, founder consent), tag-along and right of first refusal, founder vesting or re-vesting, information rights, exclusivity (no-shop) length, legal fee cap, conditions to closing, and which clauses are binding.

### 2. Get the inputs the maths needs

The script needs share counts as well as prices. If the founders have not given the fully diluted share count, the existing unallocated pool and the investor's stake, ask for them. If they cannot provide them, use the post-money percentages from the term sheet and say that share counts are illustrative.

### 3. Run the numbers

Run the script instead of doing the arithmetic in your head:

```bash
# Option pool shuffle: price per share, effective pre-money, who pays for the pool
python scripts/term_sheet_math.py pool --pre 20000000 --raise 5000000 --pool-post 0.10 --existing 7000000 --existing-pool 0

# Liquidation preference at low, middle and high exits (use 0.5x, 1x-2x and 5x+ the post-money)
python scripts/term_sheet_math.py waterfall --invested 5000000 --stake 0.20 --multiple 1 --participation none --exits 10000000,25000000,100000000

# Anti-dilution in a hypothetical down round at half the price
python scripts/term_sheet_math.py antidilution --old-price 2.5 --new-price 1.25 --new-money 5000000 --broad 10000000 --narrow 9000000 --invested 5000000
```

- `--pool-post` is the unallocated pool after the round as a fraction of post-money. If the pool is stated as a share of pre-money, convert it first and say so.
- For `--participation`, use `none` (non-participating), `full` (participating) or `cap` with `--cap` (total return multiple).
- Model the down round only when the term sheet has anti-dilution. Present it as "if a later round were priced at half this one", never as a forecast.
- If a script exits with an error, fix the input it names and run it again. Do not estimate instead.

### 4. Rate each clause

Read [references/clauses.md](references/clauses.md) for what founder-friendly, market standard and aggressive look like for each clause, and which questions to ask. Use exactly three ratings: **Founder-friendly**, **Market standard**, **Aggressive**. Base each one on the text, not on the investor's reputation.

Two things change a rating:
- **Stage and leverage.** A 1x non-participating preference is standard at seed and Series A. Stacked or higher multiples are more common in late or distressed rounds. Say which stage you are assuming.
- **Interaction.** A modest clause can bite in combination: participation plus a large preference, a broad veto list plus a board the investors control, or a drag-along with no minimum price.

### 5. Output format

Use this structure:

```markdown
# Term sheet review: [Company], [round], [investor]

## The headline
Two or three sentences: the real price (effective pre-money), what founders own after the round, and the one or two clauses to negotiate first.

## The numbers
| | Headline | Effective |
|---|---|---|
| Pre-money valuation | ... | ... |
| Price per share | ... | ... |
| Founders after the round | ... | ... |
Then the waterfall table and, if relevant, the anti-dilution table, each with one sentence on what it means.

## Clause by clause
| Clause | What it says (section) | Rating | Why |
|---|---|---|---|

## Negotiate first
Up to five asks, most valuable first, each with a fallback position.

## Questions for your lawyer
Numbered, specific to this document.

## Not stated
Terms the document leaves out that usually appear.
```

### 6. Check before sending

- Every number in the review appears in the script output or the term sheet.
- Each rating has a reason that quotes or cites the clause.
- Pre-money and post-money are never mixed up, and the currency matches the document.
- The review ends with: "This is a briefing to discuss with your lawyer, not legal advice."

## Rules

- Quote the document when a clause is ambiguous, and give both readings rather than choosing one silently.
- For Indian rounds, note that the term sheet usually becomes a share subscription agreement (SSA) and a shareholders' agreement (SHA), and that for foreign investors, foreign-exchange pricing rules can limit how far a conversion price can be adjusted.
- Do not tell the founders to accept or reject the term sheet. Show the trade-offs and what to ask for.

# Term sheet clauses: what to look for

## Contents
- Economics: valuation, option pool, liquidation preference, dividends, anti-dilution, pay-to-play
- Future rounds: pro-rata, right of first refusal, tag-along
- Control: board, protective provisions, drag-along, founder vesting, information rights
- Process: binding terms, exclusivity, costs, closing conditions
- Indian rounds

Ratings describe common practice in seed and Series A rounds. Later or distressed rounds often carry heavier terms; say when that applies.

## Economics

### Valuation (pre-money or post-money)
- Market standard: the term sheet says clearly whether the figure is pre-money or post-money, and what the fully diluted share count includes.
- Aggressive: a "pre-money" that already counts a new or enlarged pool, SAFEs and notes, so the effective price is lower than the headline.
- Ask: "Is the valuation pre- or post-money, and are the new pool and any SAFEs or notes inside it?"

### Option pool
- Founder-friendly: pool sized to a hiring plan for the period until the next round, or created after the round.
- Market standard: pool created or topped up before the investment, inside the pre-money, commonly 10–15% of the post-money company.
- Aggressive: a pool much larger than the hiring plan needs, which lowers the effective pre-money and leaves unused shares that dilute only existing holders.
- Run `pool` to show the effective pre-money. Ask: "Which hires does this pool cover before the next round?"

### Liquidation preference
- Founder-friendly or market standard: 1x non-participating. The investor takes its money back or converts to common, whichever is larger.
- Aggressive: a multiple above 1x, full participation (the investor takes its preference and then its share of the rest), or preferences stacked so later investors are paid ahead of earlier ones in full.
- Middle ground: participation capped at a total return (for example 3x), above which the investor converts.
- Run `waterfall` at a low, middle and high exit. Show what founders and employees receive at the low and middle exits; that is where the terms differ.

### Dividends
- Market standard: non-cumulative, paid only if declared by the board.
- Aggressive: cumulative dividends that accrue each year and are added to the preference.

### Anti-dilution
Anti-dilution lowers the investor's conversion price if shares are later sold below its price, so its preferred shares convert into more common shares. It does not protect against ordinary dilution at a higher price.
- Market standard: broad-based weighted average, with carve-outs for option grants, conversions of existing instruments and approved acquisitions.
- Less favourable: narrow-based weighted average (a smaller A in the formula, so a larger adjustment).
- Aggressive: full ratchet, which drops the conversion price to the new price however few shares are sold. Uncommon in venture rounds; tends to appear when the company has little leverage.
- Ask for carve-outs and a waiver that a set majority of the protected investors can sign. Run `antidilution` to show the extra shares.

### Pay-to-play
Investors keep their protections only if they take up their pro-rata share of a later, usually down, round. Generally helpful to founders because it keeps investors supporting the company.

## Future rounds

### Pro-rata (pre-emptive) rights
- Market standard: the right to buy enough of the next round to keep the investor's percentage, often limited to "major investors" above an agreed holding.
- Check how ownership is measured: fully diluted or issued shares only. Issued-only gives a larger allocation.
- Aggressive: super pro-rata (the right to buy more than its share), especially uncapped or for several rounds. A large pro-rata can crowd out a new lead.

### Right of first refusal (ROFR)
The company and/or investors can buy shares a founder wants to sell, on the same terms. Market standard. Check that small transfers to family trusts or for estate planning are excluded.

### Tag-along (co-sale)
If founders sell, investors can sell the same proportion of their shares on the same terms. Market standard.

## Control

### Board
- Founder-friendly or market standard at seed and Series A: founders keep a majority, or the board is balanced with an independent director both sides agree on.
- Aggressive: investors control the board at an early stage, or appoint the independent director alone.

### Protective provisions (reserved matters)
Decisions that need the investors' consent.
- Market standard: a short, specific list: changing the rights of the investors' shares, issuing senior or equal shares, selling the company, changing the size of the board, large borrowing, winding up.
- Aggressive: everyday decisions such as budgets, hiring and firing executives, contracts above a low limit, or any new share issue including employee options, especially with a separate veto for each investor.

### Drag-along
Holders above a threshold can make everyone else sell on the same terms.
- Founder-friendly: needs founder or common-holder consent, or a minimum price (for example a multiple of the preference).
- Market standard: a majority or supermajority of all holders plus a majority of the preferred.
- Aggressive: the investors alone can drag, with no minimum price, so a sale that pays only the preference can be forced.

### Founder vesting or re-vesting
- Market standard: four years with a one-year cliff, with credit for time already worked if the company is not brand new.
- Aggressive: full re-vesting from zero with no credit, or "bad leaver" terms that take back vested shares for reasons other than misconduct.
- Ask for double-trigger acceleration: shares vest early if the company is sold and the founder then loses their role.

### Information rights
Monthly or quarterly accounts, an annual budget and audit rights. Market standard. Check that the reporting burden is realistic for the team.

## Process

### What binds
Usually binding: exclusivity (no-shop), confidentiality, costs and governing law. Usually non-binding: valuation and almost every other term. Either side can walk away from non-binding terms, most often over a due-diligence problem.

### Exclusivity (no-shop)
- Market standard: 30–60 days.
- Aggressive: longer than 60 days, or no end date. Ask for it to end early if the investor walks away or changes the price.

### Costs
Investors often ask the company to pay their legal fees. Market standard with a cap. Aggressive with no cap or a high one.

### Conditions to closing
Due diligence, final documents, approvals. Note any condition that depends on a third party, such as a regulator or another investor, because it can delay the money.

## Indian rounds
- Investors usually take compulsorily convertible preference shares (CCPS). The term sheet becomes a share subscription agreement (SSA) for the investment and a shareholders' agreement (SHA) for ongoing rights, and the articles of association are amended so those rights can be enforced.
- "Reserved matters" is the usual name for protective provisions.
- For foreign investors, foreign-exchange rules generally require the conversion formula to be fixed when shares are issued and the conversion price not to fall below the fair value at that time, which can limit how far an anti-dilution adjustment can go. Flag this for the lawyer rather than modelling it.

#!/usr/bin/env python3
"""Term sheet arithmetic: option pool shuffle, liquidation waterfall, anti-dilution.

Standard library only, so it runs in the Claude API sandbox (no network, no
package installs), on claude.ai and in Claude Code.

Usage:
  python scripts/term_sheet_math.py pool --pre 20000000 --raise 5000000 \
      --pool-post 0.10 --existing 7000000 [--existing-pool 0]
  python scripts/term_sheet_math.py waterfall --invested 5000000 --stake 0.20 \
      --multiple 1 --participation none|full|cap --cap 3 \
      --exits 10000000,25000000,100000000
  python scripts/term_sheet_math.py antidilution --old-price 2.5 --new-price 1.25 \
      --new-money 5000000 --broad 10000000 [--narrow 9000000] [--invested 5000000]

Amounts are in one currency unit (dollars or rupees); shares are counts.
Results are simplified models for checking a term sheet, not legal advice.
"""
import argparse
import sys


def money(x):
    return f"{x:,.0f}"


def pct(x):
    return f"{x * 100:.1f}%"


def fail(message):
    print(f"Error: {message}", file=sys.stderr)
    sys.exit(2)


def pool(args):
    """Investor stake and pool size are fixed on a post-money basis; the pool
    is created before the round, so its shares are priced into the pre-money."""
    if args.pre <= 0 or args.raise_ <= 0:
        fail("--pre and --raise must be positive")
    post = args.pre + args.raise_
    investor = args.raise_ / post
    if not 0 <= args.pool_post < 1 - investor:
        fail(f"--pool-post must be between 0 and {1 - investor:.3f} (the investor already takes {pct(investor)})")
    # Post-round total T: existing holders keep 1 - investor - pool of it, so
    # T = existing / (1 - investor - pool). An existing unallocated pool counts
    # toward the target, so only the shortfall is added.
    total = args.existing / (1 - investor - args.pool_post)
    top_up = args.pool_post * total - args.existing_pool
    if top_up < 0:
        print(f"Note: the existing pool is already above {pct(args.pool_post)} of post-money, so nothing is added.")
        top_up = 0.0
    pre_shares = args.existing + args.existing_pool + top_up
    price = args.pre / pre_shares
    new_shares = args.raise_ / price
    total = pre_shares + new_shares
    effective_pre = (args.existing + args.existing_pool) * price
    print("Option pool shuffle (pool created before the round, inside the pre-money)")
    print(f"  Post-money valuation:      {money(post)}")
    print(f"  Price per share:           {price:,.4f}")
    print(f"  New investor shares:       {money(new_shares)}  ({pct(new_shares / total)})")
    print(f"  Pool shares added:         {money(top_up)}")
    print(f"  Pool after round:          {money(args.existing_pool + top_up)}  ({pct((args.existing_pool + top_up) / total)})")
    print(f"  Existing holders after:    {money(args.existing)}  ({pct(args.existing / total)})")
    print(f"  Effective pre-money:       {money(effective_pre)}  (headline {money(args.pre)})")
    print(f"  Cost of the pool to existing holders: {money(args.pre - effective_pre)}")
    if top_up > 0 and args.existing_pool == 0:
        # Without the shuffle the investor buys at pre / existing, then a pool
        # of the same size dilutes everyone, the investor included.
        holders = 1 - investor
        print(f"  Same pool created after the round instead: existing holders {pct(holders * (1 - args.pool_post))},"
              f" investor {pct(investor * (1 - args.pool_post))}")


def waterfall(args):
    """One preferred class, one exit. The investor takes its preference or, if
    better, converts to common; participating preferred takes both (up to a cap)."""
    if not 0 < args.stake < 1:
        fail("--stake must be the investor's as-converted ownership, between 0 and 1")
    if args.participation == "cap" and not args.cap:
        fail("--participation cap needs --cap (total return multiple, e.g. 3)")
    try:
        exits = [float(x) for x in args.exits.split(",") if x.strip()]
    except ValueError:
        fail("--exits must be comma-separated numbers, e.g. 10000000,25000000")
    pref = args.invested * args.multiple
    if args.participation == "none":
        label = "non-participating"
    elif args.participation == "full":
        label = "fully participating"
    else:
        label = f"participating, capped at {args.cap:g}x"
    print(f"Liquidation waterfall: {args.multiple:g}x {label}, invested {money(args.invested)}, {pct(args.stake)} as converted")
    print(f"  {'Exit value':>16}  {'Investor':>14}  {'Everyone else':>14}  How the investor is paid")
    for exit_value in exits:
        converted = args.stake * exit_value
        if args.participation == "none":
            preferred = min(pref, exit_value)
            investor = max(preferred, converted)
            how = "converts to common" if converted > preferred else "takes its preference"
        elif args.participation == "full":
            preferred = min(pref, exit_value)
            investor = preferred + args.stake * (exit_value - preferred)
            how = "preference plus its share of the rest"
        else:
            preferred = min(pref, exit_value)
            capped = min(preferred + args.stake * (exit_value - preferred), args.invested * args.cap)
            investor = max(capped, converted)
            how = "converts to common" if converted > capped else ("hits the cap" if capped == args.invested * args.cap else "preference plus its share of the rest")
        print(f"  {money(exit_value):>16}  {money(investor):>14}  {money(exit_value - investor):>14}  {how}")


def antidilution(args):
    """New conversion price = old price x (A + B) / (A + C).
    A = shares outstanding before the new issue (broad: everything incl. options
    and the unallocated pool; narrow: a smaller group), B = shares the new money
    would buy at the old price, C = new shares actually issued."""
    if args.new_price >= args.old_price:
        fail("anti-dilution applies only when --new-price is below --old-price")
    b = args.new_money / args.old_price
    c = args.new_money / args.new_price
    rows = [("Broad-based weighted average", args.old_price * (args.broad + b) / (args.broad + c))]
    if args.narrow:
        rows.append(("Narrow-based weighted average", args.old_price * (args.narrow + b) / (args.narrow + c)))
    rows.append(("Full ratchet", args.new_price))
    print(f"Anti-dilution: old price {args.old_price:g}, down-round price {args.new_price:g}, new money {money(args.new_money)}")
    print(f"  B (new money at old price): {money(b)} shares   C (shares actually issued): {money(c)}")
    if args.invested:
        before = args.invested / args.old_price
        print(f"  The investor's {money(args.invested)} converts into {money(before)} shares at the old price")
        print(f"  {'Method':<30} {'New price':>10} {'Shares as converted':>20} {'Extra shares':>13}")
    else:
        print(f"  {'Method':<30} {'New price':>10}")
    for name, price in rows:
        line = f"  {name:<30} {price:>10,.4f}"
        if args.invested:
            after = args.invested / price
            line += f" {money(after):>20} {'+' + money(after - before):>13}"
        print(line)


def main():
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    sub = parser.add_subparsers(dest="command", required=True)

    p = sub.add_parser("pool", help="option pool shuffle and effective pre-money")
    p.add_argument("--pre", type=float, required=True, help="headline pre-money valuation")
    p.add_argument("--raise", dest="raise_", type=float, required=True, help="amount invested in the round")
    p.add_argument("--pool-post", type=float, required=True, help="unallocated pool as a fraction of post-money, e.g. 0.10")
    p.add_argument("--existing", type=float, required=True, help="shares held by founders and earlier investors")
    p.add_argument("--existing-pool", type=float, default=0, help="unallocated pool shares that already exist")
    p.set_defaults(run=pool)

    w = sub.add_parser("waterfall", help="what the investor and everyone else get at each exit value")
    w.add_argument("--invested", type=float, required=True)
    w.add_argument("--stake", type=float, required=True, help="investor's as-converted ownership, e.g. 0.20")
    w.add_argument("--multiple", type=float, default=1.0, help="preference multiple, e.g. 1 or 2")
    w.add_argument("--participation", choices=["none", "full", "cap"], default="none")
    w.add_argument("--cap", type=float, help="total return cap as a multiple of the investment, with --participation cap")
    w.add_argument("--exits", required=True, help="comma-separated exit values")
    w.set_defaults(run=waterfall)

    a = sub.add_parser("antidilution", help="adjusted conversion price in a down round")
    a.add_argument("--old-price", type=float, required=True)
    a.add_argument("--new-price", type=float, required=True)
    a.add_argument("--new-money", type=float, required=True)
    a.add_argument("--broad", type=float, required=True, help="A for broad-based: all shares, options and pool")
    a.add_argument("--narrow", type=float, help="A for narrow-based, e.g. issued shares only")
    a.add_argument("--invested", type=float, help="the protected investor's original investment, to show extra shares")
    a.set_defaults(run=antidilution)

    args = parser.parse_args()
    args.run(args)


if __name__ == "__main__":
    main()