
Beyond the Core Workflow: How Extensions Bring Security, Property-Based Testing, and Your Own Rules to AI-DLC
AI-DLC's Extensions Framework lets organizations layer enforceable rules — like security baselines and property-based testing — on top of the core adaptive workflow, using a progressive disclosure pattern that only loads full rules when you opt in.
The AI-Driven Development Life Cycle (AI-DLC) changed how we think about AI-assisted software development. Instead of treating AI coding agents as autocomplete on steroids, AI-DLC introduced a structured, adaptive workflow where AI leads the work and humans validate it — across three phases: Inception, Construction, and Operations.
But here's the thing: every organization has its own rules. Your security team has policies. Your compliance folks have checklists. Your testing philosophy might be radically different from the team down the hall. The core AI-DLC workflow can't bake all of that in without becoming bloated and opinionated — the exact problem it was designed to solve.
That's where the Extensions Framework comes in.
The Problem with One-Size-Fits-All Rules
AI-DLC's core workflow is deliberately lean. It handles the universal stuff: requirements analysis, application design, code generation, build and test. It adapts depth and breadth based on your project's complexity. A simple bug fix doesn't get the same treatment as a greenfield microservice.
But what about security? What about property-based testing? What about HIPAA compliance, or your internal coding standards, or accessibility requirements? Hardcoding all of these into the core workflow would violate AI-DLC's own tenets — particularly the principle that the methodology should be agnostic and adaptable.
The Extensions Framework solves this by letting you layer additional rules on top of the core workflow as opt-in, enforceable constraints. Think of it as a plugin system for development methodology.
How Extensions Work
Extensions live under the
extensions/ directory in the AI-DLC rule details folder, organized by category:aws-aidlc-rule-details/└── extensions/ ├── security/ │ └── baseline/ │ ├── security-baseline.md # Full rules (loaded on opt-in) │ └── security-baseline.opt-in.md # Lightweight prompt (always loaded) ├── testing/ │ └── property-based/ │ ├── property-based-testing.md │ └── property-based-testing.opt-in.md └── your-category/ # Add your own └── your-rules/The design follows a principle called progressive disclosure — borrowed from how skills work in agentic systems. At workflow startup, only the lightweight
*.opt-in.md files are loaded. These contain a single structured question that gets presented during Requirements Analysis. The full rule files only load if the developer says yes.Skip an extension? The agent never sees the rules. Zero context window cost. This keeps the base workflow lean while making deep capabilities available on demand.
The Opt-In Flow
During the Requirements Analysis phase, AI-DLC presents each extension's opt-in question as a structured multiple-choice prompt. For example, the security baseline asks:
Should security extension rules be enforced for this project?* A) Yes — enforce all SECURITY rules as blocking constraints* B) No — skip all SECURITY rules* X) Other (please describe)
The PBT extension offers a three-tier choice:
Should property-based testing (PBT) rules be enforced for this project?* A) Yes — enforce all PBT rules as blocking constraints* B) Partial — enforce PBT rules only for pure functions and serialization round-trips* C) No — skip all PBT rules* X) Other (please describe)
Once enabled, extension rules become mandatory, blocking constraints. The AI agent verifies compliance at every applicable stage. Non-compliance is a blocking finding — the stage cannot proceed until it's resolved. This isn't advisory guidance. It's enforcement.
Enforcement Across Stages
Each extension defines which AI-DLC stages its rules apply to. At each applicable stage, the agent:
- Evaluates all extension rule verification criteria against the artifacts produced
- Includes a compliance section in the stage completion summary (compliant / non-compliant / N/A per rule)
- Blocks progression if any rule is non-compliant
Rules that don't apply to the current context (e.g., a stateful testing rule when there are no stateful components) are marked N/A — not a blocking finding.
The Security Baseline Extension: Shifting Left by Default
The security baseline extension ships with AI-DLC as a reference implementation. It contains 15 cross-cutting security rules mapped to the OWASP Top 10 (2025) , covering:
- Encryption at rest and in transit (SECURITY-01)
- Access logging on network intermediaries (SECURITY-02)
- Application-level logging with PII protection (SECURITY-03)
- HTTP security headers for web applications (SECURITY-04)
- Input validation on all API parameters (SECURITY-05)
- Least-privilege access policies (SECURITY-06)
- Restrictive network configuration (SECURITY-07)
- Application-level access control and IDOR prevention (SECURITY-08)
- Security hardening and misconfiguration prevention (SECURITY-09)
- Software supply chain security (SECURITY-10)
- Secure design principles including rate limiting (SECURITY-11)
- Authentication and credential management (SECURITY-12)
- Software and data integrity verification (SECURITY-13)
- Alerting and monitoring (SECURITY-14)
- Exception handling and fail-safe defaults (SECURITY-15)
Each rule includes concrete verification criteria — not vague guidance like "consider security." For example, SECURITY-06 (Least Privilege) requires: no wildcard actions, no wildcard resources (unless the API doesn't support resource-level permissions, documented), separate read/write policy statements, and trust policies scoped to specific services.
The power of embedding security extensions in AI-DLC steering is the trickle-down effect. Security controls infused at the requirements level propagate through system design, code generation, and infrastructure deployment. You don't bolt security on at the end — it's woven into every artifact the agent produces.
This pairs naturally with agentic security tools that can review the AI-DLC-generated design, code, and infrastructure against your security requirements, creating a feedback loop between generation and validation.
The security extension is explicitly described as a directional reference. Each organization should build, customize, and test their own security rules before deploying in production workflows. The framework makes it straightforward to extend — add a new directory under
extensions/security/ (say compliance/hipaa/ or internal-policies/ ), drop in your rule markdown files following the same structure, and they become enforceable constraints.The PBT Extension: Finding the Bugs Your Tests Don't Cover
The newest addition to the AI-DLC extensions ecosystem is the Property-Based Testing (PBT) extension, and it addresses a fundamental gap in how AI agents approach testing.
AI agents generate tests like
assert add(2, 3) == 5 . Useful, but limited to scenarios someone already imagined. They won't check whether addition commutes for all valid floats, whether serialize-then-deserialize always round-trips cleanly, or whether that "idempotent" endpoint truly is idempotent.Property-based testing takes a different approach. You define invariants — properties that must hold for all valid inputs — and a framework generates hundreds of random inputs searching for counterexamples. When it finds one, it shrinks to the minimal failing case. PBT systematically explores the input space that example-based tests leave untouched.
10 Cross-Cutting Rules
The PBT extension defines 10 rules that span the entire AI-DLC workflow:
PBT-01: Property Identification During Design — Every unit with business logic must be analyzed for testable properties during Functional Design. The extension defines seven property categories:
Pattern | Test Shape | When to Use |
|---|---|---|
Round-trip | f_inv(f(x)) == x | Serialization, encoding, parsing |
Invariant | measure(f(x)) == measure(x) | Sort, map, filter, transform |
Idempotence | f(f(x)) == f(x) | Normalization, dedup, cache writes |
Commutativity | f(g(x)) == g(f(x)) | Arithmetic, set operations |
Induction | Property on x implies property on x + element | Recursive structures, trees |
Easy verification | verify(solve(x)) == true | Solvers, optimizers |
Oracle | f(x) == oracle(x) | Optimized vs brute-force |
PBT-02 through PBT-06 enforce specific property types: round-trips for any operation with a logical inverse, invariant verification for documented invariants, idempotency proofs for operations that claim it, oracle testing against reference implementations, and stateful property testing for components with mutable state.
PBT-07: Generator Quality — This is where the extension gets opinionated in the right way. It requires domain-specific generators that produce realistic, structured inputs. No more testing email validation with random strings. Custom generators must respect business constraints, include edge cases, and be reusable across test files.
PBT-08: Shrinking and Reproducibility — Every PBT run must be reproducible via a seed value. Shrinking must be enabled. CI configurations must log seeds. Flaky PBT failures must be investigated, not suppressed.
PBT-09: Framework Selection — The project must select an appropriate PBT framework. The extension provides recommendations by language: Hypothesis for Python, fast-check for JavaScript/TypeScript, jqwik for Java, proptest for Rust, and others.
PBT-10: Complementary Testing Strategy — PBT must complement, not replace, example-based tests. Critical business scenarios still need explicit example-based tests. When PBT discovers a failing case, the shrunk minimal example should be added as a permanent regression test.
Enforcement Integration
The PBT rules map to specific AI-DLC stages:
Stage | What's Enforced |
|---|---|
Functional Design | Property identification in design artifacts (PBT-01) |
NFR Requirements | Framework selection in tech stack decisions (PBT-09) |
Code Generation (Planning) | PBT test steps for identified properties (all rules) |
Code Generation (Generation) | PBT tests alongside example-based tests (PBT-02–08, 10) |
Build and Test | Seed logging and CI integration (PBT-08) |
Partial Enforcement Mode
Not every project needs the full PBT treatment. The extension supports a Partial mode that enforces only PBT-02 (round-trips), PBT-03 (invariants), PBT-07 (generator quality), PBT-08 (shrinking/reproducibility), and PBT-09 (framework selection). The remaining rules become advisory. This is a pragmatic choice for projects with limited algorithmic complexity where full stateful testing or oracle comparison would be overkill.
Building Your Own Extensions
The framework is designed to be extended. To create a new extension:
- Create a directory under
extensions/(e.g.,extensions/accessibility/baseline/)
- Add a
your-extension.opt-in.mdwith a structured multiple-choice question
- Add a
your-extension.mdwith your rules, each containing:
- A unique rule ID
- A clear rule statement
- Concrete verification criteria
- Define which AI-DLC stages each rule applies to
Rules are blocking by default. If verification criteria aren't met, the stage can't proceed. This is intentional — extensions represent hard constraints, not suggestions.
Some ideas for custom extensions:
- Compliance: HIPAA, PCI-DSS, SOC 2 rules tailored to your organization
- Accessibility: WCAG conformance checks enforced during design and code generation
- Performance: Latency budgets, bundle size limits, database query constraints
- Internal standards: Naming conventions, architecture patterns, documentation requirements
Why This Matters
The Extensions Framework turns AI-DLC from a workflow into a platform. The core workflow handles the universal development lifecycle. Extensions encode your organization's specific quality gates, compliance requirements, and engineering standards — and enforce them automatically at every stage.
The progressive disclosure pattern keeps things efficient. You don't pay context window costs for rules you don't use. When you do opt in, enforcement is real — not a suggestion the agent might ignore.
Combined with the adaptive nature of AI-DLC itself (which already modulates breadth and depth based on project complexity), extensions give you a system where AI agents don't just write code faster — they write code that meets your standards, by construction.
The AI-DLC workflow repository is open source under MIT-0. The security baseline and PBT extensions ship as reference implementations. The real power comes from what you build on top of it.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article