Other

FirstPrinciples

Physics-based reasoning framework (Musk methodology) that deconstructs a problem to irreducible fundamental truths, classifies every element as hard constraint, soft constraint, or assumption, then reconstructs the optimal solution from fundamentals alone

03
Workflows
00
Tools
00
References
09
Triggers

The Problem

Ask a generic AI to challenge your architecture and it'll reason by analogy — comparing to what worked elsewhere, citing convention, anchoring to market prices as if they were physics. The result is a polished version of the status quo. You don't get someone asking whether the constraint is real or whether you're optimizing form instead of function. Inherited assumptions stay invisible because nobody decomposed the problem far enough to find them.

How This Skill Approaches It

The skill runs a three-step framework: Deconstruct (break the problem into constituent parts and actual values, not market prices or received wisdom), Challenge (classify every element as a hard constraint from physics, a soft constraint from policy, or an unvalidated assumption — only the first category is truly immutable), then Reconstruct (build the optimal solution from the hard constraints alone, ignoring inherited form). The constraint table is the core artifact. Every time you call Challenge, you get a row: what the constraint is, what type it is, the evidence for that classification, and what happens if you remove it. Reconstruct only works from the hard column. Other skills call FirstPrinciples as a sub-step when they're stuck — RedTeam, Ideate, architects mid-analysis.

Not for structural feedback loops (use SystemsThinking)

In Action

What you say to your DA, and what the FirstPrinciples skill actually does.

  • You say "challenge the assumption that we need microservices here"
    Runs Deconstruct to map what the app actually needs (team size, scale, failure modes), then Challenge to classify microservices as a soft constraint or unvalidated assumption, then Reconstruct from only the hard requirements — often landing on a modular monolith for a three-person team.
  • You say "we're paying $10k a month in cloud costs and that's just what it costs"
    Runs Deconstruct to break the bill into actual components (compute, storage, bandwidth, managed services), Challenge to identify which costs are hard (real compute needs) vs. soft (convenience choices), and Reconstruct to show the gap between the actual compute floor and what's being paid for choice.
  • You say "the firewall protects our internal network, right"
    Runs the three-step analysis to surface that packet filtering on specific ports is not equivalent to protection — reveals insider threats and authorized-port traffic as unaddressed attack surfaces the inherited model treats as solved.

Inside the Skill

The thinking, frameworks, and architecture that distinguish this skill from a generic version of the same task.

What It Does

Breaks a problem down to its fundamental truths and rebuilds the solution from there, instead of copying what already exists. Three steps: DECONSTRUCT (break it into constituent parts and real values), CHALLENGE (classify every element as hard constraint, soft constraint, or unvalidated assumption — only physics is truly immutable), and RECONSTRUCT (build the optimal solution from the fundamentals alone). Outputs a parts breakdown, a constraint table, and a reconstructed solution.

The Core Distinction

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 — Architects challenging "constraint or convention?", RedTeam and pentesters attacking assumed boundaries, engineers escaping local maxima.

Constraint Classification

When analyzing any system, classify constraints:

Type Definition Example Can Change?
Hard Physics/reality "Data can't travel faster than light" No
Soft Policy/choice "We always use REST APIs" Yes
Assumption Unvalidated belief "Users won't accept that UX" Maybe false

Rule: Only hard constraints are truly immutable. Soft constraints and assumptions should be challenged.

Integration Pattern

Other skills invoke FirstPrinciples like this:


Before Analysis

→ Use FirstPrinciples/Challenge on all stated constraints → Classify each as hard/soft/assumption

When Stuck

→ Use FirstPrinciples/Deconstruct to break down the problem → Use FirstPrinciples/Reconstruct to rebuild from fundamentals

For Adversarial Analysis

→ RedTeam uses FirstPrinciples/Challenge to attack assumptions → Pentester uses FirstPrinciples/Deconstruct on security model ```

Example

Problem: "Cloud hosting costs $10,000/month — that's just what it costs."

  • Deconstruct: What are we actually paying for? (compute, storage, bandwidth, managed services)
  • Challenge: Is managed Kubernetes a hard requirement? Is this region required? The $10K is a market price, not a fundamental cost.
  • Reconstruct: Actual compute need = $2,000. The other $8,000 is convenience we're choosing to pay for.

First Principles Analysis: [Topic]

Deconstruction

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

Constraint Classification

Constraint Type Evidence Challenge
[X] Hard/Soft/Assumption [Why] [What if removed?]

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?] ```

The Load-Bearing Rules

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

Attribution: Framework derived from Elon Musk's first principles methodology as documented by James Clear, Mayo Oshin, and public interviews.

Gotchas

  • Decompose to AXIOMS — fundamental truths, not just simpler components. The value is in finding the irreducible elements.
  • Challenge INHERITED assumptions specifically. What does everyone assume that might be wrong?
  • This is analysis/reasoning, not implementation. "Analyze" = FirstPrinciples. "Fix" = do the work directly.

Workflows & Routing · 3

Each workflow is one job the skill runs. The trigger phrases route your request to the right one — this is the skill's routing table.

  1. 01
    Challenge Workflows/Challenge.md
  2. 02
    Deconstruct Workflows/Deconstruct.md
  3. 03
    Reconstruct Workflows/Reconstruct.md

How to Invoke

Say any of these to your DA and LifeOS activates the FirstPrinciples skill automatically:

  • "first principles"
  • "fundamental truths"
  • "challenge assumptions"
  • "real constraint"
  • "rebuild from scratch"
  • "start over"
  • "physics first"
  • "question everything"
  • "reasoning by analogy"

Or invoke explicitly:

Skill("FirstPrinciples")

References & Credits

The thinkers, books, frameworks, and research this skill is built on. The ideas belong to them — the integration belongs to LifeOS.

Want LifeOS to do this for you?

Install LifeOS on your machine — your DA gets the FirstPrinciples skill plus 46 others, all hooked into one Life OS.