# Software Engineering

> Software engineering principles

- Skill: `ffsshhttiikk/software-engineering` (Agent Skill)
- Install (CLI): `npx skillmds@latest add ffsshhttiikk/software-engineering`
- Raw SKILL.md: https://api.skillmd.com/api/skills/ffsshhttiikk/software-engineering/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- License: MIT
- Author: ffsshhttiikk (https://skillmd.com/u/ffsshhttiikk)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/ffsshhttiikk/software-engineering

---


## What I do
- Apply software engineering best practices
- Design maintainable systems
- Implement development workflows
- Ensure code quality

## When to use me
When building software systems using professional practices.

## Software Development Lifecycle

### Requirements Engineering
```python
class Requirement:
    """Software requirement"""
    
    def __init__(self, id: str, title: str, description: str,
                 priority: str, category: str):
        self.id = id
        self.title = title
        self.description = description
        self.priority = priority  # must, should, could, wont
        self.category = category  # functional, non-functional
        self.status = "draft"
        self.testable_criteria = []
    
    def is_testable(self) -> bool:
        """Check if requirement is testable"""
        return len(self.testable_criteria) > 0


class RequirementsManager:
    """Manage requirements"""
    
    def __init__(self):
        self.requirements = []
        self.stakeholders = []
    
    def add_requirement(self, requirement: Requirement):
        self.requirements.append(requirement)
    
    def get_by_priority(self, priority: str) -> List[Requirement]:
        return [r for r in self.requirements if r.priority == priority]
    
    def trace_to_code(self, requirement_id: str, 
                     code_elements: List[str]):
        """Trace requirement to code elements"""
        for req in self.requirements:
            if req.id == requirement_id:
                req.code_trace = code_elements
```

## Design Patterns

### Creational
```python
class Singleton:
    """Singleton pattern"""
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance


class Factory:
    """Factory pattern"""
    
    @staticmethod
    def create_product(product_type: str):
        products = {
            "a": ProductA,
            "b": ProductB
        }
        return products[product_type]()


class Builder:
    """Builder pattern"""
    
    def __init__(self):
        self.product = Product()
    
    def set_part_a(self, value):
        self.product.a = value
        return self
    
    def set_part_b(self, value):
        self.product.b = value
        return self
    
    def build(self):
        return self.product
```

### Structural
```python
class Adapter:
    """Adapter pattern"""
    
    def __init__(self, adaptee):
        self.adaptee = adaptee
    
    def request(self):
        return self.adaptee.specific_request()


class Decorator:
    """Decorator pattern"""
    
    def __init__(self, component):
        self.component = component
    
    def operation(self):
        return self.component.operation()
```

### Behavioral
```python
class Observer:
    """Observer pattern"""
    
    def __init__(self):
        self.observers = []
    
    def attach(self, observer):
        self.observers.append(observer)
    
    def notify(self, *args):
        for observer in self.observers:
            observer.update(*args)


class Strategy:
    """Strategy pattern"""
    
    def __init__(self, algorithm):
        self.algorithm = algorithm
    
    def execute(self, data):
        return self.algorithm.process(data)
```

## Testing Strategy
```python
class TestPyramid:
    """Testing pyramid implementation"""
    
    @staticmethod
    def unit_tests():
        """Many fast, isolated unit tests"""
        pass
    
    @staticmethod
    def integration_tests():
        """Fewer integration tests"""
        pass
    
    @staticmethod
    def e2e_tests():
        """Few end-to-end tests"""
        pass
```

## Code Quality

### Metrics
```python
class CodeMetrics:
    """Code quality metrics"""
    
    @staticmethod
    def cyclomatic_complexity(control_flow: dict) -> int:
        """Cyclomatic complexity"""
        return control_flow.get("decisions", 0) + 1
    
    @staticmethod
    def cognitive_complexity(code: str) -> int:
        """Cognitive complexity"""
        # Count nesting, jumps, etc.
        return 0
    
    @staticmethod
    def maintainability_index(halstead: dict, 
                            cyclomatic: int, 
                            lines: int) -> float:
        """Maintainability index 0-100"""
        import math
        
        volume = halstead.get("volume", 1)
        mi = 171 - 5.2 * math.log(volume) - \
             0.23 * cyclomatic - 16.2 * math.log(lines)
        
        return max(0, min(100, mi * 100 / 171))
```