8.1: Capability Levels Deep Dive

Capability Level Structure

ASPICE 4.0 Capability Levels

The following diagram illustrates the structure of a Capability Level 3 (Established) process, showing how a defined standard process is tailored, deployed, and measured across the organization.

Process Attribute Details

PA 1.1: Process Performance

# PA 1.1 Process Performance Attribute
process_attribute:
  id: PA1.1
  name: "Process Performance"
  level: 1
  description: |
    A measure of the extent to which the process purpose is achieved.

  achievement_criteria:
    - "Process outcomes are achieved"
    - "Work products are produced"
    - "Process purpose is fulfilled"

  generic_practices:
    GP1.1.1:
      name: "Achieve process outcomes"
      description: |
        The process achieves its defined outcomes. As a result of full
        achievement of this attribute, the process outcomes are achieved.

  indicators:
    work_products:
      - "Process-specific work products produced"
      - "Expected outputs delivered"

    practices:
      - "Base practices performed"
      - "Outcomes achieved"

  ai_support:
    level: L2
    activities:
      - "Outcome achievement tracking"
      - "Work product verification"
      - "Gap identification"

  example_evidence:
    # See work product catalog (WP IDs 17-08, 17-11, 17-12, etc.) for full details
    swe1:
      - "Software requirements specification (17-08)"
      - "Traceability matrix (17-11)"
      - "Verification criteria (17-12)"
    swe4:
      - "Unit test results (13-50)"
      - "Coverage reports"
      - "Defect records"

PA 2.1: Performance Management

# PA 2.1 Performance Management Attribute
process_attribute:
  id: PA2.1
  name: "Performance Management"
  level: 2
  description: |
    A measure of the extent to which the performance of the process
    is managed.

  achievement_criteria:
    - "Performance objectives are identified"
    - "Performance is planned"
    - "Performance is monitored"
    - "Adjustments are made when needed"

  generic_practices:
    GP2.1.1:
      name: "Identify process performance objectives"
      description: |
        Performance objectives for the process, based on its purpose
        and the needs of the project and organization, are identified.
      work_products:
        - "Process performance objectives"
        - "Quality objectives"

    GP2.1.2:
      name: "Plan the performance of the process"
      description: |
        The performance of the process is planned, addressing
        identification of activities, dependencies, timelines,
        and responsibilities.
      work_products:
        - "Process plan"
        - "Activity schedules"

    GP2.1.3:
      name: "Monitor the performance of the process"
      description: |
        The actual performance of the process is monitored against
        the planned performance.
      work_products:
        - "Performance records"
        - "Progress reports"

    GP2.1.4:
      name: "Adjust the performance of the process"
      description: |
        When planned performance is not achieved, appropriate
        adjustments to the plan and/or the process are made.
      work_products:
        - "Corrective action records"
        - "Updated plans"

  ai_support:
    level: L2
    activities:
      - "Automated progress tracking"
      - "Performance deviation detection"
      - "Adjustment recommendations"

PA 2.2: Work Product Management

# PA 2.2 Work Product Management Attribute
process_attribute:
  id: PA2.2
  name: "Work Product Management"
  level: 2
  description: |
    A measure of the extent to which the work products produced
    by the process are appropriately managed.

  achievement_criteria:
    - "Work product requirements are defined"
    - "Work products are appropriately identified"
    - "Work products are documented and controlled"
    - "Work products are reviewed"

  generic_practices:
    GP2.2.1:
      name: "Define work product requirements"
      description: |
        Requirements for the work products are defined including
        content and quality criteria.
      work_products:
        - "Work product requirements"
        - "Quality criteria"

    GP2.2.2:
      name: "Identify work products"
      description: |
        Work products of the process are appropriately identified,
        documented, and controlled.
      work_products:
        - "Work product list"
        - "Configuration records"

    GP2.2.3:
      name: "Document and control work products"
      description: |
        Work products are documented, controlled, and maintained
        according to their requirements.
      work_products:
        - "Work products under CM"
        - "Version records"

    GP2.2.4:
      name: "Review work products"
      description: |
        Work products are reviewed against defined requirements
        and adjustments are made as necessary.
      work_products:
        - "Review records"
        - "Approval records"

  ai_support:
    level: L2-L3
    activities:
      - "Automated work product verification"
      - "Quality criteria checking"
      - "Review tracking"

PA 3.1 and PA 3.2

# PA 3.1 Process Definition
process_attribute:
  id: PA3.1
  name: "Process Definition"
  level: 3
  description: |
    A measure of the extent to which a standard process is maintained
    to support deployment of the defined process.

  generic_practices:
    GP3.1.1:
      name: "Define the standard process"
      description: "A standard process that supports deployment is defined."

    GP3.1.2:
      name: "Determine appropriate process tailoring"
      description: "Guidelines for tailoring the standard process are defined."

    GP3.1.3:
      name: "Monitor deployment effectiveness"
      description: "Process deployment effectiveness is monitored."

---

# PA 3.2 Process Deployment
process_attribute:
  id: PA3.2
  name: "Process Deployment"
  level: 3
  description: |
    A measure of the extent to which the standard process is deployed
    as a defined process to achieve its outcomes.

  generic_practices:
    GP3.2.1:
      name: "Deploy a defined process"
      description: "A defined process is deployed based on the standard process."

    GP3.2.2:
      name: "Assign roles and responsibilities"
      description: "Appropriate roles, responsibilities, and authorities are assigned."

    GP3.2.3:
      name: "Ensure required resources"
      description: "Resources are made available for performing the process."

    GP3.2.4:
      name: "Ensure required competencies"
      description: "Required competencies are defined and available."

Level Achievement Checklist

Level 1 Checklist

The diagram below presents the Level 1 (Performed) achievement checklist, listing the process outcomes and work products that must be demonstrated for each base practice.

Level 2 Checklist

The following diagram presents the Level 2 (Managed) achievement checklist, covering the additional process management, work product management, and performance tracking requirements beyond Level 1.

AI Gap Analysis Tool

Automated Assessment Support

"""
AI-assisted capability level gap analysis.
"""

from dataclasses import dataclass
from typing import List, Dict, Optional
from enum import Enum

class Rating(Enum):
    NOT_ACHIEVED = "N"
    PARTIALLY = "P"
    LARGELY = "L"
    FULLY = "F"

class CapabilityLevel(Enum):
    LEVEL_0 = 0
    LEVEL_1 = 1
    LEVEL_2 = 2
    LEVEL_3 = 3

@dataclass
class ProcessAttribute:
    """Process attribute assessment."""
    id: str
    name: str
    level: int
    rating: Rating
    evidence: List[str]
    gaps: List[str]
    recommendations: List[str]

@dataclass
class ProcessAssessment:
    """Complete process assessment."""
    process_id: str
    process_name: str
    attributes: List[ProcessAttribute]
    achieved_level: CapabilityLevel
    target_level: CapabilityLevel
    gap_summary: str


class GapAnalyzer:
    """AI-assisted gap analysis for capability levels.

    Note: Evidence patterns require customization per organization;
    the patterns below are examples based on common automotive practices.
    """

    def __init__(self):
        self.evidence_patterns = self._load_evidence_patterns()
        self.best_practices = self._load_best_practices()

    def _load_evidence_patterns(self) -> Dict:
        """Load expected evidence patterns per process."""
        return {
            'SWE.1': {
                'PA1.1': [
                    'Software requirements specification',
                    'Traceability matrix',
                    'Verification criteria',
                    'Review records'
                ],
                'PA2.1': [
                    'Requirements plan',
                    'Progress reports',
                    'Quality metrics',
                    'Corrective action records'
                ],
                'PA2.2': [
                    'Work product list',
                    'Configuration records',
                    'Review/approval records',
                    'Baseline records'
                ]
            }
        }

    def _load_best_practices(self) -> Dict:
        """Load improvement recommendations."""
        return {
            'PA1.1_gaps': [
                "Ensure all base practices are performed",
                "Verify all required work products are produced",
                "Confirm all outcomes are achieved"
            ],
            'PA2.1_gaps': [
                "Define explicit quality objectives",
                "Establish monitoring mechanisms",
                "Document corrective actions"
            ],
            'PA2.2_gaps': [
                "Define work product requirements",
                "Establish review process",
                "Implement version control"
            ]
        }

    def analyze_process(self, process_id: str,
                       collected_evidence: List[str],
                       target_level: CapabilityLevel) -> ProcessAssessment:
        """Perform gap analysis for a process."""

        attributes = []

        # Analyze PA 1.1
        pa11 = self._analyze_pa11(process_id, collected_evidence)
        attributes.append(pa11)

        # Analyze PA 2.1 and PA 2.2 if targeting Level 2+
        if target_level.value >= 2:
            pa21 = self._analyze_pa21(process_id, collected_evidence)
            pa22 = self._analyze_pa22(process_id, collected_evidence)
            attributes.append(pa21)
            attributes.append(pa22)

        # Analyze PA 3.1 and PA 3.2 if targeting Level 3
        if target_level.value >= 3:
            pa31 = self._analyze_pa31(process_id, collected_evidence)
            pa32 = self._analyze_pa32(process_id, collected_evidence)
            attributes.append(pa31)
            attributes.append(pa32)

        # Determine achieved level
        achieved = self._determine_achieved_level(attributes)

        # Generate gap summary
        gap_summary = self._generate_gap_summary(attributes, target_level)

        return ProcessAssessment(
            process_id=process_id,
            process_name=self._get_process_name(process_id),
            attributes=attributes,
            achieved_level=achieved,
            target_level=target_level,
            gap_summary=gap_summary
        )

    def _analyze_pa11(self, process_id: str,
                     evidence: List[str]) -> ProcessAttribute:
        """Analyze PA 1.1 Process Performance."""

        expected = self.evidence_patterns.get(process_id, {}).get('PA1.1', [])
        found = [e for e in expected if any(e.lower() in ev.lower() for ev in evidence)]
        missing = [e for e in expected if e not in found]

        coverage = len(found) / len(expected) if expected else 0

        if coverage >= 0.86:
            rating = Rating.FULLY
        elif coverage >= 0.51:
            rating = Rating.LARGELY
        elif coverage >= 0.16:
            rating = Rating.PARTIALLY
        else:
            rating = Rating.NOT_ACHIEVED

        gaps = [f"Missing: {e}" for e in missing]
        recommendations = self.best_practices.get('PA1.1_gaps', []) if gaps else []

        return ProcessAttribute(
            id='PA1.1',
            name='Process Performance',
            level=1,
            rating=rating,
            evidence=found,
            gaps=gaps,
            recommendations=recommendations
        )

    def _analyze_pa21(self, process_id: str,
                     evidence: List[str]) -> ProcessAttribute:
        """Analyze PA 2.1 Performance Management."""

        expected = self.evidence_patterns.get(process_id, {}).get('PA2.1', [])
        found = [e for e in expected if any(e.lower() in ev.lower() for ev in evidence)]
        missing = [e for e in expected if e not in found]

        coverage = len(found) / len(expected) if expected else 0

        if coverage >= 0.86:
            rating = Rating.FULLY
        elif coverage >= 0.51:
            rating = Rating.LARGELY
        elif coverage >= 0.16:
            rating = Rating.PARTIALLY
        else:
            rating = Rating.NOT_ACHIEVED

        gaps = [f"Missing: {e}" for e in missing]
        recommendations = self.best_practices.get('PA2.1_gaps', []) if gaps else []

        return ProcessAttribute(
            id='PA2.1',
            name='Performance Management',
            level=2,
            rating=rating,
            evidence=found,
            gaps=gaps,
            recommendations=recommendations
        )

    def _analyze_pa22(self, process_id: str,
                     evidence: List[str]) -> ProcessAttribute:
        """Analyze PA 2.2 Work Product Management."""

        expected = self.evidence_patterns.get(process_id, {}).get('PA2.2', [])
        found = [e for e in expected if any(e.lower() in ev.lower() for ev in evidence)]
        missing = [e for e in expected if e not in found]

        coverage = len(found) / len(expected) if expected else 0

        if coverage >= 0.86:
            rating = Rating.FULLY
        elif coverage >= 0.51:
            rating = Rating.LARGELY
        elif coverage >= 0.16:
            rating = Rating.PARTIALLY
        else:
            rating = Rating.NOT_ACHIEVED

        gaps = [f"Missing: {e}" for e in missing]
        recommendations = self.best_practices.get('PA2.2_gaps', []) if gaps else []

        return ProcessAttribute(
            id='PA2.2',
            name='Work Product Management',
            level=2,
            rating=rating,
            evidence=found,
            gaps=gaps,
            recommendations=recommendations
        )

    def _analyze_pa31(self, process_id: str,
                     evidence: List[str]) -> ProcessAttribute:
        """Analyze PA 3.1 Process Definition.

        Note: Simplified implementation; production use requires
        organizational standard process documentation analysis.
        """
        # Simplified - check for standard process documentation
        return ProcessAttribute(
            id='PA3.1',
            name='Process Definition',
            level=3,
            rating=Rating.PARTIALLY,
            evidence=[],
            gaps=["Standard process definition needed"],
            recommendations=["Define organizational standard process"]
        )

    def _analyze_pa32(self, process_id: str,
                     evidence: List[str]) -> ProcessAttribute:
        """Analyze PA 3.2 Process Deployment."""
        return ProcessAttribute(
            id='PA3.2',
            name='Process Deployment',
            level=3,
            rating=Rating.PARTIALLY,
            evidence=[],
            gaps=["Process deployment from standard needed"],
            recommendations=["Deploy defined process based on standard"]
        )

    def _determine_achieved_level(self,
                                  attributes: List[ProcessAttribute]) -> CapabilityLevel:
        """Determine achieved capability level."""

        pa11 = next((a for a in attributes if a.id == 'PA1.1'), None)
        pa21 = next((a for a in attributes if a.id == 'PA2.1'), None)
        pa22 = next((a for a in attributes if a.id == 'PA2.2'), None)
        pa31 = next((a for a in attributes if a.id == 'PA3.1'), None)
        pa32 = next((a for a in attributes if a.id == 'PA3.2'), None)

        # Check Level 3
        if (pa11 and pa11.rating == Rating.FULLY and
            pa21 and pa21.rating == Rating.FULLY and
            pa22 and pa22.rating == Rating.FULLY and
            pa31 and pa31.rating in [Rating.LARGELY, Rating.FULLY] and
            pa32 and pa32.rating in [Rating.LARGELY, Rating.FULLY]):
            return CapabilityLevel.LEVEL_3

        # Check Level 2
        if (pa11 and pa11.rating == Rating.FULLY and
            pa21 and pa21.rating in [Rating.LARGELY, Rating.FULLY] and
            pa22 and pa22.rating in [Rating.LARGELY, Rating.FULLY]):
            return CapabilityLevel.LEVEL_2

        # Check Level 1
        if pa11 and pa11.rating in [Rating.LARGELY, Rating.FULLY]:
            return CapabilityLevel.LEVEL_1

        return CapabilityLevel.LEVEL_0

    def _get_process_name(self, process_id: str) -> str:
        """Get process name from ID."""
        names = {
            'SWE.1': 'Software Requirements Analysis',
            'SWE.2': 'Software Architectural Design',
            'SWE.3': 'Software Detailed Design and Unit Construction',
            'SWE.4': 'Software Unit Verification',
            'SWE.5': 'Software Integration and Integration Test',
            'SWE.6': 'Software Qualification Test'
        }
        return names.get(process_id, process_id)

    def _generate_gap_summary(self, attributes: List[ProcessAttribute],
                             target: CapabilityLevel) -> str:
        """Generate gap summary text."""

        gaps = []
        for attr in attributes:
            if attr.gaps:
                gaps.extend(attr.gaps)

        if not gaps:
            return f"No gaps identified. Target Level {target.value} achievable."

        return f"Found {len(gaps)} gaps to address for Level {target.value}:\n" + \
               "\n".join(f"- {g}" for g in gaps[:5])

Work Products

Summary

Capability Levels:

• Level 1: Process outcomes achieved
• Level 2: Performance and work products managed
• Level 3: Standard process defined and deployed
• AI Support: Gap analysis, evidence collection, tracking
• Human Essential: Rating decisions, improvement planning