@polderlabs/bizar 10.7.0 → 10.7.2

package/.claude/skills/thinking-regret-minimization/SKILL.md

@@ -0,0 +1,335 @@
+---
+name: thinking-regret-minimization
+description: When advising a human on a high-stakes, hard-to-undo life/career choice, weigh the asymmetry between a recoverable downside and a permanent missed opportunity, not just the short-term cost.
+---
+
+# Regret Minimization Framework
+
+> Scope note: This is a **human-facing advisory** lens. An autonomous agent has no "future self" to regret, so do not apply it to your own tool/architecture choices — for those use thinking-reversibility (one-way vs two-way door) and thinking-opportunity-cost. Use this skill only when helping a *person* reason through a personal/career decision. The reusable core for engineering work is the asymmetry below: a recoverable downside vs. a permanently foregone upside.
+
+## Trigger Card
+
+When advising a human on a high-stakes, hard-to-undo life/career choice:
+
+1. **Check the asymmetry:** Is the downside recoverable but the missed upside permanent? If yes, the asymmetry favors trying. If the downside is catastrophic or harms others, the asymmetry flips — do NOT apply "just try it."
+2. **Demote short-term fear:** Which costs will have faded to nothing years from now? Which path, if untaken, leaves a permanent "what if?"
+3. **Recommend the path that minimizes lifetime regret** — inaction regrets grow larger over time; action regrets usually fade.
+
+For agent decisions (tooling, architecture), use `thinking-reversibility` + `thinking-opportunity-cost` instead.
+
+## Overview
+
+Jeff Bezos's Regret Minimization Framework reframes a hard, irreversible personal choice around long-term regret rather than short-term fear: imagine looking back from the far future and ask which path you'd regret *not* taking. The transferable insight is an **asymmetry** — a failed attempt is usually recoverable, while a never-taken opportunity is permanently gone.
+
+**Core Principle:** Weigh a recoverable downside against a permanent foregone upside. When the downside is reversible and the missed upside is not, the asymmetry favors trying.
+
+## When to Use
+
+- Career-defining decisions
+- Whether to pursue a risky opportunity
+- Staying safe vs. taking a leap
+- Decisions with fear of failure
+- When short-term costs obscure long-term value
+- Life-changing personal decisions
+- Entrepreneurial choices
+
+Decision flow:
+
+```
+Advising a human on a significant life/career decision?
+  → Is the downside recoverable but the missed upside permanent? → yes → APPLY THE ASYMMETRY
+  → Is short-term fear obscuring long-term value? → yes → WEIGH LONG-TERM REGRET
+  → It's an agent/engineering decision? → use thinking-reversibility + thinking-opportunity-cost instead
+```
+
+## When NOT to Use
+- The decision is yours-as-an-agent (tooling, architecture, refactor) — there's no future self; use thinking-reversibility and thinking-opportunity-cost.
+- The choice is easily reversible — regret framing is overkill; just pick and adjust.
+- The downside is *not* recoverable (catastrophic, ruinous, or harms others) — the asymmetry flips; "just try it" is wrong advice. Weigh the irreversible downside directly.
+- Others bear the consequences — one person's regret isn't the whole calculus; bring in affected stakeholders.
+
+## The Framework
+
+### Step 1: Take the Long-Horizon View
+
+When advising a person, have them picture looking back from far in the future — the point is to demote short-term fear (a lost bonus, temporary discomfort) and surface what lasts:
+
+```
+Looking back years from now:
+- Which short-term costs will have faded to nothing?
+- Which path, if not taken, would leave a permanent "what if?"
+```
+
+The mechanism that matters is the **asymmetry**, not the specific age: short-term costs fade; permanently foregone opportunities don't.
+
+### Step 2: Frame the Decision
+
+State the choice clearly:
+
+```
+The decision: Should I leave my stable job to start a company?
+
+Option A: Stay in stable job
+- Known income, security, career progression
+- Low risk, predictable outcomes
+
+Option B: Start the company
+- Uncertainty, potential failure
+- Chance to build something meaningful
+- Unknown outcomes
+```
+
+### Step 3: Apply the Regret Test
+
+For each option, ask: "Will I regret NOT doing this?"
+
+```
+At 80, will I regret:
+- Not trying to start the company? → Likely YES
+- Not staying in the stable job? → Likely NO
+
+Bezos's insight: "I knew that when I was 80, I was not going to regret
+having tried this. I was not going to regret trying to participate
+in this thing called the Internet that I thought was going to be
+a really big deal."
+```
+
+### Step 4: Distinguish Regret Types
+
+**Regrets of Action:** Things you did that went wrong
+- Usually fade over time
+- At least you tried
+- Provide learning
+
+**Regrets of Inaction:** Things you never tried
+- Grow larger over time
+- "What if?" haunts you
+- No closure or learning
+
+Research shows: Regrets of inaction are more painful and persistent than regrets of action.
+
+### Step 5: Make the Decision
+
+Choose the path with minimum lifetime regret:
+
+```
+The calculus:
+- If I try and fail: Temporary pain, but no regret for not trying
+- If I don't try: Permanent "what if?" regret
+- The expected regret of inaction > expected regret of action
+
+Decision: Try.
+```
+
+## Application Patterns
+
+### Career Decisions
+
+```markdown
+## Regret Analysis: Take the startup job or stay at BigCorp?
+
+At 80, looking back:
+- Will I regret not taking the startup risk? → Likely YES
+  "I wonder what could have been. I played it safe."
+- Will I regret not staying at BigCorp? → Likely NO
+  "I took a risk, it didn't work, but I learned and recovered."
+
+Key insight: Career failures are recoverable. Unlived possibilities aren't.
+
+Decision: Take the startup job.
+```
+
+### Entrepreneurial Decisions
+
+```markdown
+## Regret Analysis: Start the business now or wait until "ready"?
+
+At 80, looking back:
+- Will I regret not starting when I had the chance? → Likely YES
+  "I waited for perfect conditions that never came."
+- Will I regret starting before being fully ready? → Likely NO
+  "I learned by doing. Even if it failed, I grew."
+
+Key insight: "Ready" is often an illusion. Action creates readiness.
+
+Decision: Start now.
+```
+
+### Personal Decisions
+
+```markdown
+## Regret Analysis: Relocate for the opportunity or stay near family?
+
+At 80, looking back:
+This is more nuanced—both paths have legitimate regret potential.
+
+- Regret not relocating: "I passed up growth for comfort"
+- Regret relocating: "I missed years with aging parents"
+
+Key insight: When both paths have genuine regret potential,
+the decision is about values, not just regret.
+
+Process: Clarify which regret would be heavier for YOUR values.
+```
+
+### Learning Decisions
+
+```markdown
+## Regret Analysis: Pursue the degree/certification or focus on work?
+
+At 80, looking back:
+- Will I regret not getting the credential? → Maybe
+  But: Will the credential matter in 40 years?
+- Will I regret spending years on credential? → Maybe
+  But: Education rarely creates lasting regret
+
+Key insight: Educational regrets are rare;
+            missed opportunities are common regrets.
+
+Decision: Often favors learning, but depends on opportunity cost.
+```
+
+## When Regret Minimization is Less Applicable
+
+### Reversible Decisions
+
+If you can easily change course, regret minimization is overkill:
+
+```
+"Which framework should I learn first?"
+This isn't a lifetime regret question—just pick one and learn.
+```
+
+### Decisions Affecting Others
+
+When others bear the consequences, pure regret minimization is selfish:
+
+```
+"Should I risk the company's future on my vision?"
+Your regret isn't the only consideration—employees, investors matter.
+```
+
+### When Both Options Have Equal Regret
+
+Sometimes both paths lead to comparable regret:
+
+```
+"Career A or Career B?"
+If both are good options, regret minimization won't differentiate.
+Use other frameworks (values alignment, opportunity cost).
+```
+
+## Combining with Other Frameworks
+
+### With Inversion
+
+```
+Inversion: "How would I guarantee regret?"
+- Never take any risks
+- Always choose safety
+- Never pursue what excites me
+
+Avoiding these → Minimizing regret
+```
+
+### With Pre-Mortem
+
+```
+Pre-mortem: "It's years later and I deeply regret this choice. Why?"
+
+This is essentially regret minimization through narrative.
+Write the story of future regret to clarify present choices.
+```
+
+### With Opportunity Cost
+
+```
+Opportunity cost of not trying:
+- Direct: Lost potential upside
+- Regret: Permanent "what if?"
+- Learning: Missed growth opportunity
+
+Full cost often favors action.
+```
+
+## Regret Minimization Template
+
+```markdown
+# Regret Minimization Analysis: [Decision]
+
+## The Decision
+[Clear statement of the choice]
+
+## Option A: [Safe/Conservative Path]
+Short-term: [Benefits and costs]
+Long-term: [Likely trajectory]
+Is the downside recoverable? [Yes/No]
+Long-horizon regret for NOT choosing A: [Assessment]
+
+## Option B: [Risky/Bold Path]
+Short-term: [Benefits and costs]
+Long-term: [Likely trajectory]
+Is the downside recoverable? [Yes/No]
+Long-horizon regret for NOT choosing B: [Assessment]
+
+## Regret Comparison
+| Scenario | Regret Level | Duration | Type |
+|----------|--------------|----------|------|
+| Choose A, works | Low | - | - |
+| Choose A, miss B's upside | High | Permanent | Inaction |
+| Choose B, works | Low | - | - |
+| Choose B, fails | Medium | Temporary | Action |
+
+## Key Insight
+[What does the regret analysis reveal?]
+
+## Decision
+[Choice and reasoning]
+```
+
+## Common Regret Patterns in Tech Careers
+
+### Things People Regret NOT Doing
+
+- Not taking the risk earlier
+- Not starting the side project
+- Not negotiating harder
+- Not leaving toxic situations sooner
+- Not speaking up when it mattered
+- Not investing in relationships
+- Not pursuing meaningful work over safe work
+
+### Things People Rarely Regret
+
+- Taking the risk (even if it failed)
+- Starting the company (even if it folded)
+- Making the leap (even if they had to leap back)
+- Speaking up (even if it was uncomfortable)
+- Trying something hard (even if they failed)
+
+## Verification Checklist
+
+- [ ] Confirmed this is human-facing advice, not an agent decision
+- [ ] Took the long-horizon view (short-term costs demoted)
+- [ ] Checked the downside is recoverable (if not, the asymmetry flips — flag it)
+- [ ] Distinguished action vs. inaction regrets
+- [ ] Considered impact on others, not just the individual
+- [ ] Recommendation follows the recoverable-vs-permanent asymmetry
+
+## Key Questions
+
+- "Is this downside recoverable, or permanent?"
+- "Which short-term costs will have faded years from now?"
+- "Is this fear of failure, or genuine wisdom about an unrecoverable risk?"
+- "Which path, if untaken, leaves a permanent 'what if?'"
+- "Are others harmed in a way that overrides the individual's regret?"
+
+## Bezos's Story
+
+"I went to my boss and said I was going to start a company selling books on the Internet. He said, 'That's a great idea, but it would be a better idea for someone who didn't already have a good job.' So he convinced me to think about it for 48 hours."
+
+"I thought about it and I used this framework, which I call a regret minimization framework. I projected myself to age 80, and I thought, 'When I'm 80, am I going to regret leaving Wall Street in the middle of the year and forgoing my bonus? No. Am I going to regret missing the beginning of the Internet? Yes.'"
+
+"Once I thought about it that way, it was easy to make the decision."
+
+The lesson: Short-term costs (bonus, security, status) fade. Long-term "what-ifs" don't. When in doubt, minimize lifetime regret by trying.

package/.claude/skills/thinking-reversibility/SKILL.md

@@ -0,0 +1,326 @@
+---
+name: thinking-reversibility
+description: Before deliberating over a decision, ask if it's a one-way door (costly to undo) or two-way (cheap to undo) — decide two-way doors fast, and look for moves that make one-way doors reversible.
+---
+
+# Reversibility Thinking
+
+## Overview
+
+Jeff Bezos distinguishes between Type 1 (irreversible, one-way door) and Type 2 (reversible, two-way door) decisions. The key insight: most decisions are Type 2 but get treated as Type 1, causing analysis paralysis. Match your decision process to the reversibility of the decision.
+
+**Core Principle:** Reversible decisions should be made quickly by individuals. Irreversible decisions deserve deliberation. Most decisions are more reversible than they appear.
+
+## When to Use
+
+- Technology choices
+- Architecture decisions
+- Process changes
+- Hiring decisions
+- Feature implementations
+- Organizational changes
+- Any decision where you're uncertain how much analysis is warranted
+
+Decision flow:
+
+```
+Decision to make?
+  → Is it easily reversible? → yes → DECIDE QUICKLY (Type 2)
+  → Is it hard/impossible to reverse? → yes → DELIBERATE CAREFULLY (Type 1)
+  → Unsure of reversibility? → ANALYZE REVERSIBILITY FIRST
+```
+
+## When NOT to Use
+- You've already classified the door — don't re-run the analysis; just decide at the matched depth.
+- Trivial, clearly two-way calls (variable names, which test to write first) — deciding is faster than classifying.
+- The decision is being forced by a hard external constraint (deadline, contract, regulation) with no real optionality — reversibility doesn't change the available move.
+- An irreversible action is genuinely required and the upside justifies it — name it, accept it, and proceed deliberately rather than stalling.
+
+## Trigger Card
+
+Before deliberating over a decision:
+
+1. **Classify the door** — is it one-way (costly to undo) or two-way (cheap to undo)? If you're not sure, it's probably one-way.
+2. **Two-way door?** → Decide fast. The cost of delay exceeds the cost of a wrong choice you can reverse.
+3. **One-way door?** → Ask: can I make it more reversible? (Feature flag, canary, small rollout, decouple the irreversible part.) Then deliberate — but only on what's actually irreversible.
+
+If the decision is forced by an external constraint with no optionality, reversibility doesn't change the available move. If an irreversible action is genuinely required and the upside justifies it, name it and proceed.
+
+## Type 1 vs Type 2 Decisions
+
+### Type 1: One-Way Doors
+
+**Characteristics:**
+- Irreversible or very costly to reverse
+- Consequences are significant and lasting
+- Changing course means starting over
+
+**Examples:**
+- Fundamental architecture choices (monolith vs microservices for core systems)
+- Major technology platform (cloud provider for critical infra)
+- Hiring for leadership positions
+- Shutting down a product line
+- Major acquisitions or contracts
+- Public commitments or promises
+
+**Process:**
+- Extensive analysis before acting
+- Explicitly argue the opposing choice (steel-man the alternative)
+- Document the reasoning and the assumptions it rests on
+- Escalate / surface to the human owner before committing
+
+### Type 2: Two-Way Doors
+
+**Characteristics:**
+- Easily reversed if wrong
+- Limited blast radius
+- Can iterate and adjust
+
+**Examples:**
+- Most feature implementations
+- UI/UX changes
+- Internal tool selection
+- Process experiments
+- Meeting cadences
+- Individual hiring decisions
+- Marketing campaigns
+
+**Process:**
+- Decide quickly
+- Pick the most reasonable option now
+- Monitor results
+- Adjust as needed
+- Don't over-analyze
+
+## The Reversibility Analysis
+
+### Step 1: Assess True Reversibility
+
+| Factor | Question | Impact on Reversibility |
+|--------|----------|------------------------|
+| Technical cost | How hard to undo technically? | High cost = less reversible |
+| Time cost | How long to reverse? | Months = less reversible |
+| Financial cost | How expensive to change? | High cost = less reversible |
+| Reputation cost | Will reversal damage trust? | Yes = less reversible |
+| Learning cost | Will we lose the learning? | Critical learning = more complex |
+| Dependency cost | Have others built on this? | Many dependents = less reversible |
+
+### Step 2: Categorize the Decision
+
+```
+Reversibility Score:
+- Can undo in days with minimal cost: TYPE 2 (two-way door)
+- Can undo in weeks with moderate cost: TYPE 2 with monitoring
+- Can undo in months with significant cost: TYPE 1.5 (evaluate carefully)
+- Cannot realistically undo: TYPE 1 (one-way door)
+```
+
+### Step 3: Match Process to Type
+
+| Decision Type | Process | Effort | Who decides |
+|---------------|---------|--------|-------------|
+| Type 1 | Full analysis, argue the alternative, document | High | Surface to human owner before committing |
+| Type 1.5 | Structured analysis, document rationale | Moderate | Flag to owner if stakes are high |
+| Type 2+ | Quick analysis, note rationale | Low | Decide and proceed |
+| Type 2 | Just decide | Minimal | Decide and proceed |
+
+## Common Reversibility Misclassifications
+
+### Treating Type 2 as Type 1
+
+```
+Decision: Which logging library to use
+Common mistake: Extensive evaluation, committee decision, weeks of analysis
+Reality: Can swap libraries in a day; dependencies are isolated
+Correct approach: Engineer picks one, team evaluates after 2 weeks
+
+Cost of over-deliberation: Weeks of productivity lost
+```
+
+### Treating Type 1 as Type 2
+
+```
+Decision: Database technology for core product
+Common mistake: Quick decision because "we can always change later"
+Reality: Changing databases means rewriting queries, data migration, retraining
+Correct approach: Thorough evaluation, prototype, stakeholder alignment
+
+Cost of under-deliberation: Months of migration pain later
+```
+
+### Hidden Reversibility
+
+Some seemingly irreversible decisions are actually reversible:
+
+```
+"We can't change our API because clients depend on it"
+Reality: Versioning makes this reversible
+       v1 continues, v2 adds improvements
+
+"We can't change the architecture"
+Reality: Strangler pattern enables gradual change
+        Migrate piece by piece
+```
+
+### Hidden Irreversibility
+
+Some seemingly reversible decisions lock you in:
+
+```
+"It's just a prototype, we can rewrite later"
+Reality: Prototypes often become production
+        "Temporary" code lives for years
+
+"We can always switch cloud providers"
+Reality: Deep integration creates massive switching cost
+        Proprietary services create lock-in
+```
+
+## Reversibility Patterns
+
+### The Pilot Pattern
+
+Turn Type 1 into Type 2 through limited rollout:
+
+```
+Type 1: "Adopt new framework for entire codebase"
+Piloted: "Use new framework for one service"
+         → Now it's Type 2: Can abandon pilot with limited impact
+         → If successful, expand incrementally
+```
+
+### The Abstraction Pattern
+
+Create reversibility through interfaces:
+
+```
+Type 1: "Choose between Postgres and MySQL"
+With abstraction: "Define data layer interface, start with Postgres"
+                  → Can swap implementation later
+                  → Cost of reversal dramatically reduced
+```
+
+### The Time-Box Pattern
+
+Make long commitments into short experiments:
+
+```
+Type 1: "Commit to vendor for 3 years"
+Time-boxed: "Start with 6-month pilot"
+            → Can exit at known cost
+            → Full commitment only after validation
+```
+
+### The Feature Flag Pattern
+
+Deploy with reversibility built in:
+
+```
+Type 1: "Launch new pricing model"
+With flags: "Launch to 5% of users, flag-controlled"
+            → Can disable instantly
+            → Expand only when confident
+```
+
+## Decision Speed Guidance
+
+### Decide Immediately (Type 2)
+
+- Which test to write first
+- Variable naming
+- Which task to pick up next
+- Local refactors within a single module
+
+### Quick Analysis (Type 2+)
+
+- Library choices (within approved options)
+- Implementation approach for a feature
+- Code organization within a module
+- Bug fix approach
+
+### Structured Analysis (Type 1.5)
+
+- Design patterns for new components
+- API contract changes (if unversioned)
+- Tool adoption
+- Architectural changes to non-critical services
+
+### Full Deliberation, Surface to Owner (Type 1)
+
+- Core architecture decisions
+- Platform/infrastructure choices
+- Irreversible data migrations / deletions
+- Public API contracts with external consumers
+
+## Reversibility Template
+
+```markdown
+# Reversibility Analysis: [Decision]
+
+## The Decision
+[What we're deciding]
+
+## Reversibility Assessment
+
+| Factor | Assessment | Score (1-5) |
+|--------|------------|-------------|
+| Technical effort to reverse | [Details] | |
+| Time to reverse | [Duration] | |
+| Financial cost to reverse | [Cost] | |
+| Reputation impact of reversal | [Impact] | |
+| Dependencies affected | [Count/scope] | |
+| Learning lost if reversed | [Value] | |
+
+Average: [X]
+- 1-2: Clear Type 2
+- 3: Type 1.5
+- 4-5: Type 1
+
+## Decision Type: [Type 1 / 1.5 / 2]
+
+## Appropriate Process
+- Analysis depth: [Minimal / Moderate / Extensive]
+- Surface to human owner before committing? [No / Yes if high-stakes / Yes]
+- Documentation: [None / Brief / Full]
+
+## Can We Increase Reversibility?
+- Pilot: [Option]
+- Abstraction: [Option]
+- Time-box: [Option]
+- Feature flag: [Option]
+
+## Decision
+[The choice made]
+
+## Reversal Plan (if needed)
+[How we would reverse if this proves wrong]
+```
+
+## Verification Checklist
+
+- [ ] Assessed reversibility across multiple factors
+- [ ] Categorized as Type 1, 1.5, or 2
+- [ ] Matched decision process to decision type
+- [ ] Explored options to increase reversibility
+- [ ] Not over-analyzing Type 2 decisions
+- [ ] Not under-analyzing Type 1 decisions
+- [ ] Have a reversal plan for non-trivial decisions
+
+## Key Questions
+
+- "How hard would it be to undo this?"
+- "Are we treating this like a one-way door when it's actually two-way?"
+- "Can we pilot this to make it more reversible?"
+- "What's the cost of being wrong vs. the cost of delay?"
+- "Who else would be affected if we reverse?"
+- "Is this actually irreversible, or does it just feel that way?"
+
+## Bezos' Wisdom
+
+"Some decisions are consequential and irreversible or nearly irreversible – one-way doors – and these decisions must be made methodically, carefully, slowly, with great deliberation and consultation."
+
+"But most decisions aren't like that – they are changeable, reversible – they're two-way doors. If you've made a suboptimal Type 2 decision, you don't have to live with the consequences for that long. You can reopen the door and go back through."
+
+"As organizations get larger, there seems to be a tendency to use the heavy-weight Type 1 decision-making process on most decisions, including many Type 2 decisions. The end result of this is slowness, unthoughtful risk aversion, failure to experiment sufficiently, and consequently diminished invention."
+
+Speed matters. Most decisions are reversible. Decide, learn, adjust.