.agents/skills/fermi/SKILL.md
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.
npx skillsauth add dvy1987/agent-loom fermiInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
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."
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.
Restate the user's question as a single estimable quantity. "How many X are there / does it cost / will it take?"
Break the unknown into factors that multiply together. Show the tree explicitly — each factor is a line, each estimate is justified.
For each factor:
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.
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]
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>
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]
development
Run a fast, read-only health check across all skills in the library and produce a structured quality report — without modifying anything. Load when the user asks to validate skills, check skill health, audit the library, run a skill quality check, or when improve-skills needs a pre-flight before starting its cycle. Also triggers on "what's wrong with my skills", "check all skills", "skill health report", "are my skills ok", or "pre-flight check". Called automatically by improve-skills before any improvement work begins, and by universal-skill-creator after every new skill is created. Never modifies any file — only reads and reports.
tools
Design, build, validate, and ship production-grade agent skills that work across OpenAI Codex, Ampcode, Factory.ai Droids, Google Gemini, Warp, Bolt.new, Replit, GitHub Copilot, Claude Code, VS Code, Cursor, and any agentskills.io compliant platform. Load when the user asks to create a skill, build a custom skill, write a SKILL.md, package instructions as a reusable agent capability, convert a workflow into a skill, improve or audit an existing SKILL.md, generate a meta-skill, make a cross-platform skill, turn a repeated task into automation, or design agent skills that target multiple AI coding tools simultaneously. Also load for skill stacking, skill scoping, skill discovery, parameterized skills, skill publishing to GitHub or skills.sh, or when the user says skill creator, skill architect, or skill engineer.
tools
Identify the right tool for a process step. Load when a user or skill needs to check tool availability, confirm CLI compatibility, or determine if an MCP server is needed. Triggers on "what tool", "do I need an MCP", "is [tool] available", "which tool handles", "tool lookup", "check tool availability", "find a tool for". Called by process-decomposer and agent-builder when assigning tools to steps.
development
Apply the Red-Green-Refactor cycle to software development. Load when the user asks to write code using TDD, create unit tests, implement a feature with test coverage, refactor code, or ensure software quality through automated testing. Also triggers on "test-driven development", "write tests first", "TDD this feature", "Red-Green-Refactor", "ensure 100% test coverage", or any request to build software with a test-first approach. Supports unit, integration, and end-to-end testing strategies.