elon-musk

Apply First Principles Thinking to break problems into fundamentals and redesign solutions from truth-level constraints. Includes domain research, assumption deconstruction, redesign, and inversion-based execution planning.

Safety Notice

This listing is imported from skills.sh public index metadata. Review upstream SKILL.md and repository scripts before running.

Copy this and send it to your AI assistant to learn

Install skill "elon-musk" with this command: npx skills add alpoxdev/hypercore/alpoxdev-hypercore-elon-musk

Elon Musk Skill

First Principles Thinking: solve problems by reasoning from fundamentals, not analogy.


<when_to_use>

When to use

SituationExample
Only obvious answers appear"Need revenue growth -> ads?"
Cost/structure innovation"How do we cut infrastructure cost?"
Challenge assumptions"We always do it this way"
Strategic decisions"A vs B decision"
Market entry design"Should we copy competitors?"

Invocation

/elon-musk SaaS pricing is crowded and undifferentiated
/elon-musk infrastructure cost is 40% of revenue
/elon-musk churn is high and retention playbooks are failing

Outputs

  • Assumption deconstruction matrix (constraint vs convention vs unverified)
  • Comparison table (analogy-based vs first-principles approach)
  • Innovative solution options rebuilt from fundamentals
  • Execution plan and risk matrix using inversion/pre-mortem

</when_to_use>


<argument_validation>

Required ARGUMENT check

If $ARGUMENTS is missing, ask immediately:

"Which problem should we deconstruct using first principles?

Examples:
- Cost innovation: 'SaaS infra cost is 40% of revenue'
- Strategy: 'Only generic market-entry options are visible'
- Assumption challenge: 'We always did it this way, but not sure it is right'
- Technical choice: 'Options look similar; need fundamental differences'"

If $ARGUMENTS exists, continue.

</argument_validation>


<core_philosophy>

First Principles Thinking

Core idea

Analogy-based thinking copies and slightly modifies existing patterns. First-principles thinking decomposes to what is fundamentally true, then rebuilds.

DimensionAnalogy-basedFirst principles
MethodCopy and tweakDecompose then reconstruct
Question"How do others do this?""What is undeniably true?"
OutcomeIncremental optimizationPotentially disruptive innovation
EffortLower cognitive loadHigher cognitive load
Best fitRoutine decisionsBreakthrough / blocked situations

Typical cases

CaseConventional assumptionFirst-principles decompositionResult
Space launch"Rockets are inherently expensive"Raw material is a small fraction of sell priceMajor cost compression
EV battery"Battery packs are fixed-cost expensive"Component-level material and process decompositionNew cost curve possibilities

Supporting methods

MethodRolePhase
Socratic questioningAssumption deconstruction toolPhase 2
Inversion"How do we fail?" reverse risk planningPhase 4
Pre-mortem"If we fail in 6 months, why?"Phase 4

</core_philosophy>


<workflow>

Execution flow

PhaseTaskToolCore intent
0Input + environment checkToolSearchdetect MCP/tool availability
1Domain research (convention + facts + innovation cases)parallel researcher x3collect 3 lenses simultaneously
2Assumption deconstruction (Socratic questions + A/B/C)Sequential Thinking (5-7)separate constraints from habits
3Fundamental redesignparallel analyst x3explore 3-5 alternative paths
4Execution + riskSequential Thinking (3-5)inversion and pre-mortem
5Save + presentWrite.hypercore/first-principles/

Complexity profile

ComplexityPhase 2 depthPhase 4 depthCriteria
Simple3 thoughts2 thoughtssingle domain, <=3 assumptions
Medium5 thoughts3 thoughtsmulti-domain, 5-7 assumptions
Complex7+ thoughts5 thoughtsindustry-level, 10+ assumptions
</workflow>

<sourcing_strategy>

Search channel strategy

Use Tier-1 MCP channels first, and fallback to built-in web tools when unavailable.

Phase 0: MCP detection

ToolSearch("firecrawl")
ToolSearch("searxng")
ToolSearch("github")

If MCP is available -> pass MCP context into researcher prompts.
If MCP is unavailable -> use WebSearch/WebFetch fallback.

</sourcing_strategy>


<parallel_agent_execution>

Priority: Agent Teams for complex parallel work

  • If Agent Teams is available: TeamCreate -> spawn workers -> parallel collaboration.
  • If not available: parallel Task calls as fallback.

Phase 1: Parallel domain research (3 directions)

AgentTypeGoalSource requirement
1-AresearcherIndustry conventions and default approachesURL + publish date + source type
1-BresearcherHard facts/data: cost, benchmarks, constraintsURL + publish date, prefer last 12 months
1-CresearcherInnovation cases that broke assumptionsURL + publish date

Phase 3: Parallel alternative-path analysis

AgentTypeEvaluation criteria
3-Aanalystfeasibility, impact, resources, risk
3-Banalystfeasibility, impact, resources, risk
3-Canalystfeasibility, impact, resources, risk

Model routing

PhaseAgentModelWhy
1researcher x3sonnetweb-fact collection
2Sequential ThinkingmainSocratic decomposition
3analyst x3sonnetpath feasibility analysis
4Sequential Thinkingmaininversion and pre-mortem

</parallel_agent_execution>


<phase_details>

Phase 2: Assumption deconstruction (core)

Socratic 6-question set

Apply to each convention collected in Phase 1:

Question typePromptPurpose
Clarification"What exactly does this mean?"make assumption explicit
Assumption probe"What are we assuming?"reveal hidden premises
Evidence test"What evidence proves this?"separate fact from belief
Perspective shift"What other frame exists?"break fixation
Implication test"If false, what changes?"evaluate removal impact
Meta question"Why did we accept this as normal?"expose inertia

Required A/B/C classification

ClassMarkDefinitionTreatment
Physical/technical constraintsAnatural law, hard technical limitskeep as fundamentals
Habitual conventionB"because industry does it"remove
Needs validationCtestable but not yet confirmedverify with search/data

Phase 2 sequential-thinking template

thought 1: extract 5-10 assumptions from Phase 1 material
thought 2: apply Socratic questions and initial A/B/C labels
thought 3: cross-check C items with known facts
thought 4: run extra search for unresolved C items
thought 5: finalize classification and deconstruction matrix

Phase 3: Fundamental redesign

Input

  • A items: true constraints
  • B items: removed conventions

Process

1. Keep only A constraints; strip B assumptions.
2. Re-ask: "If we design from these truths only, what changes?"
3. Explore 3-5 alternatives in parallel.
4. Build "current vs first-principles" comparison table.
5. Select best path with explicit rationale.

Phase 4: Execution and risk

MethodQuestionProcess
Inversion"How do we fail for sure?"enumerate 5-7 failure paths and map preventions
Pre-mortem"If we fail in 6 months, why?"identify top causes and preemptive controls

</phase_details>


<document_storage>

Result storage

ItemRule
Path.hypercore/first-principles/[number].[problem_summary].md
Numbering`ls .hypercore/first-principles/
Flowensure folder -> Write -> return saved path

</document_storage>


<result_structure>

Output structure

SectionContent
Headerdate, problem statement
1. Domain snapshotconventions, facts, innovation cases (URLs required)
2. Deconstruction matrixassumptions + Socratic checks + A/B/C + evidence
3. Fundamental redesigncurrent vs first-principles comparison and chosen path
4. Execution + riskaction plan, inversion failures, pre-mortem
Sourcesfull URL list

</result_structure>


<examples>

Core example: cost innovation

User: /elon-musk infrastructure cost is 40% of SaaS revenue

Phase 0: detect MCP/tools
Phase 1: researcher x3 in parallel
  - conventions: "standard cloud cost structure"
  - facts: compute/network unit economics (recent data)
  - innovation cases: cost-disruptive infra companies

Phase 2: Sequential Thinking
  assumption 1: "Current provider is always optimal" -> B
  assumption 2: "Serverless is always cheaper" -> C -> B after verification
  assumption 3: "Latency constraints are physical" -> A

Phase 3: analyst x3 parallel alternatives
  A: bare metal + automation
  B: hybrid reserved + serverless cold path
  C: edge compute migration

Phase 4: inversion + pre-mortem
  risk: migration downtime -> blue/green rollout
  risk: ops complexity -> automation-first controls

Save: .hypercore/first-principles/00.saas_infra_cost_innovation.md
</examples>
<validation>

Validation checklist

ItemRequired
ARGUMENTAsk if missing
Phase 0MCP/tool availability checked
Phase 1researcher x3 (convention + facts + cases), source grading
Phase 2Sequential Thinking 3+ steps, 5+ A/B/C items, 2+ fact cross-checks
Phase 3analyst x3, comparison table included
Phase 4inversion 3+ risks, pre-mortem included
Save.hypercore/first-principles/
SourcesURL + date + source type for factual claims
Forbidden
Start without ARGUMENT
Deconstruct assumptions without domain research
Redesign without A/B/C matrix
Execution plan without inversion/pre-mortem
Factual claims without sources
Pure analogy/copy strategy
Exit without saving results
</validation>

Source Transparency

This detail page is rendered from real SKILL.md content. Trust labels are metadata-based hints, not a safety guarantee.

Related Skills

Related by shared tags or category signals.

Coding

crawler

No summary provided by upstream source.

Repository SourceNeeds Review
Coding

tanstack-start-architecture

No summary provided by upstream source.

Repository SourceNeeds Review
Coding

gemini

No summary provided by upstream source.

Repository SourceNeeds Review