👨‍💼 Manager (micromanager)
👨‍💻 Senior Developer (copy-paste expert)
👨‍💻 Mid Developer #1
👨‍💻 Mid Developer #2
👨‍💻 Mid Developer #3
👨‍💻 Junior Developer #1
👨‍💻 Junior Developer #2
🏗️ Ja (Architect/Team Lead)

Total: 8 people
Output: Chaos

interface Developer {
  yearsOfExperience: number;
  actualSkillLevel: SkillLevel;
  willingnessToLearn: boolean;
  bugProduction: number;
  codeQuality: Quality;
}

const inventoryDev: Developer = {
  yearsOfExperience: 15,
  actualSkillLevel: SkillLevel.JUNIOR,  // Harsh truth
  willingnessToLearn: false,
  bugProduction: 10,  // bugs per week
  codeQuality: Quality.LEGACY
};

const juniorDev: Developer = {
  yearsOfExperience: 1,
  actualSkillLevel: SkillLevel.MID,  // Fast learner!
  willingnessToLearn: true,
  bugProduction: 2,
  codeQuality: Quality.MODERN
};

// Math
if (inventoryDev.bugProduction > inventoryDev.value) {
  team.remove(inventoryDev);  // Painful but necessary
}

15 rokov skúseností ≠ 15 rokov vývoja
15 rokov skúseností = 1 rok skúseností × 15

Rozdiel:
15× learning & improving vs 15× repeat year 1

const newJunior: Developer = {
  yearsOfExperience: 0.5,
  actualSkillLevel: SkillLevel.JUNIOR,
  willingnessToLearn: true,  // 🔥 Key factor
  motivation: 100,
  questionAsking: "constantly",  // Good sign!
  codeQuality: Quality.IMPROVING_DAILY
};

const formerJunior: Developer = {
  yearsOfExperience: 1,
  actualSkillLevel: SkillLevel.MID_TO_SENIOR,  // 🚀
  willingnessToLearn: true,
  motivation: 100,
  codeQuality: Quality.SOLID_PRINCIPLES,
  canMentorOthers: true  // Bonus!
};

// Growth rate
const growthRate = (formerJunior.skillLevel - newJunior.skillLevel)
                   / timeInMonths;
// Result: 1.5 levels per 6 months = FAST

🏗️ Ondrej (Solution Architect / Team Lead)
   → Architecture decisions
   → Code review
   → Mentoring
   → Crisis management

👨‍💻 Senior Developer (bývalý junior, rýchlo sa vypracoval)
   → Feature development
   → Complex implementations
   → Technical research
   → Peer programming

👨‍💼 Product Owner + Tester (2-in-1 superhero)
   → Requirements
   → Testing
   → Customer communication
   → Priorities

Total: 3 people
Output: 🚀 Higher than 7-person team

// Team of 7 (old)
const oldTeam = {
  developers: 6,
  communication_overhead: 0.5,  // 50% času na meetings
  code_conflicts: 0.3,          // 30% času na merge conflicts
  bug_fixing_old_code: 0.4,     // 40% času na fixing bugs
  actual_development: 0.2       // Len 20% času na vývoj!
};

// Team of 3 (new)
const newTeam = {
  developers: 2,
  communication_overhead: 0.1,   // 10% času
  code_conflicts: 0.05,          // 5% času
  bug_fixing_old_code: 0.05,     // 5% času (dobrý kód)
  actual_development: 0.8        // 80% času na vývoj! 🎉
};

// Productivity
oldTeam.productivity = 7 × 0.2 = 1.4 effective developers
newTeam.productivity = 2 × 0.8 = 1.6 effective developers

// Winner: 3-person team je produktívnejší!

Team of 7:
Communication channels = n × (n-1) / 2 = 7 × 6 / 2 = 21 channels
Daily sync: 21 possible conversations

Team of 3:
Communication channels = 3 × 2 / 2 = 3 channels
Daily sync: "Hey guys, quick update?" Done.

def team_output(developers):
    if all(dev.skill_level == "high" and dev.motivated):
        return len(developers) * 2.5  # Synergy effect
    else:
        return len(developers) * 0.5  # Drag effect

# Old team (mixed skill)
output_old = team_output([high, high, low, low, low, low, low])
# = 7 × 0.5 = 3.5 units

# New team (all high)
output_new = team_output([high, high])
# = 2 × 2.5 = 5 units

# New team wins!

type Experience = {
  years: number;
  learningCurve: 'growing' | 'flat';
};

// Developer A
const devA: Experience = {
  years: 15,
  learningCurve: 'flat'  // Learned once, repeated 15×
};

// Developer B
const devB: Experience = {
  years: 2,
  learningCurve: 'growing'  // Learning daily
};

// After 2 years
devB.actualSkill > devA.actualSkill  // Often true!

def hire_decision(candidate):
    if candidate.attitude == "willing_to_learn":
        return "HIRE"  # Can teach skills
    elif candidate.experience > 10 and candidate.attitude == "know_it_all":
        return "PASS"  # Can't teach attitude
    else:
        return "MAYBE"

# Priority
attitude > experience > certificates

// Without refactoring
const timeToImplementFeature = (complexity: number) => {
  return complexity × technicalDebt × 10;  // 10× slower
};

// After refactoring
const timeToImplementFeature = (complexity: number) => {
  return complexity × 1;  // Clean codebase
};

// ROI calculation
const refactoringTime = 2; // weeks
const featuresPerYear = 50;
const timeSavedPerFeature = 0.5; // weeks

const totalTimeSaved = featuresPerYear × timeSavedPerFeature;
// = 50 × 0.5 = 25 weeks saved

const roi = (totalTimeSaved - refactoringTime) / refactoringTime;
// = (25 - 2) / 2 = 11.5× return!

The mythical man-month is real!

9 žien nemôže porodiť dieťa za 1 mesiac.
9 developerov nemôže spraviť 1-týždeň projekt za 1 deň.

Sweet spot: 2-4 developers
- Can communicate effortlessly
- Can share knowledge easily
- Can maintain consistent code style
- Can actually get stuff done

interface TeamHealth {
  morale: number;      // 0-100
  productivity: number;
  turnover: number;
}

// With toxic person
const before: TeamHealth = {
  morale: 30,
  productivity: 40,
  turnover: 60  // People leaving
};

// After removal
const after: TeamHealth = {
  morale: 85,
  productivity: 90,
  turnover: 5
};

// Math
const improvement = (after.productivity - before.productivity)
                    / before.productivity;
// = (90 - 40) / 40 = 125% improvement!