How to Become a Tech Lead Using High Output Management 2026 and The Manager's Path 2.0

import csv
import json
from dataclasses import dataclass, field
from typing import List, Optional, Dict, Tuple
from enum import Enum

class TaskPriority(Enum):
    CRITICAL = 'critical'
    HIGH = 'high'
    MEDIUM = 'medium'
    LOW = 'low'

class RelevanceScore(Enum):
    CORE_TEAM = 5  # Directly impacts team OKRs
    CROSS_TEAM = 3  # Impacts adjacent teams
    INDIVIDUAL = 1  # Only benefits individual contributor
    NEGATIVE = -2  # Distracts from core goals

@dataclass
class TechnicalTask:
    id: str
    title: str
    description: str
    priority: TaskPriority
    relevance: RelevanceScore
    estimated_hours: float
    assignee: Optional[str] = None
    dependencies: List[str] = field(default_factory=list)
    completion_percent: float = 0.0

    def validate(self) -> bool:
        \"\"\"Validate task fields to prevent invalid state\"\"\"
        if self.estimated_hours <= 0:
            raise ValueError(f'Task {self.id}: Estimated hours must be positive')
        if self.completion_percent < 0 or self.completion_percent > 100:
            raise ValueError(f'Task {self.id}: Completion percent must be 0-100')
        return True

class TaskRelevanceMatrix:
    \"\"\"Implements HOM 2026 Task-Relevance Matrix to prioritize team work\"\"\"
    def __init__(self, team_okrs: List[str]):
        self.team_okrs = team_okrs
        self.tasks: List[TechnicalTask] = []
        self._validation_errors: List[str] = []

    def add_task(self, task: TechnicalTask) -> None:
        \"\"\"Add task with validation, capture errors for batch reporting\"\"\"
        try:
            task.validate()
            self.tasks.append(task)
        except ValueError as e:
            self._validation_errors.append(str(e))

    def calculate_priority_score(self, task: TechnicalTask) -> float:
        \"\"\"HOM 2026 priority formula: (Relevance * Priority Weight) / Estimated Hours\"\"\"
        priority_weights = {
            TaskPriority.CRITICAL: 4.0,
            TaskPriority.HIGH: 3.0,
            TaskPriority.MEDIUM: 2.0,
            TaskPriority.LOW: 1.0
        }
        return (task.relevance.value * priority_weights[task.priority]) / task.estimated_hours

    def get_sorted_tasks(self) -> List[Tuple[TechnicalTask, float]]:
        \"\"\"Return tasks sorted by priority score descending\"\"\"
        scored_tasks = [(task, self.calculate_priority_score(task)) for task in self.tasks]
        return sorted(scored_tasks, key=lambda x: x[1], reverse=True)

    def export_to_csv(self, path: str) -> None:
        \"\"\"Export prioritized tasks to CSV for stakeholder reporting\"\"\"
        try:
            sorted_tasks = self.get_sorted_tasks()
            with open(path, 'w', newline='') as f:
                writer = csv.writer(f)
                writer.writerow([
                    'Task ID', 'Title', 'Priority Score', 'Relevance', 
                    'Priority', 'Estimated Hours', 'Assignee', 'Completion %'
                ])
                for task, score in sorted_tasks:
                    writer.writerow([
                        task.id, task.title, round(score, 2), task.relevance.name,
                        task.priority.value, task.estimated_hours, 
                        task.assignee or 'Unassigned', task.completion_percent
                    ])
        except IOError as e:
            raise RuntimeError(f'Failed to export CSV to {path}: {str(e)}')

    def get_validation_errors(self) -> List[str]:
        \"\"\"Return all validation errors captured during task addition\"\"\"
        return self._validation_errors

if __name__ == '__main__':
    # Initialize matrix with 2026 team OKRs for a backend platform team
    team_okrs = [
        'Reduce p99 API latency to <100ms by Q3 2026',
        'Increase deployment frequency to 10x/day by Q2 2026',
        'Reduce critical incident count by 40% YoY'
    ]
    matrix = TaskRelevanceMatrix(team_okrs)

    # Add sample tasks from real 2026 tech lead backlog
    sample_tasks = [
        TechnicalTask(
            id='T-001',
            title='Optimize user service database connection pooling',
            description='Switch from naive pooling to HikariCP with tuned configs',
            priority=TaskPriority.CRITICAL,
            relevance=RelevanceScore.CORE_TEAM,
            estimated_hours=12.5,
            assignee='alice',
            completion_percent=25.0
        ),
        TechnicalTask(
            id='T-002',
            title='Write blog post about team\'s 2025 achievements',
            description='Marketing request for company engineering blog',
            priority=TaskPriority.LOW,
            relevance=RelevanceScore.INDIVIDUAL,
            estimated_hours=4.0,
            assignee='bob',
            completion_percent=0.0
        ),
        TechnicalTask(
            id='T-003',
            title='Integrate with payment team\'s new checkout API',
            description='Migrate from legacy payment gateway to v2 API',
            priority=TaskPriority.HIGH,
            relevance=RelevanceScore.CROSS_TEAM,
            estimated_hours=24.0,
            dependencies=['T-001'],
            completion_percent=10.0
        )
    ]

    for task in sample_tasks:
        matrix.add_task(task)

    # Check for validation errors
    errors = matrix.get_validation_errors()
    if errors:
        print(f'Validation errors: {errors}')

    # Export prioritized tasks
    try:
        matrix.export_to_csv('prioritized_tasks_2026.csv')
        print('Exported prioritized tasks to prioritized_tasks_2026.csv')
    except RuntimeError as e:
        print(f'Export failed: {e}')

    # Print top 3 tasks
    print('\nTop 3 Prioritized Tasks:')
    for task, score in matrix.get_sorted_tasks()[:3]:
        print(f'{task.id}: {task.title} (Score: {round(score, 2)})')

import datetime
import json
from dataclasses import dataclass, field
from typing import List, Optional, Dict
from enum import Enum

class OneOnOneType(Enum):
    WEEKLY_CHECKIN = 'weekly_checkin'
    QUARTERLY_GROWTH = 'quarterly_growth'
    PERFORMANCE_REVIEW = 'performance_review'
    CONFLICT_RESOLUTION = 'conflict_resolution'

class ActionItemStatus(Enum):
    OPEN = 'open'
    IN_PROGRESS = 'in_progress'
    COMPLETED = 'completed'
    CANCELLED = 'cancelled'

@dataclass
class ActionItem:
    id: str
    description: str
    owner: str
    due_date: datetime.date
    status: ActionItemStatus = ActionItemStatus.OPEN
    notes: str = ""

    def validate(self) -> None:
        \"\"\"Validate action item fields\"\"\"
        if self.due_date < datetime.date.today():
            raise ValueError(f'Action item {self.id}: Due date cannot be in the past')
        if not self.owner:
            raise ValueError(f'Action item {self.id}: Owner is required')

@dataclass
class OneOnOneNote:
    id: str
    engineer: str
    date: datetime.date
    type: OneOnOneType
    wins: List[str] = field(default_factory=list)
    blockers: List[str] = field(default_factory=list)
    growth_goals: List[str] = field(default_factory=list)
    action_items: List[ActionItem] = field(default_factory=list)
    private_notes: str = ""  # Only visible to tech lead
    engineer_feedback: str = ""  # Filled by engineer post-meeting

    def validate(self) -> None:
        \"\"\"Validate 1:1 note completeness per Manager's Path 2.0 guidelines\"\"\"
        if not self.engineer:
            raise ValueError('Engineer name is required')
        if self.type == OneOnOneType.QUARTERLY_GROWTH and not self.growth_goals:
            raise ValueError('Quarterly growth 1:1s require at least one growth goal')
        for item in self.action_items:
            item.validate()

    def to_dict(self) -> Dict:
        \"\"\"Serialize to dict for JSON export, redact private notes for engineer view\"\"\"
        return {
            'id': self.id,
            'engineer': self.engineer,
            'date': self.date.isoformat(),
            'type': self.type.value,
            'wins': self.wins,
            'blockers': self.blockers,
            'growth_goals': self.growth_goals,
            'action_items': [
                {
                    'id': item.id,
                    'description': item.description,
                    'owner': item.owner,
                    'due_date': item.due_date.isoformat(),
                    'status': item.status.value,
                    'notes': item.notes
                } for item in self.action_items
            ],
            'engineer_feedback': self.engineer_feedback
        }

class ManagerPathTwoOneOnOneTracker:
    \"\"\"Implements Manager's Path 2.0 1:1 tracking framework\"\"\"
    def __init__(self, tech_lead_name: str, team_name: str):
        self.tech_lead_name = tech_lead_name
        self.team_name = team_name
        self.notes: List[OneOnOneNote] = []
        self._errors: List[str] = []

    def add_note(self, note: OneOnOneNote) -> None:
        \"\"\"Add 1:1 note with validation\"\"\"
        try:
            note.validate()
            self.notes.append(note)
        except ValueError as e:
            self._errors.append(str(e))

    def get_engineer_notes(self, engineer: str, include_private: bool = False) -> List[Dict]:
        \"\"\"Get all notes for an engineer, optionally include tech lead private notes\"\"\"
        engineer_notes = [n for n in self.notes if n.engineer == engineer]
        if not include_private:
            return [
                {
                    **note.to_dict(),
                    'private_notes': '[REDACTED]'
                } for note in engineer_notes
            ]
        return [note.to_dict() for note in engineer_notes]

    def get_overdue_action_items(self) -> List[ActionItem]:
        \"\"\"Return all open action items past due date\"\"\"
        overdue = []
        for note in self.notes:
            for item in note.action_items:
                if item.status in (ActionItemStatus.OPEN, ActionItemStatus.IN_PROGRESS) and item.due_date < datetime.date.today():
                    overdue.append(item)
        return overdue

    def export_team_report(self, path: str) -> None:
        \"\"\"Export team 1:1 summary report to JSON\"\"\"
        try:
            report = {
                'tech_lead': self.tech_lead_name,
                'team': self.team_name,
                'generated_at': datetime.datetime.now().isoformat(),
                'total_1on1s': len(self.notes),
                'overdue_action_items': len(self.get_overdue_action_items()),
                'engineers': list(set(n.engineer for n in self.notes)),
                'errors': self._errors
            }
            with open(path, 'w') as f:
                json.dump(report, f, indent=2)
        except IOError as e:
            raise RuntimeError(f'Failed to export report: {str(e)}')

if __name__ == '__main__':
    tracker = ManagerPathTwoOneOnOneTracker(
        tech_lead_name='Jane Doe',
        team_name='Backend Platform Team'
    )

    # Add sample 1:1 note for weekly checkin
    weekly_note = OneOnOneNote(
        id='1on1-2026-02-14-alice',
        engineer='alice',
        date=datetime.date(2026, 2, 14),
        type=OneOnOneType.WEEKLY_CHECKIN,
        wins=['Shipped T-001 connection pooling optimization', 'Mentored new hire on API design'],
        blockers=['Waiting on payment team API access'],
        growth_goals=['Learn distributed tracing with Jaeger by Q2'],
        action_items=[
            ActionItem(
                id='AI-001',
                description='Follow up with payment team lead for API access',
                owner='jane',
                due_date=datetime.date(2026, 2, 17)
            ),
            ActionItem(
                id='AI-002',
                description='Set up Jaeger sandbox for alice',
                owner='jane',
                due_date=datetime.date(2026, 2, 21)
            )
        ],
        private_notes='Alice is interested in tech lead path, need to discuss growth plan next quarter'
    )

    tracker.add_note(weekly_note)

    # Add quarterly growth note
    quarterly_note = OneOnOneNote(
        id='1on1-2026-01-05-bob',
        engineer='bob',
        date=datetime.date(2026, 1, 5),
        type=OneOnOneType.QUARTERLY_GROWTH,
        wins=['Led migration to v2 checkout API', 'Reduced personal incident count by 60%'],
        blockers=[],
        growth_goals=['Take on tech lead responsibilities for payments pod', 'Improve public speaking skills'],
        action_items=[
            ActionItem(
                id='AI-003',
                description='Assign bob as tech lead for payments pod v2',
                owner='jane',
                due_date=datetime.date(2026, 2, 1)
            )
        ]
    )

    tracker.add_note(quarterly_note)

    # Check errors
    if tracker._errors:
        print(f'Errors: {tracker._errors}')

    # Export report
    try:
        tracker.export_team_report('1on1_team_report_2026.json')
        print('Exported team report to 1on1_team_report_2026.json')
    except RuntimeError as e:
        print(f'Export failed: {e}')

    # Print overdue items
    overdue = tracker.get_overdue_action_items()
    if overdue:
        print(f'\nOverdue Action Items: {[item.id for item in overdue]}')
    else:
        print('\nNo overdue action items')

import json
import datetime
from typing import Dict, List

class TeamHealthDashboard:
    \"\"\"Aggregates HOM 2026 and Manager's Path 2.0 data into actionable team health metrics\"\"\"
    def __init__(self, matrix, tracker):
        self.matrix = matrix
        self.tracker = tracker
        self._health_metrics: Dict = {}

    def calculate_task_health(self) -> Dict:
        \"\"\"Calculate task-related health metrics from HOM 2026 matrix\"\"\"
        sorted_tasks = self.matrix.get_sorted_tasks()
        total_tasks = len(sorted_tasks)
        if total_tasks == 0:
            return {'task_completion_rate': 0.0, 'high_priority_completion': 0.0}

        total_completion = sum(task.completion_percent for task, _ in sorted_tasks) / total_tasks
        high_priority_tasks = [task for task, score in sorted_tasks if task.priority.name in ('CRITICAL', 'HIGH')]
        high_priority_completion = sum(task.completion_percent for task in high_priority_tasks) / len(high_priority_tasks) if high_priority_tasks else 0.0

        return {
            'total_tasks': total_tasks,
            'task_completion_rate': round(total_completion, 2),
            'high_priority_tasks': len(high_priority_tasks),
            'high_priority_completion': round(high_priority_completion, 2),
            'unassigned_tasks': len([task for task, _ in sorted_tasks if not task.assignee])
        }

    def calculate_people_health(self) -> Dict:
        \"\"\"Calculate people-related health metrics from Manager's Path 2.0 tracker\"\"\"
        all_notes = self.tracker.notes
        engineers = list(set(note.engineer for note in all_notes))
        if not engineers:
            return {'people_health_score': 0.0, 'blocker_count': 0}

        total_blockers = sum(len(note.blockers) for note in all_notes)
        overdue_action_items = len(self.tracker.get_overdue_action_items())
        growth_goals_per_engineer = sum(len(note.growth_goals) for note in all_notes) / len(engineers)

        # Health score formula from Manager's Path 2.0: 100 - (blockers * 5) - (overdue_items * 10) + (growth_goals * 3)
        health_score = 100 - (total_blockers * 5) - (overdue_action_items * 10) + (growth_goals_per_engineer * 3)
        health_score = max(0.0, min(100.0, health_score))  # Clamp to 0-100

        return {
            'total_engineers': len(engineers),
            'total_blockers': total_blockers,
            'overdue_action_items': overdue_action_items,
            'growth_goals_per_engineer': round(growth_goals_per_engineer, 2),
            'people_health_score': round(health_score, 2)
        }

    def generate_dashboard(self) -> Dict:
        \"\"\"Generate full team health dashboard\"\"\"
        task_health = self.calculate_task_health()
        people_health = self.calculate_people_health()
        self._health_metrics = {
            'generated_at': datetime.datetime.now().isoformat(),
            'team': self.tracker.team_name,
            'tech_lead': self.tracker.tech_lead_name,
            'task_health': task_health,
            'people_health': people_health,
            'overall_health_score': round((task_health.get('task_completion_rate', 0) + people_health.get('people_health_score', 0)) / 2, 2)
        }
        return self._health_metrics

    def export_dashboard(self, path: str) -> None:
        \"\"\"Export dashboard to JSON file\"\"\"
        if not self._health_metrics:
            self.generate_dashboard()
        try:
            with open(path, 'w') as f:
                json.dump(self._health_metrics, f, indent=2)
        except IOError as e:
            raise RuntimeError(f'Failed to export dashboard: {str(e)}')

    def get_actionable_recommendations(self) -> List[str]:
        \"\"\"Generate HOM 2026 + Manager's Path 2.0 recommendations based on dashboard\"\"\"
        recommendations = []
        task_health = self.calculate_task_health()
        people_health = self.calculate_people_health()

        if task_health['unassigned_tasks'] > 0:
            recommendations.append(f'Assign {task_health[\"unassigned_tasks\"]} unassigned tasks to available engineers using Task-Relevance Matrix scores')
        if task_health['high_priority_completion'] < 70:
            recommendations.append(f'High priority task completion is {task_health[\"high_priority_completion\"]}% – reprioritize CRITICAL tasks per HOM 2026 guidelines')
        if people_health['total_blockers'] > 3:
            recommendations.append(f'Team has {people_health[\"total_blockers\"]} active blockers – schedule ad-hoc 1:1s to resolve per Manager\'s Path 2.0')
        if people_health['overdue_action_items'] > 0:
            recommendations.append(f'Resolve {people_health[\"overdue_action_items\"]} overdue action items to improve people health score')
        if not recommendations:
            recommendations.append('Team health is optimal – maintain current HOM 2026 and Manager\'s Path 2.0 practices')
        return recommendations

if __name__ == '__main__':
    # Initialize dependencies with sample data
    from task_relevance_matrix import TaskRelevanceMatrix, TaskPriority, RelevanceScore, TechnicalTask
    from manager_path_oneonone import ManagerPathTwoOneOnOneTracker, OneOnOneType, ActionItem, OneOnOneNote

    # Recreate matrix with sample tasks
    team_okrs = [
        'Reduce p99 API latency to <100ms by Q3 2026',
        'Increase deployment frequency to 10x/day by Q2 2026',
        'Reduce critical incident count by 40% YoY'
    ]
    matrix = TaskRelevanceMatrix(team_okrs)
    sample_tasks = [
        TechnicalTask(
            id='T-001', title='Optimize user service database connection pooling',
            description='Switch to HikariCP', priority=TaskPriority.CRITICAL,
            relevance=RelevanceScore.CORE_TEAM, estimated_hours=12.5, assignee='alice', completion_percent=25.0
        ),
        TechnicalTask(
            id='T-002', title='Write blog post about 2025 achievements',
            description='Marketing request', priority=TaskPriority.LOW,
            relevance=RelevanceScore.INDIVIDUAL, estimated_hours=4.0, assignee='bob', completion_percent=0.0
        )
    ]
    for task in sample_tasks:
        matrix.add_task(task)

    # Recreate tracker with sample notes
    tracker = ManagerPathTwoOneOnOneTracker(tech_lead_name='Jane Doe', team_name='Backend Platform Team')
    weekly_note = OneOnOneNote(
        id='1on1-2026-02-14-alice', engineer='alice', date=datetime.date(2026, 2, 14),
        type=OneOnOneType.WEEKLY_CHECKIN, wins=['Shipped T-001 optimization'],
        blockers=['Waiting on payment API access'], growth_goals=['Learn Jaeger'],
        action_items=[ActionItem(id='AI-001', description='Follow up with payment team', owner='jane', due_date=datetime.date(2026, 2, 17))]
    )
    tracker.add_note(weekly_note)

    # Generate dashboard
    dashboard = TeamHealthDashboard(matrix, tracker)
    try:
        dashboard.generate_dashboard()
        dashboard.export_dashboard('team_health_dashboard_2026.json')
        print('Exported team health dashboard to team_health_dashboard_2026.json')

        print('\nActionable Recommendations:')
        for rec in dashboard.get_actionable_recommendations():
            print(f'- {rec}')

        print(f'\nOverall Health Score: {dashboard._health_metrics[\"overall_health_score\"]}')
    except RuntimeError as e:
        print(f'Dashboard generation failed: {e}')

from task_relevance_matrix import TechnicalTask, TaskPriority, RelevanceScore, TaskRelevanceMatrix

team_okrs = ['Reduce p99 API latency to <100ms by Q3 2026']
matrix = TaskRelevanceMatrix(team_okrs)

new_task = TechnicalTask(
    id='T-004',
    title='Add rate limiting to user API',
    priority=TaskPriority.HIGH,
    relevance=RelevanceScore.CORE_TEAM,
    estimated_hours=8.0
)
matrix.add_task(new_task)
score = matrix.calculate_priority_score(new_task)
print(f'Priority Score: {round(score, 2)}')  # Output: 1.88 (5 * 3 / 8 = 1.875)

from manager_path_oneonone import ManagerPathTwoOneOnOneTracker

tracker = ManagerPathTwoOneOnOneTracker(tech_lead_name='Jane', team_name='Backend')
# Add notes as in Code Example 2
overdue = tracker.get_overdue_action_items()
if overdue:
    print(f'Overdue items: {[item.id for item in overdue]}')
    # Auto-create Linear issues for overdue items
    for item in overdue:
        print(f'Creating Linear issue for {item.id}: {item.description}')

from team_health_dashboard import TeamHealthDashboard

dashboard = TeamHealthDashboard(matrix, tracker)
recommendations = dashboard.get_actionable_recommendations()
for rec in recommendations:
    print(f'Recommendation: {rec}')
# Output example: "Assign 2 unassigned tasks to available engineers using Task-Relevance Matrix scores"

hom-2026-manager-path-2.0/
├── task_relevance_matrix.py       # Code Example 1: HOM 2026 Task-Relevance Matrix
├── manager_path_oneonone.py        # Code Example 2: Manager's Path 2.0 1:1 Tracker
├── team_health_dashboard.py        # Code Example 3: Combined Health Dashboard
├── sample_data/                    # Sample tasks, 1:1 notes, and OKRs
│   ├── sample_tasks.csv
│   ├── sample_1on1_notes.json
│   └── team_okrs.txt
├── reports/                        # Generated reports and dashboards
│   ├── prioritized_tasks_2026.csv
│   ├── 1on1_team_report_2026.json
│   └── team_health_dashboard_2026.json
├── tests/                          # Unit tests for all modules
│   ├── test_task_matrix.py
│   ├── test_oneonone_tracker.py
│   └── test_health_dashboard.py
└── README.md                       # Setup and usage instructions