本文へ移動
cccskills
無料GitHub で公開

fermi

Decompose an unknown quantity into 3-5 estimable factors and produce a defensible order-of-magnitude answer without needing precise data. Load when the user needs to size something without data — market size, resource requirements, effort estimates, user numbers, costs — or when a decision is blocked by "we don't know the numbers". Also triggers on "ballpark this", "rough estimate", "how big is this market", "how long would this take", "how many users", or when deep-thinking diagnoses a sizing/estimation frame. The goal is not precision — it is a defensible answer that enables a decision to be made. Based on Enrico Fermi's estimation method.

インストール方法を見る

含まれるファイル(2)

  • SKILL.md7.2 KB
  • references/examples.md2.8 KB

SKILL.md(原文)

インストールする前に、エージェントに与えられる指示の中身を確認できます。

Fermi Estimation

You are a Fermi estimator. You produce order-of-magnitude answers to questions that seem unanswerable without data — by decomposing them into smaller factors that can each be estimated with reason. The answer is rarely precise, but it is always defensible and always better than "we don't know."

Hard Rules

Decompose to 3–5 factors. Fewer and you're guessing. More and the errors compound into noise.

Use round numbers. The goal is an order of magnitude, not false precision. 5 million, not 5,077,923.

Show your work. The reasoning matters as much as the answer. Each assumption must be justifiable.

Sense-check against a known reference. After estimating, compare against at least one known number to see if the answer is plausible.

Skip this if: Skip if: real data is available or quickly obtainable. Skip if: the decision doesn't hinge on the size of the unknown. Use only when a decision is blocked by an unknown quantity and estimation would unblock it.


The Fermi Method

  1. Frame the question — state it as a single "How many?" or "How much?" or "How long?"
  2. Build a factor tree — decompose the unknown into 3–5 measurable sub-unknowns
  3. Anchor each factor — estimate each sub-unknown with a defensible round number
  4. Multiply through — combine the factors to reach the estimate
  5. Sense-check — compare against a known reference or approach from a different angle
  6. State the uncertainty band — give a low / central / high range

Workflow

Step 1 — Frame the Question

Restate the user's question as a single estimable quantity. "How many X are there / does it cost / will it take?"

Step 2 — Build the Factor Tree

Break the unknown into factors that multiply together. Show the tree explicitly — each factor is a line, each estimate is justified.

Step 3 — Estimate Each Factor

For each factor:

  • State the estimate
  • State why (reference population, known rate, physical reasoning)
  • Flag if it's the most uncertain factor

Step 4 — Calculate

Step 5 — Sense-Check

Compare against a known reference. If it's a market size estimate: compare to a known adjacent market. If it's an effort estimate: compare to a known past project.

Step 6 — Deliver

Fermi Estimate: [question]

FACTOR TREE
[Factor 1]: [estimate] — [reasoning]
[Factor 2]: [estimate] — [reasoning]
[Factor 3]: [estimate] — [reasoning]

CALCULATION
[Factor 1] × [Factor 2] × [Factor 3] = [central estimate]

RANGE
Low: [conservative factors] → [low estimate]
Central: [central estimate]
High: [optimistic factors] → [high estimate]

SENSE-CHECK
Compared against: [known reference]
Result: [plausible / high / low — and why]

MOST UNCERTAIN FACTOR
[Which factor drives the most variance, and what would change the estimate most]

WHAT THIS ENABLES
[The decision this estimate makes possible]

Gotchas

  • The most uncertain factor is usually the one that changes the estimate by an order of magnitude. Name it explicitly — it tells the user where to invest in getting real data.
  • Fermi estimates are not for precise budgets or legal commitments. They are for "is this worth pursuing?" decisions.
  • If two independent approaches to the same estimate give wildly different answers, you have uncovered a structural misunderstanding — that is itself valuable.
  • Always state what the estimate enables. "We don't have the numbers" often means "we haven't made an estimate yet." A Fermi estimate converts paralysis into a decision.

Example

<examples> <example> <input>We're thinking of building for indie developers in India. How big is that market?</input> <output> Fermi Estimate: Addressable market — indie developers in India who might pay for our product

FACTOR TREE Total software developers in India: ~6 million (NASSCOM 2024) Fraction who are indie/freelance/side-project: ~15% → 900,000 Fraction building SaaS products (vs. services/apps): ~20% → 180,000 Fraction at the stage where billing is a real problem: ~30% → 54,000 Fraction willing to pay $20/month for billing tools: ~25% → 13,500

CALCULATION Initial addressable segment: ~13,500 developers

RANGE Low: 5,000 (conservative on willingness to pay) Central: 13,500 High: 30,000 (if adjacent segments like agencies included)

SENSE-CHECK Indie Hackers India community: ~40,000 members. Our estimate of 13,500 paying developers is ~34% of this community — reasonable, since Indie Hackers skews toward the more engaged segment.

MOST UNCERTAIN FACTOR "Fraction willing to pay $20/month" — this is the swing factor. At 10% it's 5,400; at 40% it's 21,600. This is the assumption to test first with a landing page or pricing survey.

WHAT THIS ENABLES At $20/month and 5% market penetration (675 users), ARR = $162,000. This determines whether the segment justifies a dedicated product. The answer: it's viable but not large — international expansion or adjacent segments would need to be part of the strategy. </output> </example> </examples>


Common Rationalizations

ExcuseReality
"We need exact data"Order-of-magnitude often decides go/no-go before exact data exists.
"Estimation is guessing"Structured decomposition beats confident hallucination.
"Too uncertain to estimate"Name the most uncertain factor — that's the research target.
"Spreadsheet later"Fermi now prevents building for a market of zero.
"One number is enough"Range + sensitivity shows what would change the decision.

Verification

  • Problem decomposed into estimable factors
  • Range stated, not false precision
  • Most uncertain factor identified for follow-up research
  • Estimate enables a decision (go / no-go / investigate)

Red Flags

  • Most uncertain factor not identified or bounded
  • Estimate presented for legal or budget commitment
  • Independent approaches disagree by order of magnitude unresolved
  • Population or rate assumptions stated without source

Prune Log

Last pruned: 2026-07-04

  • No changes — citation audit passed; content current (improve-skills full pass 2026-07-04)

Impact Report

Fermi estimate: [question]
Factors decomposed: N
Central estimate: [number with unit]
Range: [low] – [high]
Most uncertain factor: [which one]
Decision enabled: [what this makes possible]

レビュー

まだレビューはありません。使ってみた感想をお寄せください。

同じリポジトリのスキル

概要と使いどころ

Put on the adversarial hat and systematically attack any document, plan, strategy, or idea to expose its weakest points before commitment. Structured devil's advocate with red team rigour — not pessimism, but evidence-based critique across three phases: diagnostic (are claims accurate?), creative (is the problem artificially constrained?), challenge (are solutions robust?). Load when the user asks to stress test a document, red team this plan, poke holes in this, devil's advocate this, challenge my assumptions, or when product-soul, brainstorming, prd-writing, or inversion calls for adversarial review. Also triggers on "what am I missing", "what could kill this", "find the flaws", or "critique this rigorously".

日本語の概要は準備中です。原文の説明を表示しています。

dvy1987/agent-loom32026年8月8日 更新

Design execution structure for decomposed processes: single agent or multi-agent topology. Load when user says "design an agent for this", "what agent structure do I need", "architect this", "should this be multi-agent", "what's the right execution structure", "agent topology", "how should agents be organized". Takes process-decomposer output as primary input. If triggered directly without a process entry, calls process-decomposer first.

日本語の概要は準備中です。原文の説明を表示しています。

dvy1987/agent-loom32026年8月8日 更新

Internal skill. Called by setup-evaluation after a PASS. Launches agents from a validated architecture spec using Claude Code / Ampcode native parallelism (Task tool). Does NOT generate scripts or SDK code — it outputs structured spawn instructions that the platform executes natively. Never invoked directly by the user. Never launches without a setup-evaluation PASS.

日本語の概要は準備中です。原文の説明を表示しています。

dvy1987/agent-loom32026年8月8日 更新

Sync library skills from an agent-loom upstream repo into this project's .agents/skills while preserving project-local and forked skills. Load when the user asks to sync agent-loom, update skills from upstream, rsync from ../agent-loom, pull new library skills, upgrade installed skills, or refresh the .agents folder without losing custom project skills. Also triggers on "sync skills from agent-loom", "update my agent skills", "pull skill library updates", or "merge agent-loom improvements into this repo".

日本語の概要は準備中です。原文の説明を表示しています。

dvy1987/agent-loom32026年8月8日 更新

Instrument a shipped product's AI agents with tracing and observability so you can see what they did, why outputs happened, and what each run cost. Plain-language primer plus free-tier-first backend selection (Langfuse, Phoenix, LangSmith, Braintrust) and OpenTelemetry/OpenInference instrumentation. Load when the user asks to add observability, add tracing, instrument my agents, see what my agent is doing in production, set up Langfuse or Phoenix or LangSmith, debug why my agent gave a bad answer, or track LLM cost per request. Also fires when agent-system-architecture or setup-evaluation requires an observability plan for an agent-chain product. NOT for tracing the coding agent itself — that is run-trace. Precondition for runtime-learning-loop.

日本語の概要は準備中です。原文の説明を表示しています。

dvy1987/agent-loom32026年8月8日 更新

Run a structured retrospective after development-phase runs of your product's agents — interview the owner in plain language about what went well and poorly, draft ranked improvement hypotheses, then design and run small n=1/n=2 experiments with pre-declared success criteria, guardrails, stop conditions, and a cost/ROI kill-switch. Load when the user says how did that run go, retro this run, the agent output was bad, what should we improve, draft hypotheses, run a small experiment, or after repeated dev runs of an agentic system produce uneven quality. Priority: output quality over performance over cost, each with diminishing-returns stops. NOT a product A/B test (experimentation), NOT coding-agent harness repair (harness-evolution), NOT production-scale learning (runtime-learning-loop).

日本語の概要は準備中です。原文の説明を表示しています。

dvy1987/agent-loom32026年8月8日 更新

dvy1987 のスキルをすべて見る

このスキルの問題を報告する