| name | modeling-thinking |
| description | Structured multi-model analysis for complex non-mathematical, non-programming problems. Use when the user explicitly asks to "model", "analyze with models", or "use modeling thinking". Also offer to use this skill (wait for confirmation) when encountering: complex decisions with many interacting factors, strategic planning, social or organizational dynamics, prediction problems in ambiguous domains, or any "what should I do?" that requires reasoning through system-level effects.
Do NOT invoke for mathematical (e.g., "solve this equation") or programming tasks — those are already well-served without this skill. For borderline cases (e.g., a life decision that might not need modeling), ask the user first.
Never invoke silently. If you think this skill applies, say: "This seems like a good candidate for structured modeling — want me to approach it that way?"
|
Language
All outputs — including model files, any files saved to disk, and communication with the user — must be written in the same language the user is using. If the user writes in Chinese, write in Chinese. If in English, write in English. Internal reasoning can be in any language, but everything saved to disk and shown to the user must match the user's language.
What this skill does
You build several independent models of the user's problem, reason through each rigorously, then converge on a single best answer. The process has two rounds:
Round 1: Build initial models → discover what information is missing → ask the user targeted questions
Round 2: Incorporate the user's answers → refine models → give the final answer
The goal is not to "cover all perspectives." The goal is to find the model that most efficiently explains the problem and gives the user a concrete, actionable answer.
When to use sub-agents vs. sequential modeling
If you have sub-agent capability:
- Tell the user the default is 3 parallel modeling agents, and ask if they want more or fewer (range: 2–5)
- Spawn all modeling agents in parallel in Round 1, each assigned a distinct modeling lens
- Each agent saves its output as a Markdown file in a local session folder
If you don't have sub-agents:
- Plan N approaches (default 3) before starting any of them
- Execute one at a time, saving each to a Markdown file
- Synthesize after all are done
Step 1: Problem framing
Before picking model types, identify:
- The decision or question: What is the user trying to figure out?
- The key uncertainty: What's the thing they don't know that matters most?
- The relevant variables: What can change? What's fixed?
- The time horizon and stakes: Short-term vs. long-term? Reversible vs. irreversible?
Save a problem_framing.md to the session folder immediately. This becomes the shared reference across all models.
Step 2: Choose modeling lenses
Assign each modeling slot a distinct lens. Prioritize lenses that can be made mathematical or semi-formal, because formalization forces precision and reveals hidden assumptions.
Strongly prefer (in order):
- Optimization / objective function (what is being maximized/minimized, under what constraints?)
- Probabilistic / Bayesian (uncertain variables, priors, evidence updates)
- Game theory / strategic interaction (players, incentives, equilibrium)
- Dynamical systems / feedback loops (how variables change each other over time)
- Causal DAG (what causes what, confounders, which levers actually work)
- Expected value / decision tree (branches, probabilities, payoffs)
- Network / graph (nodes, edges, flows)
Use qualitative models when necessary:
- Agent-based thinking (actors following local rules)
- Narrative / counterfactual (what would have to be true for outcome X?)
Each model should commit to one lens and build it out — not hedge between multiple frameworks.
Step 3: Round 1 — build initial models and save everything
For each model:
-
State the model explicitly: Write out variables, relationships, and assumptions. Write equations or probability distributions where possible.
-
Derive something non-obvious: Don't just describe — compute or reason forward. What does this model predict? What would have to be true for the opposite conclusion?
-
Identify critical missing information: After building the model, note which inputs or parameters you had to assume because you don't know them — and whether the conclusion would change if those assumptions were wrong. These are the "load-bearing unknowns."
-
Save to a Markdown file: model_1_<lens>.md in the session folder. Include: the model, key derivations, preliminary conclusion, blind spots, and most importantly — what you needed to assume that you wish you knew.
Save all work immediately as you go. Don't wait until the end. The files are working memory — if anything is lost, the reasoning can be reconstructed from them.
Step 4: Identify critical questions and ask the user
After all initial models are built, review the load-bearing unknowns across all models. Find the 2–4 questions whose answers would most change the conclusion — not questions you're merely curious about, but questions where the answer genuinely shifts which model wins or what the winning model recommends.
Surface these questions to the user clearly. Explain briefly why each question matters (one sentence each). Don't ask more than 4 questions — if you have more, prioritize by impact on the conclusion.
Save the questions to questions.md in the session folder before asking the user, so there's a record.
Example format:
在给出最终分析之前，有几个关键信息会显著影响结论，请帮我确认：
- [问题] — 原因：如果[A]，结论偏向X；如果[B]，结论偏向Y。
- [问题] — 原因：这直接影响[模型名]的核心参数估计。
Step 5: Round 2 — refine with new information and deliver final answer
Once the user answers, update the models. You don't need to rebuild from scratch — update the relevant parameters, re-run the key derivations, and note where the user's answers changed the model outputs vs. where they confirmed your original assumptions.
Save updates to model_<N>_<lens>_updated.md (or annotate the original files with a clearly marked "Update" section).
Then:
Select the best model using an MDL-inspired criterion: the best model is the one where (model complexity + residuals) is minimized. Intuitively:
- A model that explains most of what matters with few assumptions beats a complex model that explains slightly more
- "Residuals" = how much of the key dynamics does this model fail to account for?
- If the model's conclusion would reverse with a small change to its assumptions, that's high residual uncertainty
- Prefer models that make contact with the user's actual decision
Write the final answer to final_answer.md:
- Which model you chose and why it beats the others (MDL reasoning)
- A concrete conclusion or recommendation — not a hedge
- The most important thing the winning model still misses
- Written as a direct answer, not a literature review
File organization
modeling_session_<topic>/
├── problem_framing.md ← saved immediately in Step 1
├── questions.md ← saved before asking user in Step 4
├── model_1_<lens>.md ← Round 1
├── model_2_<lens>.md
├── model_3_<lens>.md
├── model_1_<lens>_updated.md ← Round 2 (or update sections in originals)
├── model_2_<lens>_updated.md
├── model_3_<lens>_updated.md
└── final_answer.md
Save aggressively. Every time you finish a model, write it to disk before moving to the next. Every time the user provides information, save the updated model before continuing. The files are the single source of truth — not your context window.
Tone and communication
- Be direct. Don't add complexity with hedged, both-sides language.
- When asking questions in Step 4, be specific — not "tell me more about the company" but "what percentage equity are you being offered, and has it been written into a formal offer?"
- When you pick a winning model, explain why in plain terms.
- The final answer should feel like a conclusion, not a literature review.
