Every developer knows the power of git branch. You experiment without fear, revert mistakes, and merge only what works.
But what if you could do the same thing with life decisions?
That's exactly what I built. And it's called Forkcast.
The Problem Nobody Talks About
We all face major crossroads:
- Should I take this job offer or stay?
- Should I learn Rust or Go next?
- Should I co-found this startup or keep freelancing?
- Should I move cities for that opportunity?
We make these calls based on gut feeling, maybe a pros/cons list, and then... we never look back to evaluate how good our judgment actually was.
Think about it. Do you actually know if you're a good decision-maker? Or do you just assume you are because you can't remember the bad calls?
There's no version control for decisions. No diff. No blame. No history. No accountability.
Until now.
Introducing Forkcast
Forkcast is a decision-tracking app that uses Git metaphors to help you:
- Branch — Create a fork when you face a major choice (two or more paths)
- Commit — Log your prediction with a confidence level ("I'm 80% sure taking this job is the right call")
- Merge — Pick the path you actually take
- Score — Come back months later and honestly rate how it went. Let time be the judge.
Over time, you build a track record of your own judgment. You discover patterns:
- "I'm consistently overconfident about career moves"
- "My technical bets are actually solid — 75% accuracy"
- "I should stop trusting my gut on financial decisions"
It's a personal prediction market — with the UX of a Git client.
Why Git Metaphors?
Because developers already think in branches. The mental model is instant:
| Git Concept | Forkcast Equivalent |
|---|---|
git branch |
Create a decision fork |
git commit -m "prediction" |
Log what you think will happen |
git merge |
Pick the path you're taking |
git log |
Review your decision history |
git blame |
See which "you" made that call |
git diff |
Compare what you predicted vs. what happened |
git revert |
Acknowledge a bad decision and course-correct |
The metaphor isn't forced — it genuinely maps 1:1 to how decisions work. You explore options (branches), commit to one (merge), and live with the consequences (production).
How It Actually Works
Creating a Decision Fork
When you hit a crossroads, you create a new fork:
const decision: Decision = {
id: crypto.randomUUID(),
title: "Accept Google offer vs. stay at current startup",
createdAt: new Date(),
deadline: new Date('2025-09-01'), // When I need to decide by
branches: [
{
id: 'branch-google',
name: 'Accept Google Offer',
description: 'L4 SWE role, Mountain View, $320k TC',
predictedOutcome: 'Stable career growth, learn at scale, but less ownership',
},
{
id: 'branch-stay',
name: 'Stay at Startup',
description: 'Early engineer, equity potential, wearing many hats',
predictedOutcome: 'Higher risk, higher potential reward, more learning',
},
],
status: 'open', // open → committed → scored
};
Committing Your Prediction
Before you decide, you log what you think will happen for each path:
const prediction: Prediction = {
decisionId: decision.id,
chosenBranch: 'branch-stay',
confidence: 72, // "I'm 72% sure staying is the right call"
reasoning: `
The startup has product-market fit, we're growing 20% MoM.
If we hit Series A in 6 months, my equity is worth more than
2 years of Google salary. Risk is manageable.
`,
predictedScore: 8, // On a 1-10 scale, I expect this to be an 8/10 decision
committedAt: new Date(),
};
This is the magic moment. You're writing down exactly what you believe so Future You can't rewrite history.
Merging — The Decision Is Made
You pick your path. The fork is merged. No going back.
decision.status = 'committed';
decision.mergedBranch = 'branch-stay';
decision.mergedAt = new Date();
Scoring — Time Is the Judge
3 months, 6 months, a year later — you come back and score:
const outcome: Outcome = {
decisionId: decision.id,
actualScore: 6, // Honest rating: 6/10
reflection: `
Startup didn't hit Series A. Pivoted twice. Learning was incredible
but financially it was neutral. Google would have been more stable.
My confidence of 72% was too high — should have been 50/50.
`,
scoredAt: new Date(),
calibrationDelta: prediction.confidence - 60, // I was 12% overconfident
};
Now you have data on your own judgment. Not a feeling. Data.
The Dashboard — Your Decision History
Over time, Forkcast builds a visual picture of your decision-making:
Calibration Chart
A graph showing your predicted confidence vs. actual outcomes. Perfect calibration = the diagonal line. If you say "80% confident" and you're right 80% of the time, you're well-calibrated.
Most people discover they're overconfident by 15-25%. Knowing this is incredibly valuable.
Decision Timeline
A git-log-style timeline showing:
- Open forks (decisions you haven't made yet)
- Committed decisions (waiting to be scored)
- Scored decisions (color-coded: green = good call, yellow = okay, red = regret)
Pattern Detection
After 10+ scored decisions, Forkcast identifies patterns:
- "You score highest on technical decisions (avg: 7.8/10)"
- "Career decisions average 5.2/10 — consider seeking more external input"
- "You consistently underestimate switching costs"
The Technical Architecture
Stack
| Layer | Technology |
|---|---|
| Frontend | Next.js 14 (App Router) + TypeScript |
| Styling | Tailwind CSS + Framer Motion for animations |
| State | Zustand (local-first, persists to localStorage) |
| Data | IndexedDB via Dexie.js (all data stays on device) |
| Charts | Recharts for calibration visualizations |
| Deployment | Vercel (static, no server needed) |
Why Local-First?
Your life decisions are deeply personal. They shouldn't sit on someone else's server. Forkcast stores everything in your browser's IndexedDB:
- Zero server costs
- Zero data breaches
- Works offline
- Export as JSON anytime
- Optional: sync to your own cloud via CRDTs (planned)
// Dexie.js schema
const db = new Dexie('ForkcastDB');
db.version(1).stores({
decisions: '++id, title, status, createdAt, mergedAt',
predictions: '++id, decisionId, confidence, committedAt',
outcomes: '++id, decisionId, actualScore, scoredAt',
});
The Git-Style UI
The interface mimics familiar Git tools:
┌─────────────────────────────────────────────────┐
│ FORKCAST — Your Decision History │
├─────────────────────────────────────────────────┤
│ │
│ ● ─── Accept Google Offer (abandoned) │
│ │ │
│ ├─┐ "Accept Google vs. Stay at Startup" │
│ │ │ Confidence: 72% → Actual: 6/10 │
│ │ │ Calibration: -12% (overconfident) │
│ │ │ │
│ ● ─── Stay at Startup (merged) ✓ │
│ │ │
│ │ │
│ ● ─── Learn Rust (active) │
│ │ │
│ ├─┐ "Rust vs. Go for systems work" │
│ │ │ Confidence: 65% │
│ │ │ Status: COMMITTED — awaiting score │
│ │ │ │
│ ● ─── Learn Go (abandoned) │
│ │
└─────────────────────────────────────────────────┘
The Psychology Behind It
Forkcast is built on three cognitive science principles:
1. Hindsight Bias Elimination
Humans are terrible at remembering what they actually believed before an outcome. Once we know the result, we convince ourselves "I knew it all along."
By writing predictions down before deciding, you can't gaslight yourself later.
2. Calibration Training
Research shows that prediction calibration is a trainable skill. Weather forecasters, for example, become excellently calibrated because they get fast, frequent feedback.
Forkcast gives you that feedback loop for life decisions — which normally have zero feedback mechanism.
3. The Mere Measurement Effect
The act of formally writing down a prediction changes how carefully you think about it. You can't just type "80% confident" without actually asking yourself "Am I really 80% sure?"
The tool makes you think harder just by existing.
Who Is This For?
Forkcast is for you if:
- You're at a career crossroads and want to think more clearly
- You're a founder making high-stakes bets weekly
- You're interested in rationality, calibration, or decision science
- You want to look back in 5 years with data, not just fuzzy memories
- You're a developer who appreciates the git metaphor
It's probably not for you if:
- You prefer to live spontaneously without reflection
- You're not comfortable being honest with yourself about outcomes
- You think decisions can't be scored (they can — it's called regret)
Get Started
Try It
git clone https://github.com/Tech-aficionado/Forkcast---Open-Source-Git.git
cd Forkcast---Open-Source-Git
npm install
npm run dev
Open localhost:3000. Create your first fork. Commit a prediction. Set a reminder to come back and score it.
Deploy Your Own
One-click deploy to Vercel:
Your data stays in YOUR browser. The deployment is just a static site.
What's on the Roadmap
- Decision templates — Pre-built frameworks for career, financial, technical, and relationship decisions
- Reminder system — "Hey, you made a decision 6 months ago. Time to score it."
- Export to Markdown — Generate a personal "decision journal" you can keep in Obsidian/Notion
- CRDT sync — Optionally sync across devices without a central server
- AI reflection — Plug in an LLM to challenge your reasoning before you commit
- Team mode — Make group decisions with separate prediction commits from each member
The Source
- GitHub: github.com/Tech-aficionado/Forkcast---Open-Source-Git
- License: MIT
- Stack: TypeScript (96.9%) + CSS (3.0%) + JavaScript (0.1%)
- Philosophy: Local-first, privacy-respecting, no accounts required
Final Thought
You git log your code changes. You git blame bad commits. You git revert mistakes.
But for the decisions that actually shape your life — career moves, city changes, relationship choices, financial bets — you have zero version history.
You're essentially running rm -rf on your decision-making data every time you forget what you originally believed.
Forkcast fixes that. It gives you a commit history for your judgment.
And after a year of using it? You won't just think you're a good decision-maker. You'll know — with data.
What's a decision you made in the last year that you wish you'd tracked? Drop it in the comments. I'll share mine.
Built by Shivansh Goel — AI & Full Stack Developer building tools that make humans think more clearly.
Top comments (0)