# cap-table

Adopt this skill: https://proskills.md/skills/other/lool-ventures-founder-skills-founder-skills-skills-cap-table

Page: https://proskills.md/skills/other/lool-ventures-founder-skills-founder-skills-skills-cap-table
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: founder-skills/skills/cap-table/SKILL.md
size: 8069
upstream: https://github.com/lool-ventures/founder-skills/blob/main/founder-skills/skills/cap-table/SKILL.md

````text
---
name: cap-table
description: "Use for any cap-table number, mechanic, or date before a founder signs, from a single SAFE, note or warrant described in chat or a quick 'is this dilution reasonable?' check to any draft or signed SAFE, note, term sheet, option plan, AoA, Carta XLSX, or spreadsheet. A single question gets a short cited answer in about 2–3 minutes; the full report, about 5–10 minutes, runs only when the founder shares documents or asks for it. Source-cited deterministic math (YC, NVCA, Cooley GO) for SAFE/note conversion, priced-round dilution, anti-dilution, option pools, warrants, MFN chains, dual-class voting, QSBS and Israeli §102 dates, and Israeli ↔ Delaware flips. NOT for waterfall modeling, cumulative dividends, RSUs, 83(b), 409A, SPAC, warrant repricing, or pure term definitions."
when_to_use: >
  Cap-table questions carry known miscalculation and reliance traps, so run the
  math rather than answer from memory. Do NOT use for a pure definition with
  nothing numeric, dated, or eligibility-related at stake ('what is a SAFE?'),
  fundraising strategy ('how much should I raise?'), or financial-model review
  (use financial-model-review).
user-invocable: true
---

# Cap-Table Skill

Model cap-table mechanics for founders so they understand what their term sheets, SAFEs, and convertible notes actually do to their ownership — before they sign. Produce rule-pack-cited math for SAFE conversion, convertible-note conversion, priced-round dilution, option-pool top-ups, anti-dilution, and Israeli ↔ Delaware flips. Every counsel-review item links back to a primary source (YC SAFE primer, NVCA model docs, Israeli Companies Law / Income Tax Ordinance, etc.). Tone is founder-first: a candid coach who's read the documents you can't be expected to read.

## Reliance Boundary (mandatory)

For any eligibility, qualification, or status determination that turns on tax or legal facts the cap-table data cannot settle — QSBS (IRC §1202), Israeli §102 track / holding period, IIA obligations, or any rule carrying `counsel_review` — state the **cited fact** (the date window, threshold, or clock) and stop there. **Never conclude that the founder does or will qualify** ("yes, you qualify", "you're eligible", "strong eligibility posture"). The date or threshold is a fact you may assert with its citation; the *conclusion* is a counsel determination — present it as such and emit a counsel item. This holds whether the engagement runs the full pipeline, fast-assess, or a one-line directional answer: the boundary is about what you may *conclude*, not how deep the analysis went.

## Skill Metadata

- **Author:** lool-ventures
- **Version:** managed in `founder-skills/.claude-plugin/plugin.json`
- **Compatibility:** Python 3.10+ and `uv` for script execution.
- **Rule pack:** consumes `data/cap-table-rules.json` at script runtime.
- **Exports (full pipeline, in `cap-table-{slug}/`):**
  - `inputs.json` + `scenarios.json` → `financial-model-review` (cross-validates revenue/dilution scenarios)
  - `cap_state.json` → `ic-sim` (IC partners ask about dilution exposure)
  - `counsel_packet.json` → `fundraise-readiness` (overall readiness scorecard)
  - `report.json` → `fundraise-readiness`, future `cross-document-consistency` skill
- **Exports (fast-assess mode, in `cap-table-{slug}-fastassess/`):**
  - `fast_assess_only.json` — sentinel marking that fast-assess ran (no canonical artifacts). See `${CLAUDE_PLUGIN_ROOT}/skills/cap-table/references/sentinel-schema.md`. Future cross-skill consumers MUST check for this sentinel before treating a missing canonical artifact as "cap-table never ran."
  - `report_fast_assess.md` — founder-facing markdown deliverable
- **Imports:**
  - `market-sizing:sizing.json` — sanity-check that the planned raise + cap is consistent with modeled SAM/SOM
  - `financial-model-review:report.json` — current revenue scale + runway, to gate scenario plausibility

## Skill Execution Model (READ FIRST)

> See `founder-skills/references/skill-execution-model.md` for the full inline-skill execution model (3 dispatch contexts, Mitigation 1+2, producer contract, Cowork quirks, per-symptom triage).

This skill runs **inline in the main thread**, not as a sub-agent — see the reference above ("Why Inline (Not Forked Sub-Agent)") for the rationale. Sub-agents are deliberately shell-free, so orchestration (producer scripts, artifact persistence) stays in the main thread.

**Two dispatch contexts for the sub-agent:**

- **Context A — Per-step analytical dispatch (Mitigation 1):** Used ONLY for document-extraction lanes. Cap-table math is fully deterministic and rule-driven — the reference's Context A section carries this as cap-table's dedicated exception (no analytical/judgment work in the math layer requires a sub-agent) — so Context A is reserved for tasks that genuinely need semantic extraction from natural-language documents:
  - `INSTRUMENT_EXTRACTION` — extract terms from a PDF/DOCX SAFE, note, term sheet, or option plan
  - `SPREADSHEET_STRUCTURE_DETECTION` — identify which cells encode founders / preferred / options / convertibles in a freeform spreadsheet that doesn't match the Carta schema

  The sub-agent returns structured JSON. The main thread pipes the JSON through the validation producer (`extract_instrument.py` / `extract_cap_table.py`), which enforces the anti-hallucination gate. The sub-agent does NOT write artifacts directly.

- **Context B — Post-compose coaching dispatch (POST_COMPOSE_COACHING):** After `compose_report.py` writes `report.md` + `report.json`, the sub-agent Reads the staged `coaching_payload.json` from the hand-off dir (Mitigation 2) — it does NOT read the full `report.md` — composes the coaching commentary, WRITES it to the `OUTPUT_PATH` hand-off file, and returns a small receipt. The main thread gates the file (`check_handoff.py`) and inserts it via the shared `insert_coaching.py` script (idempotency matrix, uuid-marker replacement, run_id-parity verification — all deterministic). See the reference above for the full Context B contract.

**Tolerant JSON extraction protocol (Context A):** After dispatching the sub-agent, capture its final assistant message. The sub-agent should return raw JSON, but may wrap it in ` ```json ... ``` ` fences or add a prose preamble. Extract JSON tolerantly:

1. If the message is wrapped in a ` ```json ... ``` ` (or plain ` ``` ... ``` `) fence, strip the fence first.
2. Try to parse the stripped text directly as JSON.
3. If that fails, walk through the text looking for the first `{` character and try `json.JSONDecoder().raw_decode(text[i:])` — this is brace-aware and handles nested objects correctly (unlike regex, which truncates on the first `}`).
4. If extraction fails entirely, re-prompt the sub-agent with: "Your previous reply could not be parsed as JSON. Return ONLY the JSON object — no markdown fences, no prose preamble."

## Input Formats — Four Lanes

Each lane produces normalized `instruments.json` and/or `cap_state.json` plus an `extraction_audit.json` trail. The main thread picks the lane from the founder's input type. **Founder-facing:** lanes, grids, and structure-detection are internal — to the founder this is just "reading your cap table" (or "reading your spreadsheet"); never announce the lane number, "the grid", "structure detection", or a script/flag as you work through the steps below.

- **Lane 1 — Single instrument (PDF / DOCX).** Typical: 5–15 page SAFE, term sheet, convertible note, option plan, **or Articles of Association**. Main thread reads via the Read tool (native PDF support, up to 20 pages per call; longer docs use `pages` parameter). For SAFEs/notes/term-sheets/option-plans: dispatch Context A `INSTRUMENT_EXTRACTION`; pipe returned JSON through `extract_instrument.py`. For AoAs: dispatch Context A `ARTICLES_OF_ASSOCIATION_EXTRACTION` (see `${CLAUDE_PLUGIN_ROOT}/skills/cap-table/references/lanes/lane-1-pdf-docx.md`, section *Dispatch Context A — ARTICLES_OF
````

## File: README.md
upstream: https://github.com/lool-ventures/founder-skills/blob/main/README.md

```text
<p align="center">
  <img src="assets/github_header.png" alt="founder skills — AI coaching skills for startup founders" />
</p>

[![Claude Cowork](https://img.shields.io/badge/Claude_Cowork-D97757?logo=claude&logoColor=fff)](https://claude.com/blog/cowork-plugins)
[![Claude Code](https://img.shields.io/badge/Claude_Code-555?logo=claude&logoColor=fff)](https://code.claude.com/docs/en/plugins)
[![CI](https://github.com/lool-ventures/founder-skills/actions/workflows/ci.yml/badge.svg)](https://github.com/lool-ventures/founder-skills/actions/workflows/ci.yml)
[![License: Apache 2.0](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/lool-ventures/founder-skills)
[![Built with Skill Creator Plus](https://img.shields.io/badge/Built_with-Skill_Creator_Plus-4ecdc4?style=flat-square)](https://github.com/yaniv-golan/skill-creator-plus)
[![Install in Claude](https://img.shields.io/badge/Install_in_Claude-D97757?style=for-the-badge&logo=claude&logoColor=white)](https://founderskills.lool.vc/static/install-claude-desktop.html)

Skills for startup founders by [lool ventures](https://lool.vc).

A [Claude Cowork](https://claude.com/blog/cowork-plugins) plugin that gives founders six AI-powered coaching skills: market sizing, pitch deck review, financial model review, IC simulation, competitive positioning, and cap-table modeling. Each skill follows a structured, script-backed workflow to produce analysis that holds up under investor scrutiny.

## Contents

- [Skills](#skills)
  - [Market Sizing](#market-sizing)
  - [Deck Review](#deck-review)
  - [IC Simulation](#ic-simulation)
  - [Financial Model Review](#financial-model-review)
  - [Competitive Positioning](#competitive-positioning)
  - [Cap-Table](#cap-table)
- [Getting Started](#getting-started)
  - [Claude Cowork](#claude-cowork)
  - [Claude Code](#claude-code)
  - [What to expect on your first run](#what-to-expect-on-your-first-run)
  - [Running a skill unattended (for hosts)](#running-a-skill-unattended-for-hosts)
  - [Other platforms](#other-platforms-roadmap)
- [Development](#development)
- [Troubleshooting](#troubleshooting)
- [Privacy](#privacy)
- [Contributing](#contributing)
- [Contact](#contact)
- [License](#license)

## Skills

<picture>
  <source media="(prefers-color-scheme: dark)" srcset="assets/market_sizing.png">
  <source media="(prefers-color-scheme: light)" srcset="assets/market_sizing-light.png">
  <img alt="" src="assets/market_sizing.png">
</picture>

<a id="market-sizing-agent"></a>

### Market Sizing

Builds credible TAM/SAM/SOM analysis — the kind that earns investor trust rather than raising eyebrows.

**What it does:**
- Calculates TAM/SAM/SOM using top-down, bottom-up, or both approaches
- Validates market claims against external sources (analyst reports, government data, industry stats)
- Stress-tests assumptions with sensitivity analysis and confidence-based range widening
- Runs a 22-item self-check against common market sizing pitfalls
- Cross-checks every figure across the analysis before writing the report, so the numbers agree with each other
- Has a separate reviewer try to contradict the finished sizing, and shows every finding it can source

**What to provide:** A pitch deck, financial model, market data, or just describe the business (product, target customer, geography, pricing). The skill will research external sources to validate and build the estimate.

**What you get back:** A structured report with TAM/SAM/SOM figures (top-down and/or bottom-up), sensitivity ranges showing best/worst case, a scored self-check against common pitfalls, and coaching commentary on what will hold up in diligence.

**Example prompts:**
- "Use the market-sizing skill — here's the deck for Acme Corp, can you validate their market sizing?"
- "Use the market-sizing skill on a fintech startup in the payments space targeting SMBs in Europe."
- "Use the market-sizing skill — and show me what happens if the customer count is 30% lower."

> Technical workflow spec (for the agent runtime — not required reading): [`founder-skills/skills/market-sizing/SKILL.md`](founder-skills/skills/market-sizing/SKILL.md)

<picture>
  <source media="(prefers-color-scheme: dark)" srcset="assets/deck_review.png">
  <source media="(prefers-color-scheme: light)" srcset="assets/deck_review-light.png">
  <img alt="" src="assets/deck_review.png">
</picture>

<a id="deck-review-agent"></a>

### Deck Review

Reviews pitch decks against current investor best practices, calibrated by stage (pre-seed, seed, Series A).

**What it does:**
- Scores 35 criteria across 7 categories (pass/fail/warn/not_applicable)
- Detects fundraising stage and applies stage-specific expectations
- Reviews each slide from the investor's perspective with specific, actionable feedback
- Grounds every recommendation in a named best-practice principle
- Assembles a scored report with overall deck readiness assessment

**What to provide:** A pitch deck in any format — PDF, PowerPoint, markdown, or text descriptions of your slides.

**What you get back:** A slide-by-slide review from the investor's perspective, a scored checklist (35 criteria across 7 categories), an overall readiness rating (strong/solid/needs work/major revision), and coaching on the highest-leverage changes to make before sending.

**Example prompts:**
- "Use the deck-review skill on our seed deck."
- "Use the deck-review skill — is this ready to send to investors? We're raising a pre-seed."
- "Use the deck-review skill on these slides: Slide 1 is our company intro with the tagline 'AI-powered compliance for fintechs'..."

> Technical workflow spec (for the agent runtime — not required reading): [`founder-skills/skills/deck-review/SKILL.md`](founder-skills/skills/deck-review/SKILL.md)

<picture>
  <source media="(prefers-color-scheme: dark)" srcset="assets/ic_sim.png">
  <source media="(prefers-color-scheme: light)" srcset="assets/ic_sim-light.png">
  <img alt="" src="assets/ic_sim.png">
</picture>

<a id="ic-simulation-agent"></a>

### IC Simulation

Simulates a realistic VC Investment Committee discussion with three partner archetypes debating a startup's merits, concerns, and deal terms -- scored across 28 dimensions.

**What it does:**
- Simulates three distinct partner perspectives: The Visionary (markets/timing), The Operator (execution/GTM), The Analyst (unit economics/financials)
- Forms each partner's view independently, so they genuinely disagree rather than echoing one another
- Scores 28 dimensions across 7 categories (team, market, product, business model, financials, risk, fund fit)
- Checks portfolio conflicts against the fund's existing investments
- Can simulate a named fund, researching its thesis and portfolio first; the partners are role-played (The Visionary, The Operator, The Analyst), never the fund's real people
- Imports prior market-sizing and deck-review artifacts for grounded analysis

**What to provide:** A pitch deck, financial model, data room contents, or a verbal description of the business. Optionally, name a specific fund to simulate (e.g. "How would Northwind Ventures evaluate us?"). Works best after running market sizing and/or deck review first — those artifacts are imported automatically.

**What you get back:** A simulated IC debate with three distinct partner voices, a conviction score across 28 dimensions, a consensus verdict (invest / more diligence / decline / decline — hard pass), portfolio conflict analysis, and coaching on exactly what to prepare before a real IC meeting.

**Example prompts:**
- "Use the ic-sim skill to simulate an IC discussion for our startup."
- "Use the ic-sim skill — how would partners at a fund like this discuss our company?"
- "I just did market sizing and a deck review — now use the ic-sim skill."

> Technical workflow s
```
