# Constitutional Spec-Driven Development: Enforcing Security by Construction in AI-Assisted Code Generation
**Authors**: Srinivas Rao Marri
## Abstract
The proliferation of AI-assisted “vibe coding” enables rapid software development but introduces significant security risks, as Large Language Models (LLMs) prioritize functional correctness over security. We present Constitutional Spec-Driven Development, a methodology that embeds non-negotiable security principles into the specification layer, ensuring AI-generated code adheres to security requirements by construction rather than inspection. Our approach introduces a Constitution: a versioned, machine-readable document encoding security constraints derived from Common Weakness Enumeration (CWE)/MITRE Top 25 vulnerabilities and regulatory frameworks. We demonstrate the methodology through a banking microservices application, selected as a representative example domain due to its stringent regulatory and security requirements, implementing customer management, account operations, and transaction processing. The methodology itself is domain-agnostic. The implementation addresses 10 critical CWE vulnerabilities through constitutional constraints with full traceability from principles to code locations. Our case study shows that constitutional constraints reduce security defects by 73% compared to unconstrained AI generation while maintaining developer velocity. We contribute a formal framework for constitutional security, a complete development methodology, and empirical evidence that proactive security specification outperforms reactive security verification in AI-assisted development workflows.
Keywords: AI code generation, security, microservices, specification-driven development, constitutional constraints, CWE/MITRE
## 1 Introduction
The rapid adoption of AI-assisted code generation has created a fundamental tension in software development: the same tools that dramatically accelerate development velocity also introduce systematic security vulnerabilities. This paper addresses this challenge by introducing the term Constitutional Spec-Driven Development (CSDD), a novel methodology that embeds non-negotiable security constraints into the specification layer, ensuring that AI-generated code is secure by construction rather than by post-hoc verification. To our knowledge, this represents the first formalization of constitutional constraints applied specifically to AI code generation workflows, combining principles from Design by Contract Meyer (1992), Constitutional AI Bai et al. (2022), and specification-driven development into a unified framework for secure AI-assisted software engineering. We use the term “constitution” metaphorically: just as a political constitution establishes foundational principles that govern all subsequent legislation, a software constitution establishes non-negotiable constraints that govern all subsequent code generation. The term implies architectural primacy, not legal obligation.
### 1.1 Motivation
The Rise of Vibe Coding. The emergence of AI-assisted coding tools has fundamentally transformed software development. Large Language Models can generate functional code from natural language descriptions, enabling rapid prototyping and reducing implementation time. This paradigm, termed “vibe coding,” allows developers to describe desired functionality conversationally and receive working implementations. A developer might simply state “create a user registration endpoint” and receive a complete implementation within seconds. However, this acceleration introduces significant security risks that traditional development practices are ill-equipped to address.
The Security Gap in AI-Generated Code. Studies indicate that LLM-generated code frequently contains security vulnerabilities Pearce et al. (2022); Perry et al. (2023); Zhou et al. (2025). Analysis of code produced by popular AI assistants reveals patterns of SQL injection, cross-site scripting, improper authentication, and insufficient input validation, vulnerabilities catalogued in the CWE/MITRE Top 25 Most Dangerous Software Weaknesses MITRE (2025). The fundamental issue is that AI models optimize for functional correctness based on training data distributions, not security requirements specific to deployment contexts. When an AI generates a database query, it produces code that works, but “working” code that concatenates user input into SQL strings creates exploitable injection vulnerabilities.
Regulatory and Industry Pressures. The banking and financial services sector presents acute challenges. Regulatory frameworks including PCI-DSS, SOC 2, and GDPR impose strict security requirements PCI-SSC (2022). A single SQL injection vulnerability in a banking application could expose millions of customer records, resulting in regulatory fines exceeding $10 million, class-action litigation, and irreparable reputation damage. Traditional security practices (code reviews, penetration testing, static analysis) operate as post-hoc verification, detecting vulnerabilities after introduction rather than preventing creation. When AI accelerates code generation by orders of magnitude, reactive security processes become inadequate.
The False Dichotomy. The tension appears fundamental: organizations desire AI-assisted velocity while requiring security guarantees mandated by regulation. Current approaches treat these as competing objectives; teams must choose between moving fast with AI or moving carefully with security. We argue this dichotomy is false and propose a methodology achieving both through architectural intervention at the specification layer. By constraining AI generation before code is produced, rather than inspecting it after, we eliminate entire categories of vulnerabilities while preserving the velocity benefits of AI assistance.
The Core Problem. Contemporary AI coding assistants operate without persistent security constraints. Each request is processed independently, relying on prompt engineering to incorporate security considerations. This suffers from:
- Inconsistency: Security requirements must be restated per prompt, and developers frequently forget to include critical constraints like “use parameterized queries” or “hash passwords with bcrypt”
- Incompleteness: Developers omit requirements they consider obvious, but AI models lack the contextual understanding to infer that a banking application requires stronger security than a prototype
- Drift: Early security specifications do not propagate to later code. A developer who specified secure authentication in sprint one may forget to maintain those standards when implementing new features in sprint five
- Unverifiability: No systematic mechanism exists to verify that generated code adheres to stated requirements across an entire codebase
These limitations are dangerous in vibe coding workflows where developers accept generated implementations with minimal scrutiny. The cognitive offloading that makes AI assistance attractive simultaneously reduces security flaw detection likelihood.
### 1.2 Contributions
This paper introduces Constitutional Spec-Driven Development as a new paradigm and makes the following contributions:
C1. Constitutional Security Framework. We formalize software constitutions, hierarchical constraint systems encoding non-negotiable security requirements as first-class architectural artifacts with versioning and governance. Unlike ad-hoc security guidelines, constitutions are structured documents with explicit CWE mappings, enforcement levels (MUST/SHOULD/MAY), and amendment procedures.
C2. Spec-Driven Development Methodology. We present a complete workflow integrating constitutional constraints with AI-assisted code generation across specification, planning, task decomposition, and implementation phases.
C3. Compliance Traceability Matrix. We introduce systematic mapping of constitutional principles to implementation artifacts at file and line-number granularity, enabling automated compliance verification.
C4. Reference Implementation. We demonstrate the methodology through a banking microservices application addressing 10 CWE/MITRE Top 25 vulnerabilities through constitutional constraints.
C5. Empirical Evaluation. We analyze constitutional constraint effectiveness, measuring compliance rates and defect density compared to unconstrained generation. Our case study demonstrates a 73% reduction in security vulnerabilities, 56% faster time to first secure build, and 4.3x improvement in compliance documentation coverage.
## 2 Background and Context
This section reviews the foundational concepts underlying Constitutional Spec-Driven Development: AI-assisted code generation, known security challenges, and prior work in formal specification and constitutional AI.
### 2.1 AI-Assisted Code Generation
Large Language Models trained on code corpora can generate syntactically correct, functionally appropriate code from natural language prompts Chen et al. (2021). Tools like GitHub Copilot, Claude, and ChatGPT have achieved widespread adoption, with surveys indicating over 70% of professional developers use AI assistance regularly GitHub (2024).
### 2.2 Security Challenges in AI-Generated Code
Research has documented systematic security issues in AI-generated code. Pearce et al. Pearce et al. (2022) found that GitHub Copilot produces vulnerable code in approximately 40% of security-relevant scenarios. Perry et al. Perry et al. (2023) demonstrated that developers using AI assistance write less secure code than those coding manually, partially due to over-reliance on AI output correctness. Zhou et al. Zhou et al. (2025) specifically benchmarked vibe coding vulnerabilities in real-world tasks, confirming that agent-generated code exhibits systematic security weaknesses across diverse application domains. More recently, Liu et al. Liu et al. (2026) conducted a large-scale empirical study of 31,132 AI agent skills, finding that 26.1% contain at least one security vulnerability, including prompt injection, data exfiltration, and privilege escalation risks. Their findings underscore that the specification artifacts guiding AI agents (including constitutional documents) must themselves be authored defensively to resist adversarial manipulation.
### 2.3 Design by Contract
Meyer’s Design by Contract Meyer (1992, 1997) introduced formal specification of software behavior through preconditions, postconditions, and invariants. Our constitutional approach extends this tradition by applying contract-like constraints to AI code generation.
### 2.4 Constitutional AI
Anthropic’s Constitutional AI Bai et al. (2022) demonstrated that AI systems can be guided by explicit principles during training and inference. We adapt this concept from AI alignment to software security, embedding security principles as generation constraints.
## 3 Constitutional Spec-Driven Development
This section presents the core methodology, introducing the key concepts, architectural components, and workflow that comprise Constitutional Spec-Driven Development.
### 3.1 Core Concepts
Constitution. By analogy to political constitutions that establish foundational governing principles, we define a software constitution as a versioned document encoding non-negotiable requirements as machine-readable principles with explicit CWE vulnerability mappings, enforcement levels (MUST/SHOULD/MAY per RFC 2119), and rationale. A constitution is not prescriptive about implementation technology; it specifies what must hold, not how to achieve it.
Spec-Driven Development. A hierarchical workflow where constitutional constraints flow through specification, planning, and implementation phases, ensuring security requirements propagate to generated code.
Compliance Traceability. Systematic mapping from constitutional principles to code artifacts at file and line-number granularity, enabling audit and impact analysis.
### 3.2 Constitutional Principles Structure
Each principle in our banking constitution follows this structure:
1. Identifier: Unique code (e.g., SEC-002)
1. CWE Reference: Specific vulnerability addressed (e.g., CWE-89)
1. Enforcement Level: MUST, SHOULD, or MAY
1. Constraint: What the code must/must not do
1. Implementation Pattern: How to satisfy the constraint
1. Rationale: Why this constraint exists (attack vector)
### 3.3 Compliance Traceability Matrix
The matrix maps each principle to specific implementation artifacts:
- Audit Support: Demonstrable compliance for regulators
- Change Impact Analysis: Understanding which code affects which principles
- Gap Detection: Identifying unimplemented requirements
- Regression Prevention: Ensuring changes do not violate principles
### 3.4 Architecture Overview
Figure 1 illustrates the Spec-Driven Development architecture. The Constitution sits at the apex of the development hierarchy, governing all downstream artifacts. CONSTITUTION - Security Foundation SPECIFICATION LAYER (spec.md, plan.md, tasks.md) AI-ASSISTED GENERATION (Generator + Validator) IMPLEMENTATION (React Frontend + FastAPI Backend + Database) COMPLIANCE TRACEABILITY (Principle $→$ File:Line) 1. Constrains 2. Guides 3. Validates 4. Generates 5. Maps to 6. Traces back
Figure 1: Spec-Driven Development Architecture with Constitutional Constraints
Specification Layer Components: The specification layer comprises three artifacts that translate constitutional principles into implementable work. Feature Specifications (spec.md) define what to build (analogous to functional requirements) while respecting constitutional constraints. Implementation Plans (plan.md) detail how to build features (analogous to technical requirements) with security considerations embedded at the design level. Task Definitions (tasks.md) provide atomic work items (analogous to actionable tasks) that AI-assisted generation can execute within constitutional bounds.
## 4 Implementation
This section describes the reference implementation through a banking microservices application. Banking was selected as the example domain because its well-established regulatory requirements (PCI-DSS, GDPR) and high security stakes make constitutional constraints directly demonstrable. The methodology is domain-agnostic; practitioners in healthcare, e-commerce, government, or any regulated industry can author constitutions tailored to their specific compliance and security needs.
### 4.1 Constitution Document
To illustrate the methodology concretely, our example banking constitution (version 1.0.0) defines 15 security principles across four categories. Other domains would define different principles reflecting their specific regulatory and security requirements:
I. Security-First Principles
- SEC-001 (CWE-79, Cross-Site Scripting (XSS)): All user-supplied data MUST be contextually encoded before rendering
- SEC-002 (CWE-89, SQL Injection): Database queries MUST use parameterized statements or Object-Relational Mapping (ORM) methods exclusively
- SEC-003 (CWE-352, Cross-Site Request Forgery (CSRF)): State-changing operations MUST include anti-CSRF protection
- SEC-004 (CWE-306, Missing Authentication): All Application Programming Interface (API) endpoints except health checks MUST require valid authentication tokens
- SEC-005 (CWE-798, Hardcoded Credentials): Secrets MUST be loaded from environment variables
II. Input Validation Principles
- SEC-006 (CWE-20, Improper Validation): All API inputs MUST be validated against strict schemas
- SEC-007 (CWE-190, Integer Overflow): Financial amounts MUST use Decimal types with explicit precision
III. Authentication & Authorization Principles
- SEC-008 (CWE-287, Improper Authentication): Authentication MUST use OAuth2 with JSON Web Token (JWT) bearer tokens
- SEC-009 (CWE-522, Weak Credentials): Passwords MUST be hashed using bcrypt with cost factor $≥$ 12
- SEC-010 (CWE-862/863, Authorization Failures): Every resource access MUST verify user permissions
- SEC-011 (CWE-613, Session Expiration): Access tokens MUST expire within 15 minutes
IV. Secure Data Handling Principles
- SEC-012 (CWE-312, Cleartext Storage): Sensitive data at rest MUST be encrypted
- SEC-013 (CWE-319, Cleartext Transmission): All communication MUST use Transport Layer Security (TLS) 1.2+
- SEC-014 (CWE-200, Information Exposure): Error responses MUST NOT expose implementation details
- SEC-015 (CWE-532, Log Injection): Log entries MUST NOT contain passwords or tokens
### 4.2 Compliance Traceability Matrix
The Compliance Traceability Matrix provides a bidirectional mapping between constitutional security principles and their concrete implementations in the codebase. This matrix serves multiple purposes: (1) Audit Support, where auditors can verify that each security requirement has a corresponding implementation; (2) Change Impact Analysis, where developers can assess which constitutional principles are affected when modifying specific files; (3) Gap Detection, where missing mappings reveal unimplemented security requirements; and (4) Regression Prevention, where the matrix enables targeted security testing when code changes occur.
Table 1 presents the compliance traceability matrix for critical constitutional principles. Each row maps a security principle to its CWE identifier, the source file containing the implementation, the specific line numbers, and the technique employed.
Table 1: Constitutional Compliance Traceability Matrix
| Password Hashing JWT Authentication OAuth2 Bearer | 522 287 287 | core/security.py core/security.py api/deps.py | 14-24 27-81 17, 35-77 | Bcrypt, cost=12 python-jose, HS256 FastAPI OAuth2 |
| --- | --- | --- | --- | --- |
| Authorization Check | 862 | services/account_service.py | 102-108 | Ownership verification |
| SQL Injection Prevention | 89 | services/*.py | All queries | SQLAlchemy ORM |
| Input Validation | 20 | schemas/*.py | All schemas | Pydantic v2 |
| CORS Configuration | 352 | main.py | 47-55 | Origin whitelist |
| Error Sanitization | 200 | main.py | 78-94 | Generic messages |
| Log Filtering | 532 | core/logging.py | 50-55 | Field redaction |
| Token Expiration | 613 | config.py | 30-31 | 15min/7day tokens |
Note: The file paths and line numbers reference the reference implementation available at https://github.com/srinivasraom/banking-ms-by-constitution.
### 4.3 Key Implementation Details
Authentication Flow (SEC-008, SEC-009, SEC-011). JWT tokens Jones et al. (2015) are generated with typed claims, configurable expiration, and cryptographic signing:
⬇
1 def create_access_token (data: dict) -> str:
2 to_encode = data. copy ()
3 expire = datetime. utcnow () + timedelta (
4 minutes = settings. access_token_expire_minutes
5 )
6 to_encode. update ({
7 "exp": expire,
8 "type": "access"
9 })
10 return jwt. encode (
11 to_encode,
12 settings. secret_key,
13 algorithm = settings. algorithm
14 )
Listing 1: Python: JWT Token Generation (SEC-008, SEC-005, SEC-011)
The create_access_token function demonstrates constitutional compliance: the type claim distinguishes token purposes (SEC-008), expiration defaults to 15 minutes (SEC-011), and the secret key is loaded from environment configuration rather than hardcoded (SEC-005).
Authorization Enforcement (SEC-010). Resource-based access control prevents Insecure Direct Object Reference (IDOR) vulnerabilities:
⬇
1 async def get_account (
2 self, db: AsyncSession,
3 account_number: str,
4 customer_id: str
5) -> Account:
6 account = await self. _get_account_by_number (db, account_number)
7 if account. customer_id != customer_id:
8 raise AuthorizationError ("Not authorized to access this account")
9 return account
Listing 2: Python: Authorization Check with Ownership Verification (SEC-010)
This pattern requires the authenticated customer’s ID as a mandatory parameter and explicitly verifies ownership before returning data. The authorization check occurs after data retrieval to ensure consistent error handling; the same “not authorized” response is returned whether the account does not exist or belongs to another user, preventing information disclosure.
Input Validation (SEC-006, SEC-007). Pydantic v2 schemas provide declarative validation:
⬇
1 class CustomerCreate (BaseModel):
2 email: EmailStr
3 password: str = Field (min_length =8, max_length =128)
4 phone: str = Field (pattern = r’^\+[1-9]\d{1,14}$’)
5 date_of_birth: date
6
7 @field_validator (’date_of_birth’)
8 def validate_age (cls, v):
9 age = (date. today () - v). days // 365
10 if age < 18:
11 raise ValueError (’Must be 18 or older’)
12 return v
Listing 3: Python: Pydantic v2 Input Validation Schema (SEC-006, SEC-007)
The schema demonstrates defense-in-depth: EmailStr validates RFC 5322 email format, Field(min_length=8) enforces password complexity, the phone regex enforces E.164 international format, and the custom validator implements domain-specific business rules (banking age requirements). Pydantic’s validation errors are automatically transformed into standardized 422 responses by FastAPI.
### 4.4 Technology Stack
Constitutional Spec-Driven Development (CSDD) influences technology selection by requiring that each component in the stack provides built-in mechanisms to enforce security principles. Rather than selecting technologies based solely on developer productivity or performance, CSDD mandates that security guarantees be native to the chosen tools. This approach shifts security from an afterthought to a selection criterion, ensuring that the technology stack itself becomes a first line of defense.
Table 2 summarizes the technology stack with constitutional rationale. Each technology was selected because it provides inherent support for specific constitutional principles; for example, SQLAlchemy’s parameterized queries prevent SQL injection by design (SEC-002), while Pydantic’s declarative schemas enable input validation without manual parsing (SEC-006). This constitutional alignment means that using these technologies correctly automatically satisfies the corresponding security requirements.
Table 2: Technology Stack with Constitutional Rationale
| Backend | FastAPI | 0.100+ | OAuth2 support, Pydantic integration |
| --- | --- | --- | --- |
| ORM | SQLAlchemy | 2.0 | Parameterized queries (SEC-002) |
| Validation | Pydantic | v2 | Declarative schemas (SEC-006) |
| Auth | python-jose | 3.3+ | RFC 7519 JWT (SEC-008) |
| Hashing | passlib+bcrypt | 1.7+ | Adaptive hashing (SEC-009) |
| Frontend | React | 18 | JSX auto-escaping (SEC-001) |
| Types | TypeScript | 5.x | Compile-time safety |
| Database | PostgreSQL | 15 | ACID compliance, row-level locking |
## 5 Case Study
This section presents an empirical evaluation of Constitutional Spec-Driven Development through a complete banking microservices implementation. We describe the development process, analyze security violations prevented by constitutional constraints, and present quantitative metrics comparing constitutional development to unconstrained AI-assisted development.
### 5.1 Development Process
We developed the banking application over a two-week period with a single developer utilizing AI assistance (Claude) for code generation. The development followed our five-phase methodology:
Week 1: Foundation and Specification
- Days 1–2: Constitution ratification (15 principles from CWE/MITRE analysis)
- Days 3–4: Feature specification (authentication, accounts, transactions)
- Day 5: Implementation planning (47 code locations identified)
Week 2: Implementation and Verification
- Days 1–3: Backend implementation with constitutional constraints
- Days 4–5: Frontend implementation
- Days 6–7: Verification and compliance matrix generation
### 5.2 Constitutional Violations Prevented
During implementation, constitutional constraints prevented several security vulnerabilities that AI code generation initially produced. We document four representative violations, each illustrating a common pattern where AI assistants optimize for functional correctness while inadvertently introducing security flaws. These violations were detected during constitutional validation and corrected through regeneration with explicit principle references.
Violation 1: Raw SQL Query (CWE-89 - SQL Injection)
When asked to implement transaction filtering by amount, the AI generated code using Python f-strings to construct the SQL query dynamically. This classic SQL injection vulnerability would allow attackers to execute arbitrary SQL commands by manipulating the amount parameter.
Initial AI-generated code (REJECTED):
⬇
1 # REJECTED - Violates SEC-002 (CWE-89)
2 query = f "SELECT * FROM transactions WHERE amount > {amount}"
3 result = await db. execute (text (query))
Listing 4: Python: SQL Injection via f-string Interpolation – Violates SEC-002 (REJECTED)
Constitutional enforcement required ORM usage (ACCEPTED):
⬇
1 # ACCEPTED
2 stmt = select (Transaction). where (Transaction. amount > amount)
3 result = await db. execute (stmt)
Listing 5: Python: Secure ORM Query with Parameterized Values – Satisfies SEC-002 (ACCEPTED)
Violation 2: Plaintext Password Logging (CWE-532)
During customer registration, the AI included the user’s password in audit log details for “complete traceability.” This would expose plaintext passwords in log files, which are often stored with less stringent access controls than production databases.
Initial AI-generated code (REJECTED):
⬇
1 # REJECTED - Violates SEC-015 (CWE-532)
2 async def register_customer (db: AsyncSession, customer_data: CustomerCreate):
3 customer = Customer (** customer_data. dict ())
4 db. add (customer)
5 await db. commit ()
6
7 audit_log = AuditLog (
8 action = AuditAction. CREATE,
9 resource_type = "customer",
10 details ={
11 "email": customer_data. email,
12 "password": customer_data. password,
13 "phone": customer_data. phone
14 }
15 )
16 db. add (audit_log)
17 await db. commit ()
18 return customer
Listing 6: Python: Password Exposure in Audit Logs – Violates SEC-015 (REJECTED)
Constitutional enforcement excluded sensitive fields (ACCEPTED):
⬇
1 # ACCEPTED
2 async def register_customer (db: AsyncSession, customer_data: CustomerCreate):
3 customer = Customer (** customer_data. dict ())
4 db. add (customer)
5 await db. commit ()
6
7 audit_log = AuditLog (
8 action = AuditAction. CREATE,
9 resource_type = "customer",
10 details ={
11 "email": customer_data. email,
12 "phone": customer_data. phone,
13 "customer_id": str (customer. id)
14 }
15 # password explicitly excluded per SEC-015
16 )
17 db. add (audit_log)
18 await db. commit ()
19 return customer
Listing 7: Python: Secure Audit Logging with Credential Exclusion – Satisfies SEC-015 (ACCEPTED)
Violation 3: Missing Authorization Check (CWE-862)
The AI generated account retrieval that fetched accounts solely by account number without verifying ownership. This Insecure Direct Object Reference (IDOR) vulnerability would allow any authenticated user to access any other user’s account details by guessing or enumerating account numbers, a massive privacy breach with regulatory implications under PCI-DSS and GDPR.
Initial AI-generated code (REJECTED):
⬇
1 # REJECTED - Violates SEC-010 (CWE-862)
2 async def get_account (self, db: AsyncSession, account_number: str):
3 result = await db. execute (
4 select (Account). where (Account. account_number == account_number)
5 )
6 account = result. scalar_one_or_none ()
7 if not account:
8 raise NotFoundError ("Account not found")
9 return account
Listing 8: Python: Missing Authorization Check (IDOR) – Violates SEC-010 (REJECTED)
Constitutional enforcement required ownership verification (ACCEPTED):
⬇
1 # ACCEPTED
2 async def get_account (
3 self, db: AsyncSession,
4 account_number: str,
5 customer_id: str
6) -> Account:
7 result = await db. execute (
8 select (Account). where (Account. account_number == account_number)
9 )
10 account = result. scalar_one_or_none ()
11 if not account:
12 raise NotFoundError ("Account not found")
13 if account. customer_id != customer_id:
14 raise AuthorizationError ("Not authorized to access this account")
15 return account
Listing 9: Python: Secure Account Retrieval with Ownership Verification – Satisfies SEC-010 (ACCEPTED)
Violation 4: Improper Input Validation (SEC-006, CWE-20). The AI generated a fund transfer endpoint that accepted raw numeric input without validation, allowing negative amounts, excessively large values, and unbounded decimal precision. This violated SEC-006 (validate and sanitize all external input) and exposed the system to CWE-20 (Improper Input Validation) and CWE-190 (Integer Overflow or Wraparound).
Initial AI-generated code (REJECTED):
⬇
1 # REJECTED - Violates SEC-006 (CWE-20) and SEC-007 (CWE-190)
2 class TransferRequest (BaseModel):
3 from_account: str
4 to_account: str
5 amount: float # No constraints on value
6
7 async def transfer_funds (request: TransferRequest, db: AsyncSession):
8 from_acc = await get_account (db, request. from_account)
9 to_acc = await get_account (db, request. to_account)
10 from_acc. balance -= request. amount # Negative amounts reverse flow
11 to_acc. balance += request. amount
12 await db. commit ()
13 return {"status": "completed", "amount": request. amount}
Listing 10: Python: Transfer Without Input Validation – Violates SEC-006 (REJECTED)
Constitutional enforcement required strict input validation (ACCEPTED):
⬇
1 # ACCEPTED
2 class TransferRequest (BaseModel):
3 from_account: str = Field (..., pattern = r"^[A-Z0-9]{10}$")
4 to_account: str = Field (..., pattern = r"^[A-Z0-9]{10}$")
5 amount: Decimal = Field (
6 ..., gt = Decimal ("0"), le = Decimal ("1000000"),
7 decimal_places =2
8 )
9
10 @field_validator ("to_account")
11 @classmethod
12 def accounts_must_differ (cls, v, info):
13 if v == info. data. get ("from_account"):
14 raise ValueError ("Cannot transfer to the same account")
15 return v
16
17 async def transfer_funds (request: TransferRequest, db: AsyncSession):
18 from_acc = await get_account (db, request. from_account)
19 if from_acc. balance < request. amount:
20 raise InsufficientFundsError ("Insufficient balance")
21 from_acc. balance -= request. amount
22 to_acc = await get_account (db, request. to_account)
23 to_acc. balance += request. amount
24 await db. commit ()
25 return {"status": "completed", "amount": str (request. amount)}
Listing 11: Python: Secure Transfer with Pydantic v2 Validation – Satisfies SEC-006, SEC-007 (ACCEPTED)
### 5.3 Quantitative Results
To evaluate the effectiveness of constitutional constraints, we conducted a comparative analysis implementing the same banking application requirements twice: once using Constitutional Spec-Driven Development and once using standard AI-assisted development without constitutional constraints (the “vibe coding” baseline). Both implementations used the same AI assistant (Claude) and the same developer.
Table 3 presents the security metrics comparison between constitutional and unconstrained development.
Table 3: Security Metrics Comparison
| CWE Violations Detected | 3 | 11 | 73% reduction |
| --- | --- | --- | --- |
| Time to First Secure Build | 4 days | 9 days | 56% faster |
| Compliance Documentation | 100% | 23% | 4.3x coverage |
| Security Review Iterations | 1 | 4 | 75% reduction |
| Lines of Security Code | 847 | 612 | 38% more thorough |
### 5.4 Compliance Verification
The compliance traceability matrix was generated by systematically analyzing the codebase against constitutional principles. For each principle (SEC-001 through SEC-015), we identified all code locations implementing that principle and recorded the file path, line numbers, and implementation technique.
Table 4 presents the compliance verification summary.
Table 4: Compliance Verification Summary
| Constitutional principles defined | 15 |
| --- | --- |
| Principles fully implemented | 15 (100%) |
| Specific code locations mapped | 47 |
| CWE vulnerabilities in scope | 10 |
| CWE vulnerabilities addressed | 10 (100%) |
| Compliance gaps identified | 0 |
### 5.5 Security Coverage Distribution
Figure 2 illustrates the distribution of security implementation effort across vulnerability categories. The distribution reflects the relative complexity and prevalence of each vulnerability type in the banking domain, with authentication requiring the largest effort (25%) due to the complexity of OAuth2/JWT implementation, password hashing, and token lifecycle management. 25% 20% 20% 15% 15% 5% Authentication (CWE-287, 522) Authorization (CWE-862, 863) Input Validation (CWE-20) SQL Injection (CWE-89) Data Protection (CWE-200, 532) Session Management (CWE-613)
Figure 2: CWE Vulnerability Coverage by Implementation Effort
## 6 Lessons Learned
This section synthesizes key insights from implementing Constitutional Spec-Driven Development in the banking microservices case study. We organize lessons into three categories: constitution design, AI integration strategies, and methodology adoption considerations.
### 6.1 Constitution Design Principles
Lesson 1: Specificity Enables Enforcement. Vague principles like “use secure coding practices” provided insufficient guidance. After revising to specific principles referencing CWE identifiers and implementation patterns, compliance improved from inconsistent to 100%.
Lesson 2: Rationale Enables Contextual Judgment. Including the rationale (WHY) alongside the constraint (WHAT) and pattern (HOW) enabled appropriate decisions in edge cases.
Lesson 3: Governance Mechanisms Prevent Constitutional Drift. Semantic versioning and approval workflows prevented ad-hoc modifications that would compromise security.
Lesson 4: Constitutional Documents Must Resist Adversarial Manipulation. Because constitutional specifications are consumed by AI agents as natural language instructions, they represent an attack surface for prompt injection and specification poisoning. Liu et al. Liu et al. (2026) demonstrated that 26.1% of AI agent skills in production contain exploitable vulnerabilities, including prompt injection vectors that can override intended behavior. Constitutional documents must therefore be authored defensively: principles should use unambiguous, declarative language that cannot be reinterpreted through injected context; specifications should avoid patterns that could be exploited to weaken constraints (e.g., conditional overrides, user-controlled exception clauses); and constitution files should be treated as security-critical artifacts with access controls, code review requirements, and integrity verification equivalent to production deployment configurations.
### 6.2 AI Integration Strategies
Integrating constitutional constraints with AI code generation systems requires specific strategies for effective implementation.
Lesson 5: Context Window Management is Critical. Large constitutional documents may exceed AI model context window limits, causing truncation of critical security principles. Including only task-relevant principles (3-5 per request) improved compliance rates significantly. Table 5 presents principle adherence rates by context strategy.
Table 5: Impact of Context Management Strategy on Compliance
| Full Constitution Relevant Selection Hierarchical | 15 3-5 5-8 | 78% 96% 91% | Inconsistent High Good |
| --- | --- | --- | --- |
Lesson 6: Iterative Refinement Outperforms Manual Patching. Regeneration with explicit principle references (1.4 iterations) outperformed manual patching (3.2 iterations).
Lesson 7: Traceability Requires Automated Tooling. Manual compliance mapping achieved only 94% accuracy; automated tooling achieved 100%.
### 6.3 Methodology Adoption
Organizational adoption of Constitutional Spec-Driven Development requires addressing human factors alongside technical implementation.
Lesson 8: Upfront Investment Yields Downstream Efficiency. Constitution creation (16 hours) was recovered through 4x reduction in security review cycles.
Lesson 9: Framing Determines Adoption Success. Presenting constraints as “guardrails preventing costly rework” achieved higher adoption than “bureaucratic security requirements.”
Lesson 10: Domain Criticality Determines Adoption Priority. Regulated industries (financial services, healthcare, government) benefit most from constitutional approaches.
### 6.4 Beyond Security: Generalizability of Constitutional Constraints
While this paper focuses on security principles, the constitutional constraint mechanism is not limited to security. The same specification-driven enforcement model generalizes to any domain where non-negotiable requirements must be preserved across AI-generated code. We identify four categories of constitutional extension:
Architectural Principles. Organizations can encode architectural constraints such as layered separation (controllers must not access the database directly), dependency inversion (depend on abstractions rather than concrete implementations), and bounded context boundaries in domain-driven design. These principles prevent AI-generated code from violating structural invariants that are difficult to detect through testing alone.
Design Patterns and Conventions. Constitutional principles can mandate the use of specific design patterns: repository pattern for data access, factory pattern for object creation, or event-driven communication between services. For example, a principle such as “All inter-service communication must use asynchronous message queues; synchronous HTTP calls between services are prohibited” ensures consistency across AI-generated microservice implementations.
Proprietary and Organizational Guidelines. Enterprises maintain internal standards governing naming conventions, logging formats, error handling strategies, and API versioning schemes. Encoding these as constitutional principles ensures that AI-generated code conforms to organizational norms without requiring manual post-generation review for style and convention adherence.
Performance and Scalability Constraints. Principles such as “All database queries must use parameterized pagination with a maximum page size of 100 records” or “All external API calls must implement circuit breaker patterns with configurable timeout thresholds” encode operational requirements that are frequently overlooked in initial code generation.
This generalizability positions Constitutional Spec-Driven Development not merely as a security methodology but as a general-purpose framework for constraint-preserving AI code generation across any dimension of software quality.
### 6.5 Limitations
While our case study demonstrates significant benefits, Constitutional Spec-Driven Development has inherent limitations that practitioners must understand:
1. Bounded by Known Vulnerability Classes: Constitutional principles derived from CWE/OWASP frameworks MITRE (2025); OWASP (2021) address known vulnerability patterns but cannot anticipate zero-day attack vectors or novel vulnerability classes
1. Technical Vulnerabilities Only: Constitutional constraints effectively address technical vulnerability patterns (injection, authentication bypass) but do not address business logic flaws specific to application semantics
1. AI Capability Dependency: The methodology’s effectiveness depends on the AI model’s capability to understand natural language principles and translate them into correct implementations
1. Constitution Completeness: Constitutional documents may contain gaps (security requirements not captured in any principle), representing silent vulnerabilities
1. Specification-Layer Attack Surface: Constitutional documents, as natural language artifacts consumed by AI agents, are susceptible to prompt injection and specification poisoning attacks Liu et al. (2026). Adversarial modifications to constitution files could weaken or bypass security constraints, requiring that these artifacts be treated with the same access control rigor as production security configurations
### 6.6 Threats to Validity
We acknowledge several threats to the validity of our findings that contextualize the generalizability of results:
Internal Validity. Our case study involved a single development team with prior security training, potentially inflating observed benefits. The team’s awareness of being studied may have influenced adherence to constitutional constraints (Hawthorne effect).
External Validity. Our reference implementation addresses a specific domain (banking) with well-understood security requirements aligned with established frameworks. Results may not generalize to domains with novel or poorly understood security requirements.
Construct Validity. Security defect measurement relied on static analysis tools and manual review, potentially missing subtle vulnerabilities. Compliance metrics measure documented traceability rather than actual security effectiveness.
Conclusion Validity. Small sample size (n=1 project) limits statistical power for quantitative claims. Replication across multiple projects and teams is needed to establish robust effect size estimates.
## 7 Conclusion
We presented Constitutional Spec-Driven Development, a methodology for enforcing non-negotiable security requirements in AI-assisted code generation. By embedding security principles as first-class architectural constraints, we transform security from a reactive verification activity to a proactive generation constraint.
Our banking microservices case study demonstrates that constitutional constraints reduce security defects by 73% while maintaining development velocity. The compliance traceability matrix provides auditable evidence of security requirement implementation, addressing regulatory compliance needs in financial services.
The key insight is that AI code generation should not operate in an unconstrained space. Just as constitutional law constrains governmental action, software constitutions constrain code generation to produce implementations that are secure by construction.
### 7.1 Future Work
Several directions extend this research:
- Automated Constitution Generation: Deriving constitutional principles automatically from regulatory documents (PCI-DSS, HIPAA) using Natural Language Processing (NLP) techniques
- Real-time Validation: Implementing constitutional validation as an Integrated Development Environment (IDE) plugin that checks generated code against principles before acceptance
- Constitution Inheritance: Enabling cross-project constitution composition where domain-specific constitutions extend base security frameworks
- Broader Empirical Studies: Replicating results across diverse development teams, domains, and AI models to establish generalizability
The source code for our reference implementation is available at: https://github.com/srinivasraom/banking-ms-by-constitution
The Speckit framework Speckit (2026) is available at: https://github.com/github/spec-kit
Practitioners can begin using the methodology immediately through Speckit’s AI agent slash commands:
- /speckit.constitution: Establish project security principles
- /speckit.specify: Create baseline feature specification
- /speckit.plan: Generate implementation plan
- /speckit.tasks: Generate actionable task definitions
- /speckit.implement: Execute implementation with constitutional constraints
## References
- Pearce et al. [2022] H. Pearce, B. Ahmad, B. Tan, B. Dolan-Gavitt, and R. Karri. Asleep at the keyboard? Assessing the security of GitHub Copilot’s code contributions. In Proc. IEEE Symposium on Security and Privacy (S&P), 2022.
- Perry et al. [2023] N. Perry, M. Srivastava, D. Kumar, and D. Boneh. Do users write more insecure code with AI assistants? In Proc. ACM Conference on Computer and Communications Security (CCS), 2023.
- MITRE [2025] MITRE Corporation. 2025 CWE top 25 most dangerous software weaknesses, 2025. https://cwe.mitre.org/top25/.
- PCI-SSC [2022] PCI Security Standards Council. Payment Card Industry Data Security Standard v4.0, 2022.
- Chen et al. [2021] M. Chen et al. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374, 2021.
- GitHub [2024] GitHub. The state of the Octoverse: AI in software development, 2024.
- Meyer [1992] B. Meyer. Applying design by contract. IEEE Computer, 25(10):40–51, 1992.
- Meyer [1997] B. Meyer. Object-Oriented Software Construction. Prentice Hall, 2nd edition, 1997.
- Bai et al. [2022] Y. Bai et al. Constitutional AI: Harmlessness from AI feedback. arXiv preprint arXiv:2212.08073, 2022.
- OWASP [2021] OWASP Foundation. OWASP top ten web application security risks, 2021.
- Jones et al. [2015] M. Jones, J. Bradley, and N. Sakimura. JSON Web Token (JWT). RFC 7519, IETF, 2015.
- Zhou et al. [2025] Y. Zhou, X. Liu, Y. Li, Y. Wan, and Y. Liu. Is vibe coding safe? Benchmarking vulnerability of agent-generated code in real-world tasks. arXiv preprint arXiv:2512.03262, 2025.
- Liu et al. [2026] Y. Liu, W. Wang, R. Feng, Y. Zhang, G. Xu, G. Deng, Y. Li, and L. Zhang. Agent skills in the wild: An empirical study of security vulnerabilities at scale. arXiv preprint arXiv:2601.10338, 2026.
- Speckit [2026] Speckit. Speckit: Constitutional spec-driven development framework for AI-assisted code generation, 2026. https://github.com/github/spec-kit.