The Missing Piece in Spec-Driven Development: Aggregation and Monitoring
The Missing Piece in Spec-Driven Development: Aggregation and Monitoring
The Spec-Driven Development Wave
Spec-driven development (SDD) is reshaping how teams build software with AI coding assistants. Tools like GitHub Spec Kit, Cursor, Claude Code, and Windsurf are demonstrating that AI agents produce dramatically better code when grounded in clear specifications that define architecture, data models, and capabilities before implementation begins.
The promise is compelling: write specs that capture intent, let AI handle implementation, and maintain consistency across your entire system. But as teams adopt spec-driven workflows, they’re discovering critical gaps that existing tools don’t address.
The Three Critical Gaps
1. Spec Aggregation Across Services
Modern systems aren’t monolithic. You have:
- Multiple microservices across different repositories
- Shared libraries and components
- Third-party integrations and APIs
- Cross-cutting concerns spanning services
The problem: Each service might have its own specs, but there’s no unified view. When Service A changes its API contract, how do you know which other services are affected? When three services implement authentication differently, how do you identify the inconsistency?
Existing spec-driven tools focus on individual projects. They lack mechanisms to:
- Aggregate specifications across multiple repositories
- Identify conflicts and inconsistencies between services
- Track dependencies and integration points holistically
- Maintain architectural coherence at the system level
2. Spec-to-Code Drift Detection
Specifications are living documents, but code evolves independently. The gap emerges gradually:
- Developer makes a quick fix that bypasses the spec
- AI agent generates code based on outdated context
- Refactoring changes implementation patterns
- New dependencies get added without spec updates
The problem: Without active monitoring, specs become documentation that describes what the system should be, not what it actually is. The very foundation of spec-driven development—specs as the source of truth—erodes silently.
Current tools generate code from specs but don’t monitor whether:
- Actual code still matches the specification
- New code follows architectural patterns defined in specs
- Changes violate constraints or principles
- Dependencies introduced align with documented architecture
3. Supervision of Source Code Changes
AI coding agents are powerful but require guardrails. When multiple developers and AI assistants work in parallel, code changes need oversight:
- Does this change align with architectural principles?
- Are new components following established patterns?
- Has the change introduced security vulnerabilities?
- Should the spec be updated to reflect this change?
The problem: Most spec-driven workflows lack real-time supervision. Reviews happen after implementation, when violations are expensive to fix. Teams need proactive monitoring that catches issues as code changes, not days later during PR review.
What’s Missing in Current Tools
GitHub Spec Kit and Similar Tools
GitHub Spec Kit excels at creating structured specs and guiding AI coding agents within a single project. But it doesn’t:
- Aggregate specs across multiple repositories
- Monitor code for drift from specifications
- Provide cross-project architectural consistency checking
- Track specification evolution over time
Specification-First Development Practices
Traditional specification-first approaches emphasize upfront documentation and traceability. However, they:
- Rely on manual review processes
- Lack automated drift detection
- Don’t integrate with modern AI coding workflows
- Struggle with multi-service system complexity
Formal Verification Tools
Tools like Microsoft’s Spec# provide formal verification but:
- Focus on API contracts, not system-level architecture
- Require significant expertise and annotations
- Don’t address specification aggregation challenges
- Operate at code level rather than architectural level
The Solution: Spec Aggregation and Active Monitoring
Effective spec-driven development at scale requires three capabilities that current tools don’t provide:
Unified Spec Aggregation
Collect and consolidate specifications from across your entire system:
- Architecture components from all services
- Data models and schemas across repositories
- API contracts and integration points
- Capabilities and features system-wide
This creates a single source of architectural truth that AI agents and developers can reference, ensuring global consistency while preserving local autonomy.
Continuous Drift Detection
Monitor your codebase against specifications in real-time:
- Track when implementations diverge from documented architecture
- Identify pattern violations as they’re introduced
- Detect new dependencies that conflict with constraints
- Surface inconsistencies between spec and reality
This ensures specifications remain accurate representations of your system, not aspirational documentation.
Intelligent Change Supervision
Supervise code changes with architectural context:
- Validate changes against established principles
- Flag potential security or performance issues
- Suggest spec updates when changes represent intentional evolution
- Alert teams when changes impact dependent services
This provides guardrails for AI agents and human developers, catching issues before they’re merged.
How gjalla Fills the Gaps
gjalla addresses these critical gaps by:
Aggregating Specs Across Your System
- Automatically extract specs from multiple repositories
- Consolidate architecture, data models, and capabilities
- Provide unified view of your entire system
- Track relationships and dependencies across services
Monitoring for Spec-Code Alignment
- Continuous analysis of codebase changes
- Detection of drift from documented architecture
- Identification of pattern violations
- Real-time alerts when code diverges from specs
Supervising Development at Scale
- Architectural guardrails for AI coding agents
- Validation of changes against principles and constraints
- Impact analysis across aggregated specifications
- Intelligent suggestions for spec updates
Real-World Impact
Scenario 1: Microservices Migration Team migrating from monolith to microservices needs to ensure new services follow consistent patterns. gjalla aggregates specs from existing services, monitors new service development for pattern compliance, and flags architectural drift before it solidifies.
Scenario 2: Multi-Team Coordination Ten teams building different services with AI coding assistants. gjalla consolidates specs across all teams, detects when teams are duplicating capabilities, and supervises changes to prevent integration conflicts.
Scenario 3: Audit and Compliance Financial services company needs to demonstrate architectural compliance. gjalla aggregates current-state specs, monitors for violations of security principles, and provides auditable trail of spec-code alignment.
Scenario 4: AI Agent Governance Engineering org adopts Cursor and Claude Code across teams. gjalla provides guardrails that prevent AI agents from introducing inconsistent patterns, monitors for security violations, and keeps specs synchronized with evolving code.
The Path Forward
Spec-driven development represents a fundamental shift in how software is built with AI assistance. But without proper aggregation, monitoring, and supervision, specs become just another form of documentation that drifts out of sync with reality.
The next generation of spec-driven tools must:
- Aggregate specifications across the entire system
- Actively monitor code for drift from specs
- Supervise changes with architectural intelligence
- Maintain specs as living, accurate system representations
This isn’t about replacing existing spec-driven tools—it’s about completing the picture. Use GitHub Spec Kit, Cursor, or Claude Code to generate code from specs. Use gjalla to aggregate those specs across your system, monitor for drift, and supervise changes at scale.
Getting Started
Step 1: Generate specs from your existing codebase Step 2: Aggregate specs across all services and repositories Step 3: Enable continuous monitoring for spec-code drift Step 4: Configure supervision rules for AI coding agents Step 5: Develop with confidence knowing specs stay aligned with reality
Conclusion
Spec-driven development is only as good as the specifications themselves. If specs drift from reality, become fragmented across services, or lack supervision mechanisms, the entire approach collapses.
The industry has solved spec creation and code generation. The missing pieces are aggregation, monitoring, and supervision—the capabilities that make spec-driven development work at enterprise scale with AI coding agents.
Don’t let specification drift undermine your AI coding workflows. Aggregate, monitor, and supervise with gjalla.
Sources: