Before the recent AI shift, the team at XB Software relied on the Disciplined Agile Delivery (DAD) framework to bring structure, predictability, and scalability to their software projects. DAD has helped them balance agility with discipline, especially in complex, multi-team outsourcing environments where clarity and control are non-negotiable.
With the rise of AI-augmented development, particularly through Agentic SDLCs and Spec-Driven Development (SDD), the traditional Agile and DAD practices they've trusted are being challenged. Some even say that "AI is reshaping Agile." Does that mean DAD is obsolete? Not at all. But it does mean the approach must evolve or risk being left behind.
How the Team Used Disciplined Agile Delivery Before AI
Disciplined Agile Delivery (DAD) is one of the core methodologies at XB Software. It gives them structure and predictability, especially on their complex, multi-team projects. Rather than diving straight into code, they break work into clear phases aligned with their Discovery, Development, and Deployment practices. In each phase, they coordinate specialized roles and deliverables as follows:
- Inception (Discovery). They begin by aligning all stakeholders on the vision, scope, and architecture. In this phase they gather requirements and produce key artifacts, such as a Software Requirements Specification (SRS), an initial UI/UX prototype, and a detailed development plan with estimates. Business analysts, designers, and project managers collaborate closely to ensure every requirement is clear and agreed before any code is written;
- Construction (Development & Testing). Next comes iterative development. Cross-functional teams work in short sprints. Developers manually implement features from the approved specifications, while QA engineers unit-test each component as it's built. They also integrate new modules frequently to form a complete system, and conduct daily standups and peer code reviews to maintain quality. This lets them deliver working increments to stakeholders regularly, adapting to feedback on the fly;
- Transition (Release & Maintenance). Finally, the deployment team, including PMs, developers, and DevOps, launches the solution into the working environment. They configure and customize the system, perform final acceptance tests, and train users as needed. Once live, they move into maintenance, monitor the software, fix any post-launch issues, and add enhancements to improve usability. This stage ensures the delivered product remains stable, effective, and aligned with the business goals.
This structured lifecycle has served the company well by balancing agility with governance. However, with AI-assisted development emerging, they recognized the need to evolve their approach.
Why Agile and DAD Must Change in the Age of AI
The Agile Manifesto famously prioritizes:
- Individuals and interactions over processes and tools;
- Working software over comprehensive documentation;
- Customer collaboration over contract negotiation;
- Responding to change over following a plan.
These values have served the industry well in human-driven development. But when AI enters the picture, the balance shifts.
1. Processes and Tools Are Essential
In an AI-augmented workflow, the tool you choose defines your development process. Whether you're using Claude Code, Replit, GitHub Copilot, or custom agentic frameworks, each tool behaves, interprets context, and produces outputs differently.
Without a clear, well-defined process, AI agents will drift, hallucinate, or generate inconsistent results. In DAD terms, this means teams must formalize their "toolkit" and process boundaries more explicitly than ever before.
2. Documentation Is Your Source of Truth
The old Agile preference for "working software over documentation" falls apart when AI is involved. As the "AI coding" trend has shown, generating code is the easy part. The real challenge is building systems that are coherent, maintainable, and actually do what they were supposed to do. AI doesn't understand intent. It needs clear instructions.
Spec-Driven Development (SDD) becomes critical here. Clear, structured, and unambiguous specifications act as the single source of truth that AI agents follow. In this model, artifacts like a Product Requirements Document (PRD) and an agents.md file (which outlines specific technologies, project structure, code style examples to follow, etc.) are the executable blueprints that bridge human intent and AI execution. Without SDD, you're left with just "vibe coding", where AI produces something that looks right but may be fundamentally flawed, unscalable, or packed with hidden technical debt.
3. Collaboration Still Matters, But with Clear Boundaries
Customer collaboration remains vital, but AI requires precision. Vague requirements lead to vague outputs. In their outsourcing context, this means the team must work even more closely with clients to refine requirements into AI-executable specs.
They also need to define context boundaries for AI agents: what they should and shouldn't change, which libraries to use, which patterns to follow, etc. Without these guardrails, AI can refactor itself into confusion, corrupt its own context, and create unmaintainable code.
How the Team Is Adapting DAD for AI-Augmented Delivery
At XB Software, instead of abandoning DAD, they are adopting it to the new reality. Here's how their approach works.
Phase 1: Inception. From Vision to AI-Ready Specs
In the Inception phase, they now include:
- Structured requirement workshops focused on producing SDD artifacts (OpenAPI specs, behavior-driven scenarios, structured acceptance criteria);
- AI context design, defining which agents will handle which parts of the system, and how they'll communicate;
- Early architecture zoning that prevents context corruption and hallucinations.
This phase is about establishing the "constitution" of the project and formulating the immutable rules that even AI must follow. It's where they define the tech stack, patterns, and conventions that ensure all generated code feels native to the codebase.
They've also introduced new roles:
- Specification Steward ensures specs are clear, consistent, and AI-readable;
- AI Context Manager sets and maintains boundaries for AI agents throughout the lifecycle. This role is crucial for managing the agents.md file and ensuring the AI has the architectural brain of the system at its disposal.
Phase 2: Construction. Shorter Cycles, Stronger Gates
AI can produce working code in hours. That means they've compressed their iteration cycles while increasing validation checkpoints. They need to ensure the AI can maintain focus and consistency, delivering high-quality, reviewable code chunks. Every AI-generated deliverable is verified against:
- SDD compliance. Does it match the spec?
- Architecture alignment. Does it fit the intended context zone?
- Quality gates. Automated tests, security scans, and performance checks.
They still demo to stakeholders frequently, but now they also show spec-to-code traceability, proving that what AI built is what was agreed upon.
Phase 3: Transition. AI-Assisted Validation and Handover
Before deployment, AI agents run spec-compliance audits and context consistency checks. The team also uses AI to generate end-user documentation from the same SDD artifacts, ensuring consistency across deliverables.
Post-release, their retrospectives now include AI behavior reviews:
- Did agents stay within their context?
- Were specs clear enough?
- Where did hallucination or drift occur?
This feedback loop improves both AI governance and SDD practices over time.
The Role of Spec-Driven Development (SDD) in DAD
SDD isn't just another documentation exercise. In an AI-augmented DAD process, it serves three crucial functions:
- Control Mechanism. SDD specs act as executable contracts between human intent and AI execution. They remove ambiguity and reduce the "interpretation gap" that leads to rework;
- Validation Baseline. Every AI output is validated against the spec. This shifts the focus from "does it run?" to "does it do what we specified?" This becomes even more critical when you consider the data from their estimation guides: AI can reduce time spent on coding by ~35%, but it can also increase QA effort if the output isn't tightly controlled. The spec is their tool for that control;
- Future-Proofing Artifact. Clear specs make it easier to refactor, migrate, or scale systems later, because the intent is preserved separately from the implementation.
Read Also Code Rewrite vs Code Refactoring. Choosing the Best Code Transformation Tactics
What This Means for Clients
If you're already working with XB Software or just considering it, here's what you can expect in this new AI-augmented DAD model:
- Faster delivery cycles, but with more upfront clarity needed in requirements;
- Greater transparency through spec-driven traceability;
- Reduced risk of AI-generated technical debt, thanks to strong governance and validation;
- Continuous adaptation as the team learns which specs and contexts work best for different project types.
The company is moving from a code-centric world to a spec-centric one. By treating intent as the source of truth, they allow AI to handle the execution, while their expert teams focus on architecture, validation, and delivering true business value. Their approach remains rooted in the same discipline that's always defined the way they work. But now they're using AI to accelerate it intelligently.
The Future Is Hybrid
The future of software development is a hybrid approach, where structure supports creativity. That's why the team at XB Software is evolving their DAD practice to be AI-ready without losing the control, predictability, and collaboration that their clients rely on. They see a future where:
- Disciplined processes (like DAD) provide the governance and predictability needed for complex systems;
- Clear specifications (following SDD) act as the shared language between humans and AI;
- AI agents handle the heavy lifting of code generation, freeing their engineers to focus on higher-value design and validation work.
Sign in to leave a comment.