7.1: MAN.3 Project Management

Process Definition

Purpose

MAN.3 Purpose: To identify, establish, coordinate, and monitor the activities, tasks, and resources necessary for a project to produce a product.

Outcomes

Base Practices with AI Integration

AI-Powered Project Estimation

Estimation Model

"""
AI-assisted project estimation for embedded software projects.
"""

from dataclasses import dataclass
from typing import List, Dict, Optional, Tuple
import numpy as np
from sklearn.ensemble import RandomForestRegressor

@dataclass
class ProjectFeatures:
    """Project features for estimation."""
    # Size metrics
    requirement_count: int
    function_point_estimate: int
    lines_of_code_estimate: int

    # Complexity factors
    interface_count: int
    safety_level: str  # ASIL-A to ASIL-D
    security_level: str  # CAL 1-4
    reuse_percentage: float

    # Team factors
    team_size: int
    team_experience: str  # junior, mixed, senior
    domain_expertise: str  # low, medium, high

    # Technical factors
    target_platform: str
    real_time_constraints: bool
    misra_compliance: bool

@dataclass
class Estimate:
    """Project estimate result."""
    effort_hours: float
    duration_weeks: float
    confidence_low: float
    confidence_high: float
    confidence_level: float
    risk_factors: List[str]
    assumptions: List[str]


class ProjectEstimator:
    """AI-powered project effort estimation.

    Note: RandomForestRegressor requires training on organizational
    historical data for accurate predictions. Calibrate regularly.
    """

    def __init__(self):
        self.model = self._load_model()
        self.historical_data = self._load_historical_data()

    def _load_model(self):
        """Load trained estimation model."""
        # In production, load from saved model file
        return RandomForestRegressor(n_estimators=100)

    def _load_historical_data(self) -> List[Dict]:
        """Load historical project data for calibration."""
        # Sample historical projects
        return [
            {'req_count': 50, 'fp': 150, 'effort': 2000, 'duration': 20},
            {'req_count': 100, 'fp': 300, 'effort': 4500, 'duration': 32},
            {'req_count': 200, 'fp': 600, 'effort': 10000, 'duration': 48},
            # ... more historical data
        ]

    def estimate(self, features: ProjectFeatures) -> Estimate:
        """Generate project estimate using AI model."""

        # Feature engineering
        X = self._extract_features(features)

        # Base estimate from model
        base_effort = self._calculate_base_effort(features)

        # Apply adjustment factors
        adjustments = self._calculate_adjustments(features)
        adjusted_effort = base_effort * adjustments['total_factor']

        # Calculate duration
        optimal_team = self._calculate_optimal_team(adjusted_effort, features)
        duration = adjusted_effort / (optimal_team * 40)  # 40 hours/week

        # Confidence interval
        confidence = self._calculate_confidence(features, adjusted_effort)

        # Identify risks
        risks = self._identify_estimation_risks(features)

        return Estimate(
            effort_hours=round(adjusted_effort, 0),
            duration_weeks=round(duration, 1),
            confidence_low=round(adjusted_effort * 0.8, 0),
            confidence_high=round(adjusted_effort * 1.3, 0),
            confidence_level=confidence,
            risk_factors=risks,
            assumptions=self._get_assumptions(features)
        )

    def _extract_features(self, features: ProjectFeatures) -> np.ndarray:
        """Extract numeric features for model."""

        safety_map = {'QM': 0, 'ASIL-A': 1, 'ASIL-B': 2, 'ASIL-C': 3, 'ASIL-D': 4}
        security_map = {'CAL 1': 1, 'CAL 2': 2, 'CAL 3': 3, 'CAL 4': 4}
        experience_map = {'junior': 0.7, 'mixed': 1.0, 'senior': 1.3}
        expertise_map = {'low': 0.8, 'medium': 1.0, 'high': 1.2}

        return np.array([
            features.requirement_count,
            features.function_point_estimate,
            features.lines_of_code_estimate,
            features.interface_count,
            safety_map.get(features.safety_level, 0),
            security_map.get(features.security_level, 1),
            features.reuse_percentage,
            features.team_size,
            experience_map.get(features.team_experience, 1.0),
            expertise_map.get(features.domain_expertise, 1.0),
            1 if features.real_time_constraints else 0,
            1 if features.misra_compliance else 0
        ])

    def _calculate_base_effort(self, features: ProjectFeatures) -> float:
        """Calculate base effort using simplified COCOMO-like model.

        Note: This is a simplified approach; consider using COCOMO II or
        organization-specific calibration for production estimates.
        """

        # Base: 3 hours per function point (industry average - calibrate for your organization)
        base_hours_per_fp = 3.0

        # Adjust for embedded software (typically 1.5x)
        embedded_factor = 1.5

        base_effort = features.function_point_estimate * base_hours_per_fp * embedded_factor

        return base_effort

    def _calculate_adjustments(self, features: ProjectFeatures) -> Dict[str, float]:
        """Calculate adjustment factors."""

        factors = {}

        # Safety factor
        safety_factors = {
            'QM': 1.0, 'ASIL-A': 1.1, 'ASIL-B': 1.25,
            'ASIL-C': 1.5, 'ASIL-D': 1.8
        }
        factors['safety'] = safety_factors.get(features.safety_level, 1.0)

        # Security factor
        security_factors = {
            'CAL 1': 1.0, 'CAL 2': 1.1, 'CAL 3': 1.2, 'CAL 4': 1.35
        }
        factors['security'] = security_factors.get(features.security_level, 1.0)

        # Reuse factor (reduces effort)
        factors['reuse'] = 1.0 - (features.reuse_percentage * 0.5)

        # Team experience factor
        experience_factors = {'junior': 1.3, 'mixed': 1.0, 'senior': 0.85}
        factors['experience'] = experience_factors.get(features.team_experience, 1.0)

        # MISRA compliance factor
        factors['misra'] = 1.15 if features.misra_compliance else 1.0

        # Real-time factor
        factors['realtime'] = 1.2 if features.real_time_constraints else 1.0

        # Total factor
        factors['total_factor'] = (
            factors['safety'] *
            factors['security'] *
            factors['reuse'] *
            factors['experience'] *
            factors['misra'] *
            factors['realtime']
        )

        return factors

    def _calculate_optimal_team(self, effort: float,
                               features: ProjectFeatures) -> int:
        """Calculate optimal team size using Brooks' Law consideration."""

        # Square root rule for team sizing
        optimal = int(np.sqrt(effort / 200))  # ~200 hours per person baseline

        # Constrain to reasonable range
        return max(2, min(optimal, features.team_size))

    def _calculate_confidence(self, features: ProjectFeatures,
                             estimate: float) -> float:
        """Calculate confidence level for estimate."""

        confidence = 0.75  # Base confidence

        # Higher requirements = lower confidence
        if features.requirement_count > 100:
            confidence -= 0.05
        if features.requirement_count > 200:
            confidence -= 0.05

        # Higher safety = lower confidence (more unknowns)
        if features.safety_level in ['ASIL-C', 'ASIL-D']:
            confidence -= 0.05

        # More reuse = higher confidence
        if features.reuse_percentage > 0.3:
            confidence += 0.05

        # Experienced team = higher confidence
        if features.team_experience == 'senior':
            confidence += 0.05

        return min(0.9, max(0.5, confidence))

    def _identify_estimation_risks(self, features: ProjectFeatures) -> List[str]:
        """Identify risks to estimation accuracy."""

        risks = []

        if features.requirement_count > 150:
            risks.append("Large scope increases estimation uncertainty")

        if features.reuse_percentage < 0.1:
            risks.append("Low reuse - most code is new development")

        if features.safety_level in ['ASIL-C', 'ASIL-D']:
            risks.append("High safety level may require additional activities")

        if features.team_experience == 'junior':
            risks.append("Junior team may face learning curve")

        if features.interface_count > 10:
            risks.append("Many interfaces increase integration complexity")

        return risks

    def _get_assumptions(self, features: ProjectFeatures) -> List[str]:
        """Document estimation assumptions."""

        return [
            "Requirements are stable (< 10% change expected)",
            "Team availability at planned capacity",
            "Tools and infrastructure available from project start",
            "No major technology changes during project",
            f"Team size: {features.team_size} engineers"
        ]


def generate_estimate_report(estimate: Estimate, project_name: str) -> str:
    """Generate estimation report."""

    report = [f"# Project Estimate: {project_name}\n"]

    report.append("## Summary\n")
    report.append(f"| Metric | Value |")
    report.append(f"|--------|-------|")
    report.append(f"| Effort | {estimate.effort_hours:,.0f} hours |")
    report.append(f"| Duration | {estimate.duration_weeks:.1f} weeks |")
    report.append(f"| Confidence | {estimate.confidence_level*100:.0f}% |")
    report.append(f"| Range | {estimate.confidence_low:,.0f} - {estimate.confidence_high:,.0f} hours |\n")

    report.append("## Risk Factors\n")
    for risk in estimate.risk_factors:
        report.append(f"- {risk}")

    report.append("\n## Assumptions\n")
    for assumption in estimate.assumptions:
        report.append(f"- {assumption}")

    return "\n".join(report)

Project Planning Framework

Work Breakdown Structure

The following diagram presents an example Work Breakdown Structure for an ASPICE-compliant project, decomposing the project scope into manageable work packages aligned with process groups.

Progress Tracking Dashboard

AI-Generated Status Report

The diagram below shows an AI-generated project status report, consolidating schedule adherence, risk status, milestone progress, and resource utilization into a single dashboard view.

Project Plan Template

Note: Resource names and dates are illustrative; customize for actual project.

# Project Plan (template)
project_plan:
  project_id: PRJ-(ID)
  project_name: "(Project Name)"
  version: 1.0
  date: (date)

  overview:
    description: |
      Development of Body Control Module software for door lock
      control function, including remote keyless entry support.
    objectives:
      - "Implement door lock/unlock control per customer specification"
      - "Achieve ASIL-B certification for safety functions"
      - "Meet CAL 3 cybersecurity requirements"
    scope:
      in_scope:
        - "Door lock/unlock control logic"
        - "Remote keyless entry interface"
        - "CAN communication stack"
        - "Diagnostic services"
      out_of_scope:
        - "Hardware design (customer provided)"
        - "Backend connectivity"

  schedule:
    start_date: 2024-10-01
    end_date: 2025-03-01
    duration_weeks: 22

    phases:
      - name: "Requirements"
        start: 2024-10-01
        end: 2024-11-15
        deliverables: [SRS, traceability matrix]

      - name: "Architecture"
        start: 2024-11-01
        end: 2024-12-15
        deliverables: [Architecture document, design review]

      - name: "Implementation"
        start: 2024-12-01
        end: 2025-01-31
        deliverables: [Source code, unit tests]

      - name: "Integration"
        start: 2025-01-15
        end: 2025-02-15
        deliverables: [Integration test report]

      - name: "Qualification"
        start: 2025-02-01
        end: 2025-03-01
        deliverables: [Qualification report, release]

  resources:
    team:
      - role: Project Manager
        allocation: 50%
        name: TBD

      - role: SW Architect
        allocation: 100%
        name: TBD

      - role: SW Developer
        count: 3
        allocation: 100%

      - role: Test Engineer
        count: 2
        allocation: 100%

      - role: Safety Engineer
        allocation: 25%
        name: TBD

    budget:
      labor_hours: 3200
      hardware: 15000
      tools: 5000
      total: 180000

  risks:
    - id: RSK-001
      description: "HIL equipment availability"
      probability: medium
      impact: high
      mitigation: "Reserve equipment early"

    - id: RSK-002
      description: "Requirements changes"
      probability: medium
      impact: medium
      mitigation: "Change control process"

  communication:
    status_meetings: "Weekly on Monday"
    reports: "Bi-weekly to steering committee"
    tools: ["Jira", "Confluence", "Teams"]

  quality:
    reviews:
      - type: Requirements review
        milestone: M1
      - type: Architecture review
        milestone: M2
      - type: Code review
        timing: Continuous

    metrics:
      - name: Requirements coverage
        target: "100%"
      - name: Code coverage
        target: "> 80%"
      - name: Open defects at release
        target: "0 critical, 0 high"

Work Products

Summary

MAN.3 Project Management:

• AI Level: L1-L2 (AI assists, human decides)
• Primary AI Value: Estimation, tracking, reporting
• Human Essential: Planning decisions, corrective actions
• Key Outputs: Project plans, progress reports
• Integration: Links to all development processes