My Git-Based Decision Tracker

Most developers treat their career and life choices like a series of random commits to a main branch, but we never actually run a diff on our judgment. We make a call based on a gut feeling, and six months later, we rewrite the history in our heads to make it seem like we knew what we were doing all along.

To fix this, I built a tool called Forkcast. It basically applies Git version control logic to life decisions so you can actually track your prediction accuracy over time.

The Logic Behind the Workflow

The mental model is straightforward: when you hit a crossroads, you don't just choose; you branch.

• Branching: You create a fork for every viable path.
• Committing: You log a prediction and a confidence percentage (e.g., "I'm 70% sure this move is the right call").
• Merging: You pick the path you actually take.
• Scoring: You return months later to rate the actual outcome.

It turns your life into a personal prediction market. Instead of wondering if you're good at making bets, you have a logged track record showing you're, for example, 80% accurate on technical stacks but only 30% accurate on financial risks.

Technical Implementation

I structured the data to mirror a Git history. When a decision is created, it's an open 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'),
 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', 
};

The critical part is the "commit" phase. This is where you lock in your reasoning before the outcome is known, preventing "hindsight bias."

const prediction: Prediction = {
 decisionId: decision.id,
 chosenBranch: 'branch-stay',
 confidence: 72, 
 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, 
 committedAt: new Date(),
};

This is essentially a deep dive into personal accountability. By treating life decisions as a deployment process—where you explore options in a branch and then merge into production—you stop guessing about your decision-making skills and start measuring them.