5 Mistakes That Cost Me $50k in 2026 Job Offers: A Career Lesson

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "os"
    "time"
)

// Offer represents a 4-year tech job offer with standard US benefits
type Offer struct {
    Company      string  `json:"company"`
    BaseSalary   float64 `json:"base_salary"`
    BonusTarget  float64 `json:"bonus_target"` // Percentage of base, e.g., 30 for 30%
    RSUTotal     float64 `json:"rsu_total"`    // Total RSU grant over 4 years
    RSUCliff     float64 `json:"rsu_cliff"`    // Percentage cliff in year 1, e.g., 25 for 25%
    RSUGrowth    float64 `json:"rsu_growth"`   // Annual RSU value growth, e.g., 10 for 10%
    Match401k    float64 `json:"match_401k"`   // Percentage match, e.g., 5 for 5%
    MatchCap     float64 `json:"match_cap"`    // Annual cap on 401k match, e.g., 10000
    SigningBonus float64 `json:"signing_bonus"`
}

// CalculateTotalComp returns 4-year total compensation, accounting for vesting and growth
func CalculateTotalComp(o Offer) (float64, error) {
    if o.BaseSalary <= 0 {
        return 0, fmt.Errorf("base salary must be positive")
    }
    if o.BonusTarget < 0 || o.BonusTarget > 100 {
        return 0, fmt.Errorf("bonus target must be between 0 and 100")
    }

    // Standard RSU vesting: 1-year cliff, then equal monthly vesting for remaining 3 years
    // Year 1 RSU: (o.RSUCliff / 100) * o.RSUTotal
    // Years 2-4: ((100 - o.RSUCliff)/100 * o.RSUTotal) / 3 each year
    year1RSU := (o.RSUCliff / 100) * o.RSUTotal
    year2to4RSU := ((100 - o.RSUCliff) / 100 * o.RSUTotal) / 3

    // Apply annual RSU growth to years 2-4
    year2RSU := year2to4RSU * (1 + o.RSUGrowth/100)
    year3RSU := year2to4RSU * pow(1 + o.RSUGrowth/100, 2)
    year4RSU := year2to4RSU * pow(1 + o.RSUGrowth/100, 3)

    // Bonus is target % of base, assume 100% payout for simplicity
    annualBonus := o.BaseSalary * (o.BonusTarget / 100)

    // 401k match: annual, capped
    annual401k := min(o.BaseSalary*0.01*o.Match401k, o.MatchCap)

    // Total 4-year comp
    total := o.BaseSalary + o.SigningBonus // Year 1 base + signing
    total += o.BaseSalary * 3 // Years 2-4 base
    total += annualBonus * 4
    total += year1RSU + year2RSU + year3RSU + year4RSU
    total += annual401k * 4

    return total, nil
}

func min(a, b float64) float64 {
    if a < b {
        return a
    }
    return b
}

func pow(a float64, b float64) float64 {
    result := 1.0
    for i := 0; i < int(b); i++ {
        result *= a
    }
    return result
}

func main() {
    if len(os.Args) < 2 {
        log.Fatal("Usage: go run main.go ")
    }

    file, err := os.Open(os.Args[1])
    if err != nil {
        log.Fatalf("Failed to open file: %v", err)
    }
    defer file.Close()

    var offer Offer
    decoder := json.NewDecoder(file)
    if err := decoder.Decode(&offer); err != nil {
        log.Fatalf("Failed to parse JSON: %v", err)
    }

    totalComp, err := CalculateTotalComp(offer)
    if err != nil {
        log.Fatalf("Invalid offer data: %v", err)
    }

    fmt.Printf("4-Year Total Compensation for %s: $%.2f\n", offer.Company, totalComp)
}

import json
import random
from typing import Dict, List, Optional

class OfferNegotiator:
    """Simulates negotiation outcomes for tech job offers based on 2026 Levels.fyi data."""

    def __init__(self, initial_offer: Dict):
        self.initial = initial_offer
        self.current = initial_offer.copy()
        self.negotiation_history: List[str] = []

    def validate_offer(self) -> None:
        """Validate that the initial offer has required fields."""
        required = ["base", "bonus_target", "rsu_total", "signing"]
        for field in required:
            if field not in self.initial:
                raise ValueError(f"Missing required field: {field}")
            if self.initial[field] <= 0:
                raise ValueError(f"Field {field} must be positive")

    def counter_base(self, increase_pct: float) -> None:
        """Counter offer with a base salary increase."""
        if increase_pct <= 0 or increase_pct > 20:
            raise ValueError("Base increase must be between 0 and 20%")
        new_base = self.current["base"] * (1 + increase_pct / 100)
        self.negotiation_history.append(f"Counter base: +{increase_pct}% (${self.current['base']:.2f} -> ${new_base:.2f})")
        self.current["base"] = new_base

    def counter_rsu(self, increase_pct: float) -> None:
        """Counter offer with RSU grant increase."""
        if increase_pct <= 0 or increase_pct > 30:
            raise ValueError("RSU increase must be between 0 and 30%")
        new_rsu = self.current["rsu_total"] * (1 + increase_pct / 100)
        self.negotiation_history.append(f"Counter RSU: +{increase_pct}% (${self.current['rsu_total']:.2f} -> ${new_rsu:.2f})")
        self.current["rsu_total"] = new_rsu

    def counter_signing(self, amount: float) -> None:
        """Counter offer with signing bonus increase."""
        if amount <= 0 or amount > 50000:
            raise ValueError("Signing increase must be between $0 and $50k")
        new_signing = self.current["signing"] + amount
        self.negotiation_history.append(f"Counter signing: +${amount:.2f} (${self.current['signing']:.2f} -> ${new_signing:.2f})")
        self.current["signing"] = new_signing

    def simulate_company_response(self) -> str:
        """Simulate company response based on 2026 negotiation data: 68% accept counters, 22% counter back, 10% revoke."""
        rand = random.uniform(0, 1)
        if rand < 0.68:
            return "accepted"
        elif rand < 0.90:
            return "countered"
        else:
            return "revoked"

    def calculate_total_comp(self) -> float:
        """Calculate 4-year total comp using same logic as Go example."""
        base = self.current["base"]
        bonus = base * (self.current["bonus_target"] / 100) * 4
        rsu = self.current["rsu_total"]
        signing = self.current["signing"]
        return base * 4 + bonus + rsu + signing  # Simplified, no 401k for brevity

    def run_negotiation(self, counters: List[Dict]) -> Dict:
        """Run a full negotiation flow with multiple counters."""
        self.validate_offer()
        for counter in counters:
            counter_type = counter.get("type")
            value = counter.get("value")
            try:
                if counter_type == "base":
                    self.counter_base(value)
                elif counter_type == "rsu":
                    self.counter_rsu(value)
                elif counter_type == "signing":
                    self.counter_signing(value)
                else:
                    raise ValueError(f"Unknown counter type: {counter_type}")
            except ValueError as e:
                print(f"Invalid counter: {e}")
                continue

            response = self.simulate_company_response()
            self.negotiation_history.append(f"Company response: {response}")
            if response == "revoked":
                print("Offer revoked!")
                break
            elif response == "countered":
                # Company counters with 50% of requested increase
                if counter_type == "base":
                    self.current["base"] = self.current["base"] * (1 + (value/100)*0.5)
                elif counter_type == "rsu":
                    self.current["rsu_total"] = self.current["rsu_total"] * (1 + (value/100)*0.5)
                elif counter_type == "signing":
                    self.current["signing"] += value * 0.5
        return self.current

if __name__ == "__main__":
    initial_offer = {
        "base": 180000,
        "bonus_target": 20,
        "rsu_total": 120000,
        "signing": 10000
    }
    negotiator = OfferNegotiator(initial_offer)
    counters = [
        {"type": "base", "value": 10},
        {"type": "rsu", "value": 15},
        {"type": "signing", "value": 5000}
    ]
    final_offer = negotiator.run_negotiation(counters)
    print(f"Final offer: {json.dumps(final_offer, indent=2)}")
    print(f"Total comp: ${negotiator.calculate_total_comp():.2f}")

import { Command } from 'commander';
import * as fs from 'fs/promises';
import * as path from 'path';

interface InterviewMistake {
    id: string;
    date: string;
    company: string;
    mistakeType: 'negotiation' | 'signals' | 'comp_structure' | 'follow_up' | 'prep';
    costEstimate: number; // Estimated $ lost
    description: string;
    fixed: boolean;
}

interface MistakeTrackerConfig {
    storagePath: string;
    userId: string;
}

class MistakeTracker {
    private config: MistakeTrackerConfig;
    private mistakes: InterviewMistake[] = [];

    constructor(config: MistakeTrackerConfig) {
        this.config = config;
    }

    async loadMistakes(): Promise {
        try {
            const data = await fs.readFile(this.config.storagePath, 'utf-8');
            this.mistakes = JSON.parse(data) as InterviewMistake[];
        } catch (err: any) {
            if (err.code === 'ENOENT') {
                // File doesn't exist, start with empty array
                this.mistakes = [];
                await this.saveMistakes();
            } else {
                throw new Error(`Failed to load mistakes: ${err.message}`);
            }
        }
    }

    async saveMistakes(): Promise {
        await fs.mkdir(path.dirname(this.config.storagePath), { recursive: true });
        await fs.writeFile(this.config.storagePath, JSON.stringify(this.mistakes, null, 2));
    }

    addMistake(mistake: Omit): InterviewMistake {
        const newMistake: InterviewMistake = {
            ...mistake,
            id: `mistake_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
        };
        this.mistakes.push(newMistake);
        return newMistake;
    }

    listMistakes(filterFixed: boolean = false): InterviewMistake[] {
        if (filterFixed) {
            return this.mistakes.filter(m => !m.fixed);
        }
        return this.mistakes;
    }

    calculateTotalLoss(): number {
        return this.mistakes.reduce((sum, m) => sum + m.costEstimate, 0);
    }

    async markFixed(id: string): Promise {
        const mistake = this.mistakes.find(m => m.id === id);
        if (!mistake) {
            throw new Error(`Mistake with id ${id} not found`);
        }
        mistake.fixed = true;
    }
}

const program = new Command();

program.name('mistake-tracker').description('Track job interview mistakes to avoid losing offer value');

program.command('add')
    .requiredOption('-c, --company ', 'Company name')
    .requiredOption('-t, --type ', 'Mistake type (negotiation|signals|comp_structure|follow_up|prep)')
    .requiredOption('-e, --cost ', 'Estimated cost in USD')
    .requiredOption('-d, --description ', 'Mistake description')
    .option('-f, --fixed', 'Mark as fixed')
    .action(async (opts) => {
        const tracker = new MistakeTracker({ storagePath: './mistakes.json', userId: 'user1' });
        await tracker.loadMistakes();
        const mistake = tracker.addMistake({
            date: new Date().toISOString().split('T')[0],
            company: opts.company,
            mistakeType: opts.type as any,
            costEstimate: parseFloat(opts.cost),
            description: opts.description,
            fixed: opts.fixed || false,
        });
        await tracker.saveMistakes();
        console.log(`Added mistake: ${mistake.id}`);
    });

program.command('list')
    .option('-u, --unfixed', 'Only show unfixed mistakes')
    .action(async (opts) => {
        const tracker = new MistakeTracker({ storagePath: './mistakes.json', userId: 'user1' });
        await tracker.loadMistakes();
        const mistakes = tracker.listMistakes(opts.unfixed);
        console.log(`Total mistakes: ${mistakes.length}`);
        console.log(`Total loss: $${tracker.calculateTotalLoss()}`);
        mistakes.forEach(m => {
            console.log(`[${m.fixed ? 'FIXED' : 'OPEN'}] ${m.date} ${m.company}: ${m.description} ($${m.costEstimate})`);
        });
    });

program.parse();

curl -H "Accept: application/vnd.github+json" https://api.github.com/users/yourusername/repos?per_page=100 | jq '[.[] | {name: .name, stars: .stargazers_count, fork: .fork}] | sort_by(-.stars)'

negotiation_templates = {
    "base": "I'm excited about the role, but my research shows base salaries for senior engineers at {company} are 10% higher than the offer. Can we adjust to ${new_base}?",
    "rsu": "The RSU grant is lower than competing offers. Can we increase to ${new_rsu} to match market rates?"
}

## Interview Debrief: {Company} {Date}
### Team Fit Signals
- [ ] Manager mentioned on-call rotation is 1 week/quarter
- [ ] Team uses Go 1.23 PGO, which I have experience with
### Red Flags
- [ ] No 401k match
- [ ] RSU cliff is 2 years