A Productivity System That Scales With Your Career

// ❌ Flat task list — everything at the same priority level
interface FlatSystem {
  tasks: string[];
  // No distinction between "fix this bug" and "evaluate team hiring plan"
}
 
// ✅ Layered system — different timeframes, different decision models
interface ProductivitySystem {
  execution: {
    dailyFocus: string[];          // 3-5 concrete tasks
    timeBlocks: TimeBlock[];       // Calendar structure
    energyTracking: EnergyLevel;   // When you do best work
  };
  planning: {
    weeklyGoals: Goal[];           // 2-3 outcomes per week
    reviewCadence: "friday";       // Retrospective
    backlog: PrioritizedItem[];    // Ranked by impact
  };
  strategy: {
    quarterlyThemes: string[];     // What matters most this quarter
    skillInvestments: string[];    // Areas of deliberate growth
    roleAlignment: RoleExpectation[];
  };
}
 
interface TimeBlock {
  start: string;
  end: string;
  type: "deep-work" | "meetings" | "admin" | "learning";
  flexibility: "fixed" | "movable";
}
 
interface Goal {
  description: string;
  keyResults: string[];
  status: "not-started" | "in-progress" | "completed" | "blocked";
}

type WorkMode = "deep" | "shallow" | "collaborative" | "recovery";
 
interface WorkBlock {
  mode: WorkMode;
  duration: number; // minutes
  tasks: string[];
  prerequisites: string[];
}
 
function buildDaySchedule(
  role: "ic" | "senior" | "lead" | "manager",
  meetings: Meeting[]
): WorkBlock[] {
  const meetingSlots = meetings.map((m) => ({
    start: m.startTime,
    end: m.endTime,
  }));
 
  const freeSlots = findFreeSlots(meetingSlots, "09:00", "18:00");
 
  const blocks: WorkBlock[] = [];
 
  // Protect the longest free slot for deep work
  const longestSlot = freeSlots.sort(
    (a, b) => slotDuration(b) - slotDuration(a)
  )[0];
 
  if (longestSlot && slotDuration(longestSlot) >= 90) {
    blocks.push({
      mode: "deep",
      duration: slotDuration(longestSlot),
      tasks: getHighestPriorityDeepWork(role),
      prerequisites: ["notifications-off", "status-dnd"],
    });
  }
 
  // Batch shallow work into remaining slots
  const shortSlots = freeSlots.filter(
    (s) => slotDuration(s) >= 15 && slotDuration(s) < 90
  );
 
  for (const slot of shortSlots) {
    blocks.push({
      mode: "shallow",
      duration: slotDuration(slot),
      tasks: getShallowWork(role),
      prerequisites: [],
    });
  }
 
  // Add recovery blocks after long meetings
  for (const meeting of meetings) {
    if (meeting.duration >= 60) {
      blocks.push({
        mode: "recovery",
        duration: 15,
        tasks: ["process-notes", "update-action-items"],
        prerequisites: [],
      });
    }
  }
 
  return blocks;
}

interface PrioritizationCriteria {
  role: string;
  factors: Factor[];
}
 
interface Factor {
  name: string;
  weight: number;
  evaluate: (task: Task) => number;
}
 
const icPrioritization: PrioritizationCriteria = {
  role: "individual-contributor",
  factors: [
    {
      name: "technical-impact",
      weight: 0.4,
      evaluate: (task) => task.codebaseImpact,
    },
    {
      name: "deadline-proximity",
      weight: 0.3,
      evaluate: (task) => 1 / daysUntilDeadline(task),
    },
    {
      name: "learning-value",
      weight: 0.2,
      evaluate: (task) => task.skillGrowthPotential,
    },
    {
      name: "dependency-chain",
      weight: 0.1,
      evaluate: (task) => task.blockedItems.length,
    },
  ],
};
 
const leadPrioritization: PrioritizationCriteria = {
  role: "tech-lead",
  factors: [
    {
      name: "team-unblocking",
      weight: 0.35,
      evaluate: (task) => task.teamMembersBlocked,
    },
    {
      name: "strategic-alignment",
      weight: 0.30,
      evaluate: (task) => task.quarterlyGoalAlignment,
    },
    {
      name: "technical-risk",
      weight: 0.20,
      evaluate: (task) => task.riskScore,
    },
    {
      name: "individual-contribution",
      weight: 0.15,
      evaluate: (task) => task.codebaseImpact,
    },
  ],
};
 
function prioritize(
  tasks: Task[],
  criteria: PrioritizationCriteria
): Task[] {
  return tasks
    .map((task) => ({
      task,
      score: criteria.factors.reduce(
        (total, factor) => total + factor.weight * factor.evaluate(task),
        0
      ),
    }))
    .sort((a, b) => b.score - a.score)
    .map(({ task }) => task);
}

interface WeeklyReview {
  completedGoals: Goal[];
  incompleteGoals: Goal[];
  surprises: string[];
  nextWeekPriorities: string[];
  systemAdjustments: string[];
}
 
function conductWeeklyReview(
  weekPlan: WeeklyPlan,
  actualOutcomes: Outcome[]
): WeeklyReview {
  const completed = weekPlan.goals.filter(
    (g) => g.status === "completed"
  );
  const incomplete = weekPlan.goals.filter(
    (g) => g.status !== "completed"
  );
 
  // Identify work that wasn't planned but consumed time
  const unplannedWork = actualOutcomes.filter(
    (o) => !weekPlan.goals.some((g) => g.id === o.goalId)
  );
 
  const review: WeeklyReview = {
    completedGoals: completed,
    incompleteGoals: incomplete,
    surprises: unplannedWork.map(
      (w) => `${w.description} consumed ${w.hoursSpent}h`
    ),
    nextWeekPriorities: deriveNextWeekPriorities(
      incomplete,
      weekPlan.quarterlyThemes
    ),
    systemAdjustments: [],
  };
 
  // Detect patterns that need system changes
  if (unplannedWork.length > completed.length) {
    review.systemAdjustments.push(
      "Too much reactive work — add buffer blocks to schedule"
    );
  }
 
  if (incomplete.length > completed.length) {
    review.systemAdjustments.push(
      "Overcommitting on weekly goals — reduce to 2 per week"
    );
  }
 
  return review;
}

type RoleLevel = "ic" | "senior" | "lead" | "manager";
 
const timeAllocation: Record<RoleLevel, {
  execution: number;
  planning: number;
  strategy: number;
}> = {
  ic:      { execution: 0.80, planning: 0.15, strategy: 0.05 },
  senior:  { execution: 0.65, planning: 0.25, strategy: 0.10 },
  lead:    { execution: 0.45, planning: 0.30, strategy: 0.25 },
  manager: { execution: 0.25, planning: 0.35, strategy: 0.40 },
};
 
function auditTimeAllocation(
  role: RoleLevel,
  actualHours: { execution: number; planning: number; strategy: number }
): string[] {
  const target = timeAllocation[role];
  const total =
    actualHours.execution + actualHours.planning + actualHours.strategy;
 
  const suggestions: string[] = [];
 
  const executionRatio = actualHours.execution / total;
  if (executionRatio > target.execution + 0.15) {
    suggestions.push(
      `Spending ${Math.round(executionRatio * 100)}% on execution — ` +
      `target is ${Math.round(target.execution * 100)}%. ` +
      `Delegate or automate some execution work.`
    );
  }
 
  const strategyRatio = actualHours.strategy / total;
  if (strategyRatio < target.strategy - 0.10) {
    suggestions.push(
      `Only ${Math.round(strategyRatio * 100)}% on strategy — ` +
      `invest more time in quarterly planning and career direction.`
    );
  }
 
  return suggestions;
}