FirstPrinciples

• What the analysis calls fundamental is only physics, math, verified fact or a truly immutable requirement; every market price, best practice and policy is shown to be convention and taken apart.
• The irreducible function of the subject is stated as an outcome, not a mechanism ("pick the right model and effort for a piece of work", not "a router"), and every component under discussion is marked as serving that function or not. Costing from fundamentals appears only when cost is part of the question.
• Output length matches the request: an inline, brief or terse pass returns the irreducible job, the classification with its evidence, and the key insight in a few lines, without empty template sections; the full templates are for full runs.
• A full run ends with a solution rebuilt from the hard constraints and compared against the current approach, plus the one assumption that was limiting it.

A full analysis runs them in order, Deconstruct → Challenge → Reconstruct; each also runs alone when its input is already in hand. A standalone Challenge hands its analysis to Reconstruct or back to the requester for a decision.

Every intent uses this one classification; Challenge applies it to each constraint. Only hard constraints are truly immutable; soft constraints and assumptions are challenged.

Most reasoning is reasoning by analogy — "how did we solve something similar," "what do others do" — then copy it with tweaks. That inherits everyone else's assumptions and treats policy and convention as if they were laws of physics, so you optimize the suitcase instead of inventing wheels. First principles forces the split between what's actually immutable and what's merely inherited, then rebuilds from only the parts that can't change.

• Reasoning by analogy (default, often wrong): copies existing solutions with slight variations.
• Reasoning from first principles (this skill): asks "what is this actually made of?" and rebuilds from irreducible facts.

Invoked directly, or by other skills when inherited assumptions may be limiting the solution space — architecture work asking "constraint or convention?", RedTeam and pentests attacking assumed boundaries, engineering escaping local maxima.

• Market prices and industry best-practices are NOT fundamental truths. "Batteries cost $600/kWh" or "hosting costs $10K/mo" are convention, not physics — deconstruct to material/compute cost before accepting them.
• Optimize function over form — what you're trying to accomplish, not how it's traditionally done (improve the wheel, don't polish the suitcase).
• Rebuild, don't patch — when the assumptions are wrong, start from the hard constraints rather than fixing the inherited form. Cross-domain solutions from unrelated fields often apply.

Deconstruction

• Constituent Parts: [List fundamental elements]
• Actual Values: [Real costs/metrics, not market prices]

Constraint Classification

Reconstruction

• Fundamental Truths: [Only the hard constraints]
• Optimal Solution: [Built from fundamentals]
• Form vs Function: [Are we optimizing the right thing?]

Key Insight

[One sentence: what assumption was limiting us?] ```

User customizations live at <configRoot>/LIFEOS/USER/CUSTOMIZATIONS/SKILLS/FirstPrinciples/ (configRoot is $CLAUDE_CONFIG_DIR when set, else ~/.claude). When that directory exists, its PREFERENCES.md, configurations and resources apply and override the defaults here; when it is absent, the defaults stand.

• The Core Distinction, The Load-Bearing Rules and Challenge's tabular worked example (Intents/Challenge.md § Examples) are measured keep-content; never cut them as choreography. A 2026-10-10 quality pass cut all three and lost the A/B against the old text; restoring them won it back. Source: commit aaac137c88, suite ab-firstprinciples-challenge.

User: "What is a model router fundamentally for, and what are the irreducible constraints on routing LLM work?"
→ Deconstruct → Challenge → Reconstruct
→ The router's job as an outcome, each design element marked as serving it or not, a constraint table with evidence, a rebuilt design, and the assumption that was limiting the current one

User: "Quick inline pass: judgment-layer question system for support-ticket routing. What is code, what is judgment, what does the decision irreducibly turn on?"
→ Challenge, compact
→ A few lines: the irreducible decision, which inputs code can decide exactly and which need judgment, and which inherited design choices are soft

User: "Cloud hosting costs $10,000/month. That's just what it costs."
→ Deconstruct
→ What the bill pays for (compute, storage, bandwidth, managed services); actual compute need is about $2,000, and the other $8,000 is convenience being chosen, such as managed Kubernetes and a fixed region