# Simon Martinelli - Lessons from Spec-driven Development - AI Native DevCon June 2026

## Executive summary

The talk introduces the AI Unified Process, a spec-driven approach designed to combat code and specification drift in large, long-lived enterprise applications. Instead of treating code as the source of truth, this method uses system use cases (specifically SysML use cases) and domain/entity models as stable contracts. AI is leveraged not for full regeneration, but for generating and updating code and tests incrementally from these specifications, enabling modernization efforts that are more robust than simple 'lift and shift' migrations.

## Key takeaways

- Spec-Driven Development (SDD) as the Source of Truth: System use cases act as a stable contract for application behavior. Code is derived from these specs, ensuring that changes are managed through formal requirements updates rather than relying solely on code maintenance.
- Modernization via Specification Extraction: For modernization projects (e.g., ERP systems), the process involves reverse-engineering use cases and entity models from existing documentation, code, and tests. This allows for feature integration without being limited to a simple technology migration.
- Architectural Shift: Self-Contained Systems: To effectively use AI in large systems, the architecture should move away from overly distributed microservices (which create context management issues) toward 'Self-contained systems'—vertical splits that keep UI, business logic, and database within a single project or application.

## Technical details

- AI Unified Process Workflow: The process starts with defining the vision, gathering requirements (using Product Requirements Documents/Requirements Catalog), generating an Entity Model (domain model), and creating SysML use cases. Code generation is then driven directly from these specs, skipping intermediate 'plan' or 'task' phases common in tool-centric approaches.
- Specification Artifacts: The core artifacts include SysML use cases (which define behavior with pre/post conditions and scenarios), the Entity Model (domain model derived from database structure), and UI specifications (e.g., Figma designs). The post-conditions of a use case serve as verifiable acceptance criteria for testing.
- Development Flow & CI/CD: The recommended development flow is to start with tests (Test-Driven Development) and use those tests to drive code generation. The process emphasizes continuous flow over fixed sprints, utilizing use cases in a Kanban manner.
- AI Implementation Best Practices: When using AI agents for development, it is crucial to define clear 'skills' and guardrails. The speaker advises against letting AI create an entire project (due to token waste) and recommends using dedicated CLI tools (like Spring Initializr) for initial setup.

## Practical implications

- Shifts the focus of development teams from writing code to refining and maintaining comprehensive specifications (requirements engineering).
- Reduces team size required for maintenance/modernization by enabling a single developer to manage multiple self-contained systems.
- Accelerates the requirements phase: The work shifts 'left,' allowing business stakeholders (Product Owners, Requirements Engineers) to drive specification changes rapidly, minimizing development bottlenecks.

## Topics

Spec-Driven Development, Enterprise Architecture, AI in Software Engineering, Software Modernization, Domain Modeling, AI Native Dev.io, SysML use cases

Source: https://www.youtube.com/watch?v=odbNXv9xXjc