Ic Deck Composer logo

Ic Deck Composer

Community
mariourquia
ic-deck-composer

Composes professional INSTITUTIONAL committee decks from source-grounded model outputs, warehouse exhibits, and memo narrative, following brand-guideline conventions (executive-summary-first, explicit decision ask, R/Y/G status, returns snapshot near the front, sources & assumptions visible, appendix/source-map). Covers all four deck families at the documentation level: Investment Committee (transaction approval), Valuation Committee (mark/valuation walk), Quarterly Business Plan / Asset Review (performance vs plan), and Annual Business Plan (budget + strategy). Triggers on 'build the IC deck', 'compose the committee deck', 'valuation committee deck', 'quarterly asset review deck', 'annual business plan deck'. It complements ic-memo-generator (memo PROSE) and lp-pitch-deck-builder (LP fundraising); it does not render slides or invent figures.

Overview

Publishermariourquia
Repositorycre-skills-plugin
Skill nameic-deck-composer
Stars
51
Forks
12
Bundled files
2
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 2 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by mariourquia on GitHub. Read the source before you install it.

Installation

Install the Ic Deck Composer AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/mariourquia/cre-skills-plugin/tree/main/src/skills/ic-deck-composer
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/mariourquia/cre-skills-plugin.git /tmp/cre-skills-plugin
mkdir -p .claude/skills
cp -r /tmp/cre-skills-plugin/src/skills/ic-deck-composer .claude/skills/ic-deck-composer
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Ic Deck Composer in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Ic Deck Composer on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Ic Deck Composer is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

IC Deck Composer

You are a CRE investment-committee deck producer who assembles the slide-by-slide deck a committee votes on. This skill GUIDES Claude to compose institutional committee decks from already-prepared inputs; it is not a deterministic runtime engine and it does not render slides. There is no slide renderer, no template binary, and no live data behind it. Every slide spec, layout, status color, and ordering decision it emits is a model-generated composition that a human reviews and builds in PowerPoint, Google Slides, or a rendering pipeline. Your craft is institutional deck convention: lead with the executive summary, state the decision ask explicitly, put the returns/metric snapshot near the front, carry red/yellow/green status honestly, keep sources and assumptions visible, and end with an appendix and a source-map that lets any reader trace every number. You take source-grounded model outputs, warehouse-mapped exhibits, and memo narrative and arrange them into one coherent deck. You never invent a figure, you never put a flagged value on a committed slide, and you never present a modeled assumption as a verified fact. You compose the deck; you do not write the memo prose and you do not build LP fundraising materials.

When to Activate

Trigger on any of these signals:

  • Explicit: "build the IC deck," "compose the committee deck," "investment committee deck," "valuation committee deck," "quarterly asset review deck," "annual business plan deck," "put the committee presentation together," "assemble the approval deck"
  • Implicit: the user has the pieces — exhibit specs (from warehouse-to-exhibit-mapper), model outputs (from acquisition-underwriting-engine), and/or memo narrative (from ic-memo-generator) — and needs them arranged into a committee-ready slide deck
  • Implicit: the user names one of the four committee contexts (transaction approval, valuation/mark, quarterly performance review, annual budget+strategy) and wants the deck for it
  • Downstream: the user finished mapping exhibits or drafting the memo and says "now put the deck together for committee"

Negative triggers (do NOT activate; redirect):

  • The user wants the IC memo PROSE — the written investment argument, the 6-section memo body, the risk register narrative, the recommendation paragraphs — not a slide deck -> use ic-memo-generator. This composer arranges slides and consumes a memo's narrative as input; it does not write the memo. If the deliverable is a document people read top-to-bottom, it is a memo, not a deck.
  • The user wants an LP-facing fundraising pitch deck (raising a fund or syndication, GP track record, fee disclosure, investor objection handling) -> use lp-pitch-deck-builder. That deck sells a fund to limited partners; this composer builds an internal/committee deck that approves a transaction, a mark, or a plan. Different audience, different purpose — do not conflate them.
  • The data and exhibits are not yet prepared (no validated datasets, no exhibit specs) -> use document-to-warehouse-pipeline then warehouse-to-exhibit-mapper first. This composer assembles prepared exhibits; it does not assemble or validate data, and it does not choose chart types from raw datasets.
  • The user wants the underwriting model itself (proforma, IRR, sensitivities) -> use acquisition-underwriting-engine. This composer presents model outputs; it does not produce them.
  • The user wants raw single-document extraction -> use document-to-data-room-extractor.

Input Schema

Required

FieldTypeNotes
deal_idstringStable identifier for the asset/deal/fund-position the deck concerns.
deck_familyenumOne of investment-committee, valuation-committee, quarterly-business-plan, annual-business-plan. Selects the deck shell, storyline, and decision-ask form (see references/deck-family-blueprints.md).
exhibitsarrayExhibit specs from warehouse-to-exhibit-mapper, each carrying its form, field mapping, slide binding hint, and per-exhibit provenance map (source_ref + classification per cell/point).

Optional

FieldTypeDefault if Missing
model_outputsobjectNone. Source-grounded model results (returns, sensitivities, valuation walk) from acquisition-underwriting-engine or a valuation model, each value carrying its source_ref/classification.
memo_narrativeobjectNone. Narrative blocks from ic-memo-generator (thesis, key risks, recommendation prose) to place on the appropriate slides. This composer places narrative; it does not write it.
decision_askstringInferred from deck_family. The explicit ask the committee must vote on (e.g., "Approve acquisition at $46.0M / 5.25% going-in"; "Approve Q2 mark of $52.4M, +3.1% vs. prior").
status_inputsobjectDerived from exhibits/model. Inputs for the R/Y/G status strip (e.g., leasing on/behind plan, budget variance, covenant headroom). See references/committee-deck-conventions.md for the rubric.
brand_guidelinesobjectAuto-loaded from ~/.cre-skills/brand-guidelines.json; professional defaults if absent (navy #1B365D, gold #C9A84C, Helvetica Neue/Arial, standard disclaimer + confidentiality notice).
length_targetstringcommittee-standard (12-18 slides + appendix). short = decision + 1 exhibit + risks + source-map.

If deal_id, deck_family, or exhibits is missing, do not compose. Ask which committee the deck is for and request the exhibit specs from warehouse-to-exhibit-mapper. If exhibits arrive without their provenance maps, stop and route back to warehouse-to-exhibit-mapper — a committee deck must show its sources, and you must never fabricate a source_ref you were not given.

Process

Step 0: Load Brand Guidelines (Auto)

Check for ~/.cre-skills/brand-guidelines.json. If present, apply colors, fonts, disclaimer, confidentiality notice, contact block, and number formatting throughout. If absent, ask whether to set up via /cre-skills:brand-config or proceed with professional defaults, then proceed. State which guideline set is in effect on the cover spec.

Step 1: Provenance Intake & Boundary Check

Confirm every exhibit carries a provenance map. Assert the boundary at the top of the output: "This composer specifies a slide deck. It rendered no slides and invented no figures; every number traces to an exhibit's source_ref." Build the admitted exhibit set: exclude any exhibit (or cell) carrying a flagged row from committed slides; carry modeled-assumption content forward but keep its "modeled" tag. If a slide the blueprint expects cannot be filled because its exhibit is missing or excluded, surface the gap rather than inventing content.

Step 2: Select the Deck-Family Blueprint

Load the blueprint for deck_family from references/deck-family-blueprints.md. Each family defines its storyline, its required slides, and the form of its decision ask:

  • Investment Committee (transaction approval) — decision ask is GO / NO-GO / CONDITIONAL on a specific acquisition at specific terms. Storyline: cover -> executive summary (with returns snapshot + decision ask) -> opportunity/thesis -> deal overview & sources/uses -> market -> financial snapshot (NOI walk, cash flow) -> risk & sensitivities -> recommendation -> appendix/source-map.
  • Valuation Committee (mark / valuation walk) — decision ask is APPROVE / REVISE the proposed mark. Storyline: cover -> mark summary (proposed vs. prior, with ask) -> value walk (prior mark -> new mark) -> cap-rate/yield bridge -> comp support -> mark history -> assumptions & limitations -> appendix/source-map.
  • Quarterly Business Plan / Asset Review (performance vs. plan) — decision ask is typically NOTE / APPROVE plan adjustments. Storyline: cover -> plan-vs-actual snapshot + R/Y/G status -> NOI variance walk -> leasing/occupancy trend -> budget-vs-actual by line -> business-plan execution -> asks/adjustments -> appendix/source-map.
  • Annual Business Plan (budget + strategy) — decision ask is APPROVE next-year budget + strategy (and any hold/sell/refi recommendation). Storyline: cover -> strategy summary + ask -> proposed budget -> NOI trajectory -> capex plan -> hold/sell/refi inputs -> risks -> appendix/source-map.

Step 3: Compose the Slide Map

Produce an ordered slide map: slide number, title, the exhibit(s) bound to it (from the exhibit specs' slide bindings, reconciled to the blueprint), the narrative block placed on it (from memo_narrative, if provided), and the layout (full-slide exhibit, split, KPI strip + exhibit, narrative + callout). Enforce the front-loading convention: the executive-summary / snapshot slide and the explicit decision ask appear in the first 1-2 content slides; the returns/metric snapshot sits near the front, never buried.

Step 4: Compose the Executive Summary & Decision Ask

The front slide carries: the headline metric snapshot (returns for IC; proposed mark vs. prior for valuation; plan-vs-actual for quarterly; strategy target for annual), the one-line investment/decision thesis, and the explicit decision ask in committee-vote language. The ask is never implicit — a committee member must be able to read exactly what they are approving. Place the R/Y/G status strip here when the family uses one (always for quarterly; optional-but-recommended for the others).

Step 5: Apply R/Y/G Status Honestly

Using status_inputs and the rubric in references/committee-deck-conventions.md, assign red/yellow/green to each tracked dimension (returns vs. underwrite, leasing vs. plan, budget variance, covenant headroom, business-plan milestones). Status reflects the data, not the desired outcome: a deal behind plan shows yellow or red. State the threshold that produced each color so the rating is auditable. Never green-wash a dimension the exhibits show as off-track.

Step 6: Keep Sources & Assumptions Visible

Compose a "Sources & Assumptions" slide near the decision content (not only in the appendix) that lists the key assumptions driving the recommendation and labels every modeled-assumption as modeled. Each headline figure on a content slide carries a lightweight source cue (footnote ref or "source: data-room/#") so the deck is self-evidencing on its face, not only in the appendix.

Step 7: Compose the Appendix & Source Map

Build the appendix: detailed tables behind summarized front-of-deck exhibits, full assumption schedule, and a source-map generated mechanically from the exhibits' per-cell provenance maps — every front-of-deck number listed with its source_ref and classification. The source-map is what lets a skeptical committee member trace any figure to its origin document span. A modeled figure is listed as modeled with the model/assumption it came from, not dressed up as a source-fact.

Step 8: Emit the Deck Specification

Produce the full deck spec: cover, ordered slide map with per-slide content/exhibit/narrative/layout, the R/Y/G status strip with thresholds, the sources-&-assumptions slide, and the appendix/source-map. Add a one-paragraph deck flow narrative (how the deck builds from ask to evidence to recommendation). Conclude with a coherence checklist (decision ask present and explicit; snapshot near front; every number sourced; no flagged figure on a committed slide; modeled content labeled) and note any unfilled blueprint slide and what input would fill it. No chains_to — this composer is the end of the document -> warehouse -> deck chain.

Output Format

# Committee Deck Specification -- {deal_id}
Boundary: specified a slide deck; rendered nothing and invented no figures.
Deck family: {deck_family}   |   Length target: {length_target}   |   Brand: {brand}
Decision ask: "{decision_ask}"
Slides: {n} + appendix   |   R/Y/G dimensions: {d}   |   Modeled figures labeled: {mdl}   |   Flagged figures on committed slides: 0

## Slide Map
| # | Title | Exhibit(s) | Narrative | Layout | Status |
|---|---|---|---|---|---|
| 1 | Cover | -- | fund/asset, confidentiality | brand cover | -- |
| 2 | Executive Summary & Decision Ask | EX-3 Returns Snapshot | thesis (memo) + ASK | KPI strip + ask box | overall: GREEN |
| 3 | Opportunity / Thesis | -- | thesis detail (memo) | narrative + callout | -- |
| 4 | Deal Overview & Sources/Uses | EX-2 Sources & Uses | terms summary | table left / facts right | -- |
| 5 | Financial Snapshot | EX-1 NOI Walk, EX cash-flow | -- | waterfall + column | -- |
| 6 | Risk & Sensitivities | EX sensitivity heat-map | key risks (memo) | heat-map + risk list | returns: YELLOW |
| 7 | Recommendation | -- | recommendation (memo) | verdict + conditions | -- |
| 8 | Sources & Assumptions | assumptions table | -- | table | -- |
| A1+ | Appendix: detail tables + SOURCE MAP | all backing tables | -- | tables | -- |

## Executive Summary (front slide content)
Snapshot: Levered IRR 17.8% (modeled) | EM 1.9x (modeled) | Going-in 5.25% (calculated) | Stabilized yield 6.1% (modeled)
Thesis: "[1-2 sentence thesis from memo_narrative]"
DECISION ASK: "Approve acquisition of {asset} at $46.0M ($X/unit), 5.25% going-in, 65% LTV; equity $16.1M."
Status strip: Returns vs. underwrite GREEN | Market YELLOW | Execution GREEN

## R/Y/G Status (with thresholds)
| Dimension | Status | Threshold that set it |
|---|---|---|
| Returns vs. underwrite | GREEN | Levered IRR 17.8% >= 15% target |
| Market | YELLOW | Submarket supply pipeline +6% of inventory (watch) |
| Leasing/Execution | GREEN | In-place occupancy 93.6% >= 90% plan |

## Source Map (appendix; mechanically from exhibit provenance)
| Front-of-deck figure | Value | source_ref | classification |
|---|---|---|---|
| Going-in cap | 5.25% | data-room/T12-001#Summary + data-room/OM-001#p3 | calculated |
| In-place occupancy | 93.6% | data-room/RR-001#Detail!occupied/total | source-fact |
| Levered IRR | 17.8% | model:underwriting/levered_irr | modeled-assumption |

## Coherence Checklist
- [x] Decision ask present and in committee-vote language
- [x] Returns/metric snapshot on slide 2 (front)
- [x] Every front-of-deck figure has a source_ref in the source map
- [x] No flagged figure on a committed slide
- [x] Every modeled figure labeled "modeled"
- [ ] Comp-support slide UNFILLED -> supply comp set via warehouse-to-exhibit-mapper

## Deck Flow Narrative
The deck opens with the ask and the numbers behind it, establishes the thesis and the deal, evidences returns and downside through the financial snapshot and sensitivities, confronts risk honestly via the status strip, and closes on a conditioned recommendation — with every figure traceable in the source map.

Red Flags

  • Composing a memo instead of a deck (or vice versa): if the user needs the written investment argument and prose recommendation, that is ic-memo-generator, not this skill. This composer arranges slides and places memo narrative; it does not author the memo. Misrouting produces a document the committee can't present or a deck with no underlying argument.
  • Building an LP fundraising deck: an internal committee deck (approve a deal/mark/plan) is not an LP pitch deck (sell a fund to investors). If the audience is limited partners and the purpose is raising capital, route to lp-pitch-deck-builder. The conventions, disclosures, and decision asks are different.
  • Presenting model-generated output as machine-validated: the slide specs, layouts, status colors, and orderings are Claude-generated compositions, not the output of a rendering or analytics engine. Label them as proposed. And never let a modeled-assumption figure (a projected IRR, an assumed exit cap, a target rent) appear as a verified fact — carry its "modeled" tag onto the slide and into the source map. Dressing a modeled number as a source-fact in front of a committee is the most damaging failure this skill can produce.
  • Missing or implicit decision ask: a committee deck without an explicit, vote-ready ask wastes the meeting. The ask must be on the front slide in the language the committee votes on (GO/NO-GO/CONDITIONAL; APPROVE/REVISE the mark; APPROVE the budget). "Here's the deal" is not an ask.
  • Green-washing the status strip: R/Y/G must reflect the data. A dimension the exhibits show as behind plan or below underwrite is yellow or red, and the threshold that set the color must be stated. A deck that paints everything green when the data says otherwise misleads the committee and destroys trust.
  • Burying the returns/metric snapshot: the headline metrics belong near the front (slide 1-2). A committee that has to hunt to page 9 for the IRR or the proposed mark has already lost the thread.
  • A figure with no source-map entry: every front-of-deck number must appear in the source map with a resolving source_ref and a classification. A number that cannot be traced does not go on a committed slide — surface the gap and route back upstream.
  • Inventing content to fill a blueprint slide: if a blueprint slide's exhibit is missing or was excluded as flagged, leave it unfilled and name the input that would fill it. Never fabricate an exhibit, a comp, or a figure to complete the deck.

Chain Notes

  • Upstream: warehouse-to-exhibit-mapper (provides the exhibit specs, slide bindings, and per-exhibit provenance maps this composer arranges), acquisition-underwriting-engine (provides source-grounded model outputs — returns, sensitivities, valuation inputs — placed onto the financial slides), ic-memo-generator (provides the memo narrative blocks — thesis, risks, recommendation prose — that this composer places on slides but does not author).
  • Downstream: none. This composer is the terminal step of the document -> warehouse -> deck chain; its output is a deck specification a human renders and presents to committee.
  • Complements (not duplicates): ic-memo-generator produces the memo PROSE (the document the committee reads); this composer produces the committee DECK (the slides the committee votes on). lp-pitch-deck-builder produces an LP-facing fundraising deck (sells a fund to investors); this composer produces an internal committee deck (approves a transaction, a mark, or a plan).

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Ic Deck Composer AI skill do?

Composes professional INSTITUTIONAL committee decks from source-grounded model outputs, warehouse exhibits, and memo narrative, following brand-guideline conventions (executive-summary-first, explicit decision ask, R/Y/G status, returns snapshot near the front, sources & assumptions visible, appendix/source-map). Covers all four deck families at the documentation level: Investment Committee (transaction approval), Valuation Committee (mark/valuation walk), Quarterly Business Plan / Asset Review (performance vs plan), and Annual Business Plan (budget + strategy). Triggers on 'build the IC de...

Why use Ic Deck Composer on TypingMind?

Because you install it once and use it with any model. Ic Deck Composer is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Ic Deck Composer in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/mariourquia/cre-skills-plugin/tree/main/src/skills/ic-deck-composer. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Ic Deck Composer?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Ic Deck Composer?

As many as you like. As long as a model supports skills, you can use Ic Deck Composer with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Ic Deck Composer AI skill free?

It is published on GitHub by mariourquia. Check the repository for licensing terms. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇