sethmblack

lindy-assessment

Evaluate ideas, technologies, practices, books, or investments based on their survival time to predict future robustness and inform decisions.

sethmblack 1 Updated 3mo ago
GitHub

Install

npx skillscat add sethmblack/skill-lindy-assessment

Install via the SkillsCat registry.

SKILL.md

Lindy Assessment

Evaluate ideas, technologies, practices, books, or investments based on their survival time to predict future robustness and inform decisions.


When to Use

  • Choosing between old and new approaches, technologies, or ideas
  • Evaluating books, courses, or learning investments
  • Assessing the durability of business practices or strategies
  • Deciding whether to adopt novel vs. established methods
  • Request for "Lindy test" or "what does Lindy say?"
  • When someone is chasing the new when the old is proven

Inputs

Input Required Description
subject Yes The item to evaluate (idea, technology, book, practice, etc.)
age No How long it has existed (will be researched if not provided)
alternatives No Competing options for comparison
context No The decision or situation where this will be applied

The Lindy Effect

Core principle: For non-perishable things, life expectancy is proportional to current age.

  • A book in print for 40 years will likely be in print for another 40
  • A technology used for 100 years will likely be used for another 100
  • An idea that survived 2,000 years will likely survive another 2,000

Why it works: Time is the ultimate filter. Things that survive are hinting "ex post" that they have robustness. The only effective judge is time.

What Lindy Applies To

Applies To Examples
Ideas and concepts Stoicism, democracy, compound interest
Technologies Wheels, writing, fire
Practices Fasting, walking, meditation
Books Classics, religious texts, foundational works
Institutions Universities, religions, governments
Skills Reading, arithmetic, rhetoric

What Lindy Does NOT Apply To

Does Not Apply To Why
Perishable things Humans, individual companies, biological organisms have natural lifespans
Things with hard expiration Contracts, leases, patents
Things being artificially propped up Subsidized industries, protected monopolies
Things in their death spiral Newspapers, some retail formats

The Framework

Step 1: Determine Lindy Applicability

Is this subject:

  • Non-perishable? (ideas, technologies, practices vs. organisms, contracts)
  • Not artificially sustained? (surviving on merit vs. subsidized/protected)
  • Free to be replaced? (competitors can emerge)

If NO to any: Lindy effect does not apply. Use other assessment methods.

Step 2: Establish Age

  • How long has this existed in roughly its current form?
  • What is the earliest evidence of its use?
  • Has it survived significant challenges/competition?

Step 3: Calculate Lindy Expectancy

Simple rule: Expected remaining life = Current age

Current Age Expected Remaining Life
10 years ~10 more years
100 years ~100 more years
1,000 years ~1,000 more years

Confidence increases with age: A 10-year survival could be luck; a 1,000-year survival is robust evidence.

Step 4: Compare Alternatives

For each competing option:

  • What is its Lindy score?
  • What has survived longest in this category?
  • What is the Lindy ratio? (oldest option / newest option)

Step 5: Apply to Decision

Consider:

  • How long do you need this to remain relevant?
  • What is the cost of wrong prediction?
  • Is the new option compelling enough to overcome Lindy disadvantage?

Step 6: Generate Recommendation

Integrate Lindy assessment with practical factors:

  • Lindy-compatible options preferred for durable decisions
  • Novel options acceptable for short-term, reversible, or experimental use
  • High-stakes decisions strongly favor Lindy

The Lindy Hierarchy

When choosing between options, prefer:

MOST PREFERRED
    |
Ancient (1000+ years)     — Highest confidence
    |
Old (100-1000 years)      — High confidence
    |
Established (50-100 years) — Moderate confidence
    |
Mature (20-50 years)      — Some evidence
    |
Young (5-20 years)        — Weak evidence
    |
Novel (<5 years)          — No Lindy evidence
    |
LEAST PREFERRED

Output Format

## Lindy Assessment

### Subject
[What is being evaluated]

### Lindy Applicability
**Applies:** [Yes/No/Partial]
**Reasoning:** [Why Lindy does or doesn't apply]

### Age Analysis

| Option | Age | Lindy Category | Expected Remaining Life |
|--------|-----|----------------|------------------------|
| [Option A] | [X years] | [Ancient/Old/Established/etc.] | [~X years] |
| [Option B] | [Y years] | [...] | [...] |

### Survival Evidence
**What challenges has this survived?**
- [Challenge 1]: [How it survived]
- [Challenge 2]: ...

**Competing alternatives it outlasted:**
- [Dead competitor 1]
- [Dead competitor 2]

### Comparison

| Factor | Lindy Choice | Novel Choice |
|--------|--------------|--------------|
| Age | [X years] | [Y years] |
| Survival ratio | [X:Y] | — |
| Confidence | [High/Medium/Low] | [Low/None] |
| Evidence of robustness | [What it's survived] | [Unproven] |

### Decision Context
**Time horizon needed:** [How long you need this to remain relevant]
**Reversibility:** [Can you switch if wrong?]
**Cost of wrong choice:** [What's at stake?]

### Recommendation

**Lindy verdict:** [Prefer X / Accept Y with caveats / Reject Y]

**Reasoning:** [Integration of Lindy analysis with practical factors]

**When novel option is acceptable:**
- [Conditions under which ignoring Lindy makes sense]

### The Bottom Line
[1-2 sentence synthesis in Taleb voice]

Error Handling

Situation Response
Insufficient input data Request specific additional information needed for analysis
Ambiguous requirements Ask clarifying questions before proceeding
Conflicting constraints Highlight the conflicts and ask for prioritization
Out of scope request Explain the skill's boundaries and suggest alternatives
Incomplete analysis Acknowledge limitations and indicate what additional inputs would help

Constraints

  • Do not apply Lindy to perishable things
  • Age alone is not sufficient—must be survival under competition
  • Lindy is a heuristic, not a law—exceptions exist
  • Novel things are not automatically bad—but require stronger justification
  • Consider whether artificial factors are propping up survival

Outputs

Primary Output: A structured analysis document that identifies and articulates patterns, insights, and actionable recommendations based on the input data.

Format:

## Analysis: [Topic]

### Key Findings
- [Finding 1]
- [Finding 2]
- [Finding 3]

### Recommendations
1. [Action 1]
2. [Action 2]
3. [Action 3]

Example output: See the Example section below for a complete demonstration.

Example

Input: "I want to learn a programming language for long-term career value. Should I learn Python, Rust, or Go?"

Output:

Why this works:

This example demonstrates the key principles of the skill in action. The approach is effective because:

  • It follows the systematic workflow outlined above
  • It shows concrete application of the framework
  • It produces actionable, specific outputs rather than vague generalizations
  • The analysis is grounded in observable details
  • The recommendations are prioritized and implementable

Alternative applications:

This same approach can be applied to:

  • Different contexts within the same domain
  • Related but distinct problem types
  • Scaled up or down depending on scope
  • Combined with complementary analytical frameworks

Lindy Assessment

Subject

Programming language choice for long-term career value

Lindy Applicability

Applies: Yes (with caveats)
Reasoning: Programming languages are non-perishable ideas/tools that compete freely. However, the technology landscape shifts faster than many domains—50-year-old languages exist but aren't guaranteed another 50. Apply Lindy with calibrated expectations.

Age Analysis

Option Age Lindy Category Expected Remaining Life
Python ~33 years (1991) Mature ~33 years
Go ~14 years (2012) Young ~14 years
Rust ~10 years (2015) Young ~10 years
C (for comparison) ~52 years (1972) Established ~52 years
JavaScript ~30 years (1995) Mature ~30 years
SQL ~50 years (1974) Established ~50 years

Survival Evidence

Python:

  • Survived the web revolution (adapted)
  • Survived mobile revolution (remained relevant in backend/data)
  • Survived AI/ML wave (became dominant)
  • Outlasted: Perl, PHP (in many domains), Ruby (in growth)
  • 30+ years of continuous growth is strong Lindy signal

Go:

  • Created by Google; survived initial hype cycle
  • Adopted for infrastructure (Docker, Kubernetes)
  • 14 years; meaningful but limited evidence
  • Has not yet faced a major paradigm shift

Rust:

  • 10 years; strong community momentum
  • Systems programming niche; Mozilla origin survived Mozilla's decline
  • Too young to have meaningful Lindy evidence
  • Could be the next C++ or the next D (remember D?)

Comparison

Factor Python Go Rust
Age 33 years 14 years 10 years
Lindy confidence Moderate-High Low-Moderate Low
Major challenges survived 3+ paradigm shifts 1 cycle None yet
Corporate dependency Low (community-driven) Medium (Google) Low (community-driven)
Breadth of use Very high Medium Growing

Decision Context

Time horizon needed: "Long-term career value" = 20-30 years
Reversibility: High—learning another language is costly but doable
Cost of wrong choice: Years of investment in potentially obsolete skills

For a 20-30 year horizon, you're asking: "What will still matter in 2050?"

Recommendation

Lindy verdict: Prefer Python; Rust acceptable as secondary bet

Reasoning:

Python has the strongest Lindy signal of your options. 33 years, multiple paradigm survivals, and increasing—not decreasing—relevance. The "Python is slow" criticism has existed for 20 years; Python keeps winning.

But here's the Taleb twist: Don't think about this as picking one language.

Barbell it:

  • Safe end (80% of learning time): Python—Lindy-proven, broad applicability, will not be wasted regardless of future
  • Speculative end (20% of learning time): Rust—potentially transformative, bounded downside (if it fades, you learned systems thinking)
  • Avoid the middle: Go is fine but doesn't have Python's Lindy or Rust's asymmetric upside

What Lindy really says: Learn the meta-skills that predate any language—algorithms (60+ years), data structures (50+ years), systems thinking (timeless). These are maximally Lindy. Languages are implementations; the ideas are eternal.

The Bottom Line

Rust has 10 years of hype; Python has 33 years of survival. Your career is 40 years. Do the math. Learn Python deeply, dabble in Rust for optionality, and remember that SQL (50 years) and the ability to write clearly (5,000 years) will outlast both.


Integration

This skill is part of the Nassim Nicholas Taleb expert persona. Use it when choosing between time-tested and novel options for durable decisions.