agentleFS
babypochi06babypochi06/cc-thinking-skills/skills/thinking-second-order/SKILL.md

thinking-second-order

Skill2 starsChanged 9 months agoMITView on GitHub

Think beyond immediate consequences to second and third-order effects. Use for strategic decisions, policy changes, and avoiding unintended consequences.

The file

We split this skill into the rules it gives an agent

2 rules. About 0 are common, 2 are distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈2

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    When the "obvious" solution feels too easy

    line 19
  2. Distinctive:

    Ask: "What if everyone did this?"

    line 63

≈ “Common” is an estimate: at least 1 in 5 of the 350,495 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Second-Order Thinking

Overview

Second-order thinking, articulated by Howard Marks, moves beyond immediate effects to consider what happens next, and what that leads to. First-order thinking is simplistic ("This action solves the problem"); second-order thinking asks "And then what?" repeatedly.

Core Principle: The obvious answer to "What should I do?" is often wrong because it ignores downstream effects.

When to Use

  • Making strategic or architectural decisions
  • Evaluating policy or process changes
  • Considering incentive structures
  • Planning features that change user behavior
  • Decisions with long-term consequences
  • When the "obvious" solution feels too easy

Decision flow:

Decision with consequences beyond immediate? → yes → APPLY SECOND-ORDER THINKING
                                            ↘ no → First-order may suffice

First vs Second-Order Thinking

SituationFirst-OrderSecond-Order
Team is slowAdd more engineersMore engineers → more coordination → slower decisions → may get slower
Users complainAdd the feature they requestFeature → complexity → more support load → less time for core work
Costs too highCut spendingCuts → reduced quality → customer churn → revenue drop → worse situation
Bug in prodHotfix immediatelyHotfix → skip testing → more bugs → trust erosion → slower deployments

The Process

Step 1: Identify the Decision and First-Order Effect

Decision: Add a feature flag system
First-order: Teams can ship features independently ✓

Step 2: Ask "And Then What?"

Chain the consequences:

Feature flags → More flags created → Flag debt accumulates
             → Teams don't clean up → Combinatorial testing complexity
             → Bugs from flag interactions → "Turn it off" becomes risky
             → Flags become permanent → Codebase complexity explodes

Step 3: Apply the 10/10/10 Framework

Evaluate impact across time horizons:

TimeframeQuestionAnalysis
10 minutesHow will I feel right after?Relief—problem solved
10 monthsHow will this affect things in 10 months?Flag sprawl emerging
10 yearsWhat's the long-term trajectory?Technical debt crisis

Step 4: Consider Systemic Effects

Ask: "What if everyone did this?"

Decision: Skip code review for urgent fixes
If everyone: All urgent fixes skip review
Result: Definition of "urgent" expands → most things skip review
Outcome: Quality collapses, more urgent fixes needed

Step 5: Map the Consequence Chain

┌─────────────────┐
│ Decision: X     │
└────────┬────────┘
         ▼
┌─────────────────┐
│ 1st Order: A    │ ← Obvious, intended
└────────┬────────┘
         ▼
┌─────────────────┐
│ 2nd Order: B    │ ← Less obvious
└────────┬────────┘
         ▼
┌─────────────────┐
│ 3rd Order: C    │ ← Often counterintuitive
└────────┬────────┘
         ▼
┌─────────────────┐
│ Feedback Loop   │ ← May reinforce or counteract
└─────────────────┘

Common Second-Order Effects in Software

Optimization

1st: Optimize critical path → Faster
2nd: Team focuses on optimization → Less feature work
3rd: Premature optimization spreads → Complexity increases
4th: Maintenance burden grows → Slower overall

Hiring

1st: Hire senior engineers → More capacity
2nd: Salary expectations rise → Budget pressure
3rd: Junior engineers feel stuck → Attrition
4th: Knowledge concentrated in seniors → Bus factor risk

Process Addition

1st: Add approval process → More oversight
2nd: Approvals create bottleneck → Slower delivery
3rd: People route around process → Shadow processes
4th: Formal process becomes theater → Worst of both worlds

Technical Shortcuts

1st: Skip tests to ship faster → Feature delivered
2nd: Bugs emerge → Support load increases
3rd: Team fights fires → Less time for features
4th: More shortcuts taken → Quality death spiral

Application Framework

For any significant decision, fill out:

## Second-Order Analysis: [Decision]

### Immediate Effect (1st Order)
[What happens right away]

### Near-Term Consequences (2nd Order)
[What does the immediate effect cause? 1-3 months]

### Medium-Term Consequences (3rd Order)  
[What do the near-term effects cause? 3-12 months]

### Long-Term Trajectory
[Where does this path lead? 1+ years]

### Feedback Loops
[Does this create reinforcing or balancing dynamics?]

### If Scaled
[What happens if this becomes standard practice?]

### Revised Decision
[Given analysis, what should we actually do?]

Questions to Surface Second-Order Effects

  • "And then what?"
  • "Who else is affected, and how will they respond?"
  • "What incentives does this create?"
  • "What behavior does this encourage/discourage?"
  • "If this works, what problems does success create?"
  • "What will we wish we had done differently in a year?"
  • "What does this look like if everyone does it?"

Verification Checklist

  • Identified first-order effect clearly
  • Asked "and then what?" at least 3 times
  • Applied 10/10/10 framework
  • Considered systemic/scaled effects
  • Identified potential feedback loops
  • Revised decision based on full consequence chain
  • Documented reasoning for future reference

Marks' Warning

"First-level thinking is simplistic and superficial, and just about everyone can do it. Second-level thinking is deep, complex, and convoluted."

The crowd uses first-order thinking. Competitive advantage comes from thinking one level deeper—seeing what happens after the obvious effect.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.