specification-driven-generation

Specification-Driven Generation

Generate implementation code and validation tests from written specifications through a systematic specification-to-code workflow.

Workflow

1. Analyze Specification

Read and extract requirements from the specification:

• Identify functional requirements (what the code must do)
• Extract input/output contracts (parameters, return types, constraints)
• Note edge cases, error conditions, and validation rules
• Understand performance requirements or complexity constraints
• Identify data structures and algorithms needed

2. Design Implementation

Plan the code structure before writing:

• Choose appropriate data structures
• Select efficient algorithms
• Plan class/function organization
• Identify helper functions needed
• Consider error handling approach

3. Generate Implementation

Write clean, well-documented code that satisfies the specification:

Code Structure:

• Use clear, descriptive names that reflect the specification
• Add docstrings/comments explaining the specification being implemented
• Include type hints/annotations where applicable
• Implement all required functionality
• Handle edge cases and errors per specification

Common Patterns:

• Data structures: Classes with proper encapsulation, initialization, and methods
• Algorithms: Step-by-step implementation with complexity documentation
• Validators: Input validation matching specification constraints
• Utilities: Helper functions for complex operations

4. Generate Tests

Create comprehensive tests that validate the implementation against the specification:

Test Coverage:

• Normal cases from specification examples
• Edge cases mentioned in specification
• Error cases and validation rules
• Boundary conditions
• Performance requirements (if specified)

Test Structure:

# Example: Testing a sorted list data structure
def test_basic_functionality():
    # From spec: "Insert elements in sorted order"
    sl = SortedList()
    sl.insert(5)
    sl.insert(2)
    sl.insert(8)
    assert sl.to_list() == [2, 5, 8]

def test_edge_case_duplicates():
    # From spec: "Allow duplicate elements"
    sl = SortedList()
    sl.insert(3)
    sl.insert(3)
    assert sl.to_list() == [3, 3]

def test_error_handling():
    # From spec: "Raise TypeError for non-comparable items"
    sl = SortedList()
    with pytest.raises(TypeError):
        sl.insert("string")
        sl.insert(5)