Ic Sim

IC Simulation Skill

Help startup founders prepare for the conversation that happens behind closed doors — the one where VC partners debate whether to invest. Produce a realistic IC simulation with three distinct partner perspectives, scored across 28 dimensions, with specific coaching on what to prepare. The tone is founder-first: a coaching tool for preparation, not a judgment.

Skill Metadata

• Author: lool-ventures
• Version: managed in founder-skills/.claude-plugin/plugin.json
• Compatibility: Python 3.10+ and uv for script execution.
• Imports (recommended):
• market-sizing:sizing.json — fund alignment and market validation
• deck-review:checklist.json — deck quality assessment
• Exports:
• report.json → fundraise-readiness, dd-readiness

Skill Execution Model (READ FIRST)

This skill runs inline in the main thread (not as a sub-agent). The main thread has full tool access including Bash, and is responsible for orchestrating the full pipeline: running producer scripts, persisting artifacts, and dispatching the ic-sim sub-agent at specific moments.

Two dispatch contexts for the sub-agent:

• Context A — Per-step analytical dispatch (Mitigation 1): Steps 4, 5, and 6 dispatch the ic-sim agent via the Task tool. The novel element here is parallel dispatch: Step 4 (PARTNERANALYSIS) dispatches the agent three times simultaneously — one per partner archetype — in a single assistant turn. Steps 5 and 6 (SCOREDIMENSIONS and DETECT_CONFLICTS) are sequential dispatches. The sub-agent does deep analysis and returns structured JSON. The main thread captures the JSON and pipes it through the producer script. The sub-agent does NOT write artifacts directly.
• Context B — Post-compose coaching dispatch: The final step dispatches the sub-agent after compose_report.py writes report.md. The sub-agent reads report.md, appends ## Coaching Commentary, verifies all canonical artifacts on disk, and returns a structured success payload.

Why this model: In Cowork, sub-agents have a restricted tool allowlist (no Bash). By keeping orchestration in the main thread and dispatching sub-agents only for analytical or post-compose tasks that use only Read/Edit/Glob/Grep, the pipeline works correctly in both Claude Code (CLI) and Cowork.

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."

> 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).

Input Formats

Accept any combination: pitch deck, financial model, data room contents, text descriptions, prior market-sizing or deck-review artifacts, or just a verbal description of the business.

Available Scripts

All scripts are at ${CLAUDE_PLUGIN_ROOT}/skills/ic-sim/scripts/:

• fund_profile.py — Validates fund profile structure (archetypes, check size, thesis, portfolio)
• detect_conflicts.py — Validates conflict assessments and computes summary stats
• score_dimensions.py — Scores 28 dimensions across 7 categories with conviction-based scoring
• compose_report.py — Assembles report with cross-artifact validation; --strict exits 1 on high/medium warnings
• visualize.py — Generates self-contained HTML with SVG charts (not JSON)

Also available from ${CLAUDE_PLUGIN_ROOT}/scripts/ (shared):

• founder_context.py — Per-company context management (init/read/merge/validate)

Run with: python3 ${CLAUDE_PLUGIN_ROOT}/skills/ic-sim/scripts/.py --pretty [args]

Available References

Read each when first needed — do NOT load all upfront. At ${CLAUDE_PLUGIN_ROOT}/skills/ic-sim/references/:

• partner-archetypes.md — Read before Step 4. Three canonical archetypes with focus areas, debate styles, red flags
• evaluation-criteria.md — Read before Step 5. 28 dimensions across 7 categories with stage-calibrated thresholds
• ic-dynamics.md — Read before composing discussion.json. How real VC ICs work: formats, decisions, what kills deals
• artifact-schemas.md — Consult as needed when depositing agent-written artifacts

Artifact Pipeline

Every simulation deposits structured JSON artifacts into a working directory. The final step assembles all artifacts into a report and validates consistency. This is not optional.

| Step | Artifact | Producer | |------|----------|----------| | 1 | founder context | founder_context.py read/init | | 2 | startup_profile.json | Agent (heredoc) | | 3 | prior_artifacts.json | Agent (heredoc) | | 4 | fund_profile.json | Agent (heredoc) then fund_profile.py validates | | 5a | conflict_check.json | Context A dispatch: DETECTCONFLICTS → detect_conflicts.py | | 5b-d | partner_assessment_{visionary,operator,analyst}.json | Context A dispatch: PARTNERANALYSIS × 3 in parallel | | 6 | discussion.json | Main thread combines 3 partner returns | | 7 | score_dimensions.json | Context A dispatch: SCOREDIMENSIONS → score_dimensions.py | | 8 | Report | compose_report.py (writes both report.json and report.md) | | 9 | Coaching | Context B dispatch: POSTCOMPOSE_COACHING |

Rules:

• Deposit each artifact before proceeding to the next step
• For agent-written artifacts, consult references/artifact-schemas.md for the JSON schema
• If a step is not applicable, deposit a stub: {"skipped": true, "reason": "..."}
• Do NOT use isolation: "worktree" for sub-agents — files written in a worktree won't appear in the main $SIM_DIR

Keep the founder informed with brief, plain-language updates at each step. Never mention file names, scripts, or JSON. After each analytical step (5–7), share a one-sentence finding before moving on.

Workflow

Step 0: Path Setup

Every Bash tool call runs in a fresh shell — variables do not persist. Prefix every Bash call that uses these paths with the variable block below, or substitute absolute paths directly:

SCRIPTS="${CLAUDE_PLUGIN_ROOT}/skills/ic-sim/scripts"
REFS="${CLAUDE_PLUGIN_ROOT}/skills/ic-sim/references"
SHARED_SCRIPTS="${CLAUDE_PLUGIN_ROOT}/scripts"
if ls "$(pwd)"/mnt/*/ >/dev/null 2>&1; then
  ARTIFACTS_ROOT="$(ls -d "$(pwd)"/mnt/*/ | head -1)artifacts"
elif ls "$(pwd)"/sessions/*/mnt/*/ >/dev/null 2>&1; then
  ARTIFACTS_ROOT="$(ls -d "$(pwd)"/sessions/*/mnt/*/ | head -1)artifacts"
else
  ARTIFACTS_ROOT="$(pwd)/artifacts"
fi

If CLAUDE_PLUGIN_ROOT is empty OR the path it resolves to does not exist in your environment (in Claude Cowork it substitutes to a host-side path that is not present inside the session VM — test with ls), fall back: Glob for **/skills/ic-sim/scripts/score_dimensions.py, strip to get SCRIPTS, derive REFS and SHARED_SCRIPTS. In Claude Cowork this is always the case — don't retry the substituted path; go straight to the Glob fallback. If Glob returns multiple matches, prefer the one under a plugin mount (.remote-plugins/ or the plugins cache) over any workspace copy. If Glob returns nothing, locate it with Bash: find / -path '*/skills/ic-sim/scripts/score_dimensions.py' 2>/dev/null | head -5.

If ARTIFACTS_ROOT resolves to $(pwd)/artifacts but no artifacts/ directory exists at $(pwd): Use Glob with pattern **/artifacts/founder_context.json to locate existing artifacts, and derive ARTIFACTS_ROOT from the result. If nothing is found, mkdir -p "$ARTIFACTS_ROOT" and proceed.

After Step 1 (when the slug is known):

SIM_DIR="$ARTIFACTS_ROOT/ic-sim-${SLUG}"
mkdir -p "$SIM_DIR"
mkdir -p "$SIM_DIR/.staging"   # for ad-hoc sub-agent JSON staging
RUN_ID="$(date -u +%Y%m%dT%H%M%SZ)"

Pass RUN_ID to all sub-agents. Every artifact written to $SIM_DIR must include "metadata": {"run_id": "$RUN_ID"} at the top level. compose_report.py checks that all artifact run IDs match — a mismatch triggers a STALE_ARTIFACT high-severity warning, blocking under --strict.

If SIM_DIR already contains artifacts from a previous run, remove them before starting:

rm -f "$SIMDIR"/{startupprofile,priorartifacts,fundprofile,conflictcheck,discussion,scoredimensions,partnerassessmentvisionary,partnerassessmentoperator,partnerassessmentanalyst,report}.json "$SIM_DIR"/report.{html,md}

In Cowork, file deletion may require explicit permission. If cleanup fails with "Operation not permitted", request delete permission and retry before proceeding.

Step 1: Read or Create Founder Context

python3 "$SHARED_SCRIPTS/founder_context.py" read --artifacts-root "$ARTIFACTS_ROOT" --pretty

Exit 0 (found): Use the company slug and pre-filled fields. Proceed to Step 2.

Exit 1 (not found): This is normal for a first run — do not treat it as an error. Use AskUserQuestion (NOT plain chat) to ask for company name, stage, sector, and geography. Provide at least 2 options. Then create:

python3 "$SHARED_SCRIPTS/founder_context.py" init \
  --company-name "Acme Corp" --stage seed --sector "B2B SaaS" \
  --geography "US" --artifacts-root "$ARTIFACTS_ROOT"

Exit 2 (multiple): Present the list, ask which company, re-read with --slug.

Mode Selection

Ask the user (or infer from context):

1. Interactive — Pause between partner positions for founder input
2. Auto-pilot — Run all sections without pausing
3. Fund-specific — Research a real fund first. Combines with either mode.

Steps 2-3: Extract Startup Profile and Import Prior Artifacts

Read the provided materials and extract the startup profile directly. Import any prior market-sizing or deck-review artifacts from $ARTIFACTS_ROOT. Deposit both artifacts to $SIM_DIR.

Read $REFS/artifact-schemas.md before writing artifacts to ensure JSON schema compliance.

Write startup_profile.json:

cat  "$SIM_DIR/startup_profile.json"
{
  "company_name": "...",
  "simulation_date": "YYYY-MM-DD",
  "stage": "seed",
  "one_liner": "...",
  "sector": "...",
  "geography": "...",
  "business_model": "...",
  "funding_history": "...",
  "current_raise": "...",
  "key_metrics": "...",
  "materials_provided": ["..."],
  "metadata": {"run_id": ""}
}
PROFILE_EOF

Write prior_artifacts.json (stub if no prior artifacts):

cat  "$SIM_DIR/prior_artifacts.json"
{"imported": [], "skipped": [], "reason": "No prior artifacts available", "metadata": {"run_id": ""}}
PRIOR_EOF

Step 4: Build Fund Profile -> fund_profile.json

REQUIRED — read $REFS/partner-archetypes.md now.

Generic mode: Build a standard early-stage fund profile with the three canonical archetypes (visionary, operator, analyst).

Fund-specific mode: Use WebSearch to research fund thesis, portfolio, partner backgrounds, check size range, and stage preference. Map real partners to archetype roles.

Validation constraints: check_size_range must be a dict (not a string), stage_focus must be a non-empty array, each source must have url or title.

cat _input.json` first, then pipe via:

```bash
cat "$SIM_DIR/.staging/_input.json" | python3 "$SCRIPTS/.py" ...

The .staging/ directory is created at setup and removed at cleanup. This avoids Operation not permitted errors that occur when writing to the session outputs mount (Cowork marks it read-only post-write).

Step 5a: Check Portfolio Conflicts -> conflict_check.json (Context A dispatch)

Dispatch the ic-sim sub-agent in Context A (DETECT_CONFLICTS). Dispatch via the Task tool.

Dispatch prompt template:

CONTEXT: DETECT_CONFLICTS
SIM_DIR: 
RUN_ID: 

You are the ic-sim agent dispatched in Context A (DETECT_CONFLICTS).
Read fund_profile.json at /fund_profile.json and startup_profile.json
at /startup_profile.json.

For each company in the fund's portfolio, assess whether it conflicts with the
startup. Assess each company for: direct conflict, adjacent conflict, or
customer overlap. Use consistent names between portfolio and conflicts.

Return JSON only — exactly the shape expected by detect_conflicts.py
(portfolio_size and conflicts array — no metadata block; producer script adds it):
{
  "portfolio_size": ,
  "conflicts": [
    {
      "company": "",
      "type": "direct|adjacent|customer_overlap",
      "severity": "blocking|manageable",
      "rationale": ""
    }
  ]
}

Return empty conflicts array if no conflicts found. portfolio_size must equal
the number of companies in the fund's portfolio.

After the sub-agent returns: apply the tolerant JSON extraction protocol (see "Skill Execution Model" preamble) to obtain the structured JSON. Then pipe through the producer script:

cat 
CONFLICT_EOF

Step 5b-d: Partner Assessments (PARTNER_ANALYSIS × 3 in parallel)

REQUIRED — read $REFS/partner-archetypes.md and $REFS/evaluation-criteria.md now (if not already read).

Parallel dispatch recipe

Dispatch the ic-sim agent THREE TIMES in parallel via the Task tool — one per archetype (visionary, operator, analyst). Use a SINGLE assistant turn with 3 Task tool calls (NOT three sequential turns). The Claude Code harness runs all three Task calls in parallel when they appear in the same assistant response.

Pseudocode for the dispatch (executed as 3 parallel Task tool_use blocks):

[
  Task(description="Partner analysis: visionary",
       prompt="CONTEXT: PARTNER_ANALYSIS\narchetype: visionary\nSIM_DIR: \nRUN_ID: \nfund_profile: \ndeal_context: "),
  Task(description="Partner analysis: operator",
       prompt="CONTEXT: PARTNER_ANALYSIS\narchetype: operator\nSIM_DIR: \nRUN_ID: \nfund_profile: \ndeal_context: "),
  Task(description="Partner analysis: analyst",
       prompt="CONTEXT: PARTNER_ANALYSIS\narchetype: analyst\nSIM_DIR: \nRUN_ID: \nfund_profile: \ndeal_context: "),
]

Full dispatch prompt template (used for each archetype separately, with archetype: changed):

CONTEXT: PARTNER_ANALYSIS
archetype: visionary|operator|analyst
SIM_DIR: 
RUN_ID: 

You are the ic-sim agent dispatched in Context A (PARTNER_ANALYSIS) for the
 archetype. Read:
- ${CLAUDE_PLUGIN_ROOT}/skills/ic-sim/references/partner-archetypes.md
- ${CLAUDE_PLUGIN_ROOT}/skills/ic-sim/references/evaluation-criteria.md
- /startup_profile.json
- /fund_profile.json
- /prior_artifacts.json (if present)

Embody the  partner perspective as defined in partner-archetypes.md.
Evaluate the startup from that specific lens. Every conviction point and concern
must be grounded in specific evidence from the startup materials.

Return JSON only — the partner assessment object (no metadata block):
{
  "partner": "",
  "verdict": "invest|more_diligence|pass|hard_pass",
  "rationale": "",
  "conviction_points": ["", ...],
  "key_concerns": ["", ...],
  "questions_for_founders": ["", ...],
  "diligence_requirements": ["", ...]
}

After all three sub-agents return: apply the tolerant JSON extraction protocol to each of the three returned messages. Write each partner's assessment directly:

# Write partner_assessment_visionary.json (insert the extracted JSON, adding metadata)
cat 
VISIONARY_EOF

# Repeat for operator and analyst

Or more concisely

…

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: lool-ventures
• Source: lool-ventures/founder-skills
• License: Apache-2.0

Install and usage instructions live in the source repository linked above.