Full SKILL.md

Financial Modeling

name: financial-modeling description: Builds live, downloadable Excel (.xlsx) financial models from scratch — valuation, deal/banking, private-equity returns, strategy/market, and analysis tools — with multi-tab structure, live formulas, built-in checks, and a recalc-and-verify pass. Use whenever someone wants a model built as a spreadsheet they can open and edit: DCF, trading or transaction comps, DDM, sum-of-the-parts, football field, three-statement, LBO, debt schedule, accretion/dilution, sources & uses, credit stats and covenants, LP/GP waterfall, value-creation bridge, management incentive plan, fund J-curve, IRR/MOIC, dividend recap, market sizing (TAM/SAM/SOM), revenue build, unit economics (LTV/CAC), pricing/elasticity, sensitivity tables, scenario toggles, or Monte Carlo — even if they don't name the model precisely (e.g. "value this company", "size this market", "what returns does this deal make", "show the downside"). Do NOT trigger for editing an existing workbook through the Claude for Excel sidebar add-in; this skill builds a new file with openpyxl.

A reusable engine for building strategy, investment-banking, and private-equity models as live .xlsx files in the Claude app. This file is the spine: it carries the shared build method, the cell and formatting conventions, the recalc-and-verify discipline, and a map to 25 model recipes. Load a reference file only when the task touches that family — do not pull them all in at once.

Scope and boundary

  • What this builds: a brand-new spreadsheet from scratch using openpyxl (and numpy/pandas where a recipe needs them), with live formulas, multiple tabs, and built-in checks. The model is built in the code tool, recalculated headlessly, verified error-free, then delivered as a downloadable file.
  • What this is NOT: the "Claude for Excel" sidebar add-in that edits a workbook open inside Excel. No add-in, plugin, or Microsoft 365 connection is required or used. If the user wants edits to an existing open workbook, this skill does not apply.

How to use this skill

  1. Identify which model the user needs (use the catalog below; match intent, not just the literal model name).
  2. Load the one reference file for that family. It gives the tab structure, the distinctive formulas, the model-specific checks, the inputs to gather, and a worked example.
  3. Read references/build-engine.md once per build for the shared mechanics — cell conventions, named ranges, scenario toggle, circularity handling, the openpyxl build steps, and the recalc-and-verify loop. Every model relies on it; the family references do not repeat it.
  4. Gather the inputs the recipe lists. If the user has not supplied them, ask, or build with clearly-labelled illustrative placeholders and say so.
  5. Build, recalculate headlessly, verify zero formula errors and all checks PASS, then deliver. Run the final QA gate before treating the file as done.

Model catalog and reference map

Load the file that matches the model. Each reference covers six related models.

Several models compose: a football field consumes the low/high outputs of the DCF, comps, precedent, and LBO models; sensitivity, scenario manager, and Monte Carlo attach to any model with a live output cell; the credit stats and value-creation bridge can link to a live LBO or three-statement model.

A

Valuation

  1. Valuation Models

    1,387 w

    Load when **Valuation**.

    references/valuation.md6 sub-sections
B

Deal & banking

  1. Deal & Banking Models

    1,509 w

    Load when **Deal & banking**.

    references/deal-and-banking.md6 sub-sections
C

PE & returns

  1. Private Equity & Returns Models

    1,635 w

    Load when **PE & returns**.

    references/pe-and-returns.md6 sub-sections
D

Strategy & market

  1. Strategy & Market Models

    1,064 w

    Load when **Strategy & market**.

    references/strategy-and-market.md4 sub-sections
E

Analysis & decision

  1. Analysis & Decision Tools

    1,183 w

    Load when **Analysis & decision**.

    references/analysis-and-decision.md3 sub-sections

  2. Build Engine — shared mechanics for every model

    1,133 w

    Load when **Shared build mechanics** (always).

    references/build-engine.md12 sub-sections

The shared method (every model)

These hold for all 25 recipes. Full detail is in references/build-engine.md.

  • One workbook, several tabs, in order. Inputs live only on an Assumptions (or Inputs/Drivers) tab; calculation tabs read from it; an Outputs/Summary tab carries the answer; a Checks tab carries the tie-outs. A Cover tab states purpose, the colour legend, and any toggle.
  • Cell colour convention. Blue font = hardcoded input. Black = formula computed within a tab. Green = link pulling from another tab. Reviewers read the model's wiring from the colours.
  • No hardcoded constants inside formulas. Every assumption is its own labelled input cell and is referenced, ideally through a named range, so the model re-solves when any input changes.
  • One consistent formula per row, filled across all period columns so it copies cleanly and is auditable.
  • Scenario toggle where the model has cases: a single selector cell drives CHOOSE/INDEX pulls of the active Base/Bull/Bear column.
  • Live formulas, never pasted values. openpyxl writes formula text but does not compute it, so cells are blank until recalculated.
  • Recalc-and-verify loop. After writing, recalculate headlessly (e.g. LibreOffice --headless --convert-to xlsx) so cached values and charts populate, then scan every cell for #REF!, #DIV/0!, #VALUE!, #NAME?. Fix and recalculate in a loop until zero errors and every check passes, then deliver.
  • Number formats are consistent: $mm with negatives in parentheses (#,##0;(#,##0)), multiples as 0.0"x", percentages to one decimal (0.0%), discount factors 0.000, per-share to two decimals where relevant.
  • Circularity (interest ↔ cash ↔ debt) is broken with a circuit-breaker toggle (interest on beginning balance) for a clean first calc, or by enabling iterative calculation when averaging balances. Document the choice on the Cover.

Final QA gate

Before treating a model as finished, confirm:

  1. Inputs isolated — every assumption is a blue input cell on the Assumptions tab; no constant is buried in a formula.
  2. Wiring correct — blue/black/green colours match how each cell is actually populated; cross-tab links resolve.
  3. The model's identity holds — the structural tie-out for that model is exactly zero (balance sheet balances; Sources = Uses; tiers sum to distributions; effects sum to the equity change; TAM ≥ SAM ≥ SOM; etc.).
  4. Checks tab all PASS — and the master flag reads PASS.
  5. Zero formula errors after a real recalculation (not just openpyxl writing the text).
  6. Returns sanity where relevant — net ≤ gross; MOIC > 0; XIRR converged with a supplied guess.
  7. Illustrative numbers flagged — any example figures are labelled hypothetical; no invented benchmarks, sources, or real company names.

Note on origin and reuse

Consolidated from a 25-skill Excel-modeling pack. The recipes are sector-agnostic but lean on IB/PE conventions. Example numbers throughout are illustrative only.