Agentic Development Enablement
Your team already has the agents. We install the method.
Codenovai trains engineering and product teams to run AI-DLC, the AI-Driven Development Lifecycle open-sourced by AWS Labs, using Spec Kit, GitHub's spec-driven development toolkit. You get the vocabulary — Intents, Units of Work, Bolts, Mob Elaboration — and the control system underneath it: evals, review gates, and audit logs. Installed on your codebase, run by your people, in six to eight weeks.
The Two Frameworks
AI-DLC
AI-Driven Development Lifecycle · AWS Labs, open source
AI-DLC is an AI-native software methodology in which the AI drafts the plan, asks clarifying questions, and waits for a human decision before it acts. Work moves through three phases — Inception (what and why), Construction (how), and Operations (deploy and run) — and the team elaborates each phase together rather than in silos.
awslabs/aidlc-workflowsSpec-Driven Development
SDD, via Spec Kit · GitHub, open source
Spec-Driven Development makes the specification the source of truth and the code its output. Instead of prompting an agent and hoping, you write a constitution, a spec, and a plan — then the agent implements against artifacts a human already approved. Spec Kit is GitHub's toolkit that turns that loop into concrete commands.
github/spec-kitThey solve different halves of the same problem. AI-DLC changes how the team decides; Spec Kit changes how the work is specified and executed. Adopting one without the other is the most common failure we are called in to fix.
Why Teams Stall
Adoption is not the problem. Nobody changed how decisions get made.
Almost every team we assess has already bought the tools. What they have not changed is the operating model around them — so agents get pointed at underspecified tickets, produce plausible output at volume, and land in a review process that was designed for human-sized pull requests. The output looks like progress and behaves like debt.
The spec never existed
The agent inferred the requirement, and inferred it differently in each session. Nobody can say which version was correct because nothing was written down.
Review became a bottleneck
Output arrives faster than anyone can meaningfully read it, so review degrades into approval. The gate is still there; it stopped being a gate.
Product got left behind
Engineering moved to a new cadence and product kept writing two-week tickets, so the fastest part of the pipeline is now waiting on the slowest.
The AI-DLC Flow
Three phases. The AI proposes, the team decides, nothing ships unapproved.
AI-DLC is adaptive by design — it only runs the stages that earn their keep for a given change, so a one-line fix does not acquire a governance programme. What stays constant is the shape: the AI drafts, it asks what it cannot know, and a human decides before it acts.
01
Inception
Mob ElaborationWhat are we building, and why?
The AI turns an Intent into requirements, user stories, and Units of Work — then stops and asks the questions it cannot answer. Product, engineering, security and ops answer in the same room, once. Risk and complexity are assessed here, so a trivial change never gets a heavyweight process it does not need.
Outputs
- Intent, validated
- Units of Work with dependencies
- Acceptance criteria
- Risk & complexity assessment
02
Construction
Mob ConstructionHow is it actually built?
The AI proposes a logical architecture, a domain model, the code, and the tests. Your engineers review the proposal — not a blank page — and decide. This is where Spec Kit does the heavy lifting: constitution, spec, plan, tasks, then implementation against artifacts a human already approved.
Outputs
- Logical architecture & domain model
- Spec → plan → tasks
- Implementation + tests
- Cross-artifact consistency check
03
Operations
Mob OpsHow does it stay alive?
Infrastructure as code, deployment, observability, and production-readiness validation — generated and reviewed on the same terms as the application code. The loop closes: what you learn in production corrects the spec, not just the codebase.
Outputs
- Infrastructure as code
- Deployment automation
- Monitoring & observability
- Production-readiness validation
Sprints Become Bolts
The vocabulary changes because the unit of work changed.
AI-DLC renames the Agile furniture deliberately — not as branding, but because keeping the old words keeps the old batch sizes. A Bolt is hours or days. An epic becomes a Unit of Work. This is the part of the change your product manager owns.
Sprint — two weeks
Bolt — hours or days
The batch shrinks because elaboration and implementation stopped being separate calendar events.
Epic
Unit of Work
A named, independently deliverable slice with dependencies and parallelisation boundaries made explicit up front.
Backlog grooming
Mob Elaboration
One live session where the AI asks and the whole team answers — instead of a week of asynchronous clarification.
PRD
Intent + Constitution + Spec
The intent states the outcome, the constitution states the non-negotiables, the spec is executable by an agent.
Story points
Acceptance criteria + eval scores
You stop estimating effort you no longer control, and start specifying the condition that proves it worked.
Definition of done
Verification criteria
Concrete checks the agent evaluates and a human signs off — a blocking constraint, not a wiki page.
Retro
Bolt review + spec correction
The fix lands in the constitution or the spec, so the same mistake cannot be regenerated next Bolt.
The Spec Kit Loop
Eight commands that turn a specification into something executable.
Spec Kit inverts the usual relationship: the specification is the source of truth and the code is its output. Each command produces an artifact a human reviews, which is what makes the implementation step safe to hand to agents. We teach the whole loop on your repository — and we teach where each artifact stops being worth writing.
/speckit.constitutionTech lead · once
Writes the project's governing principles — the non-negotiables that every later artifact inherits. Your architecture rules, security posture, and review policy stop being tribal knowledge.
/speckit.specifyProduct + engineering
Describes what to build and why, deliberately excluding the how. This is the artifact your product manager owns and reviews.
/speckit.clarifyMob session
Surfaces underspecified areas before any planning happens. This command is where most of the value hides — ambiguity is far cheaper to kill here than in review.
/speckit.planEngineering
Produces the technical plan: stack, architecture, and the trade-offs behind them, constrained by the constitution.
/speckit.tasksEngineering
Breaks the plan into actionable, reviewable tasks — the units agents can execute in parallel.
/speckit.analyzeReview gate
Checks consistency and coverage across constitution, spec, plan, and tasks before a line of code is generated.
/speckit.implementAgents, human-reviewed
Executes the tasks against the approved plan. Because the artifacts were reviewed, review here is about correctness — not about guessing what was intended.
/speckit.checklist · /speckit.convergeOngoing
Generates quality checklists, and assesses an existing codebase against the artifacts to find what is still outstanding — the brownfield entry point.
Two Tracks, One Room
We train engineers and product managers together, because the method only works if both changed.
The single most common failure mode is an engineering-only rollout. Mob Elaboration is not a developer ceremony — it needs the person who can decide what the product should do, in the room, answering questions live. Each track has its own material; the sessions overlap where the handoffs are.
Track A
Engineering
Engineers, tech leads, platform and staff+. Hands on keyboard, on your repository.
- Writing a constitution your team will actually honour, and encoding it as steering rules (AGENTS.md, .cursor/rules, .amazonq/rules, .kiro/steering)
- The full Spec Kit command loop on your own repository, not a toy project
- Decomposing a Unit of Work into tasks agents can run in parallel without colliding
- Building a golden test set and an offline eval harness you can re-run every Bolt
- Review gates: what a human must read, what a machine can pass, and where to draw that line
- MCP integration so agents work inside your repo, database, and cloud with scoped, audited permissions
- Prompt-injection defence, cost caps, and runaway protection before anything touches production
- Brownfield entry: running /speckit.converge against a legacy codebase to find the real gap
Track B
Product
Product managers, product owners, delivery leads, and whoever currently owns the roadmap.
- Writing an Intent that an agent can decompose — and recognising one that cannot be
- Running Mob Elaboration: how to answer an AI's clarifying questions as a group without the session sprawling
- Splitting an Intent into Units of Work with honest dependencies and parallelisation boundaries
- Writing acceptance criteria that are machine-verifiable, not aspirational
- Planning and running a Bolt — scoping to hours or days, and knowing when to stop one
- Reading eval output and review-gate results instead of story-point burndown
- Where the product manager's approval is structurally required, and where it is noise
- Rebuilding your ceremonies: what replaces standup, grooming, planning, and retro
The Vocabulary
- Intent
- The business outcome you want, written in one paragraph before anything is broken down. AI-DLC starts here rather than at a ticket.
- Unit of Work
- A self-contained, independently deliverable slice decomposed from an Intent — AI-DLC's replacement for the epic. Units carry dependencies, acceptance criteria, and explicit parallelisation boundaries.
- Bolt
- The smallest iteration in AI-DLC, measured in hours or days rather than the two weeks of a sprint. A Bolt takes one Unit of Work from elaboration to something running and reviewed.
- Mob Elaboration
- The Inception-phase working session where product, engineering, security, and operations answer the AI's clarifying questions together and turn an Intent into Units of Work — instead of routing questions through a backlog.
- Mob Construction
- The Construction-phase equivalent: the AI proposes logical architecture, a domain model, code, and tests, and the team reviews and decides together in real time.
- Constitution
- In Spec Kit, the project's governing principles — the non-negotiables every generated spec, plan, and implementation must respect. It is written once and enforced on every run.
How We Run It
Assess, install, ship one real Bolt, then leave.
01
Week 0Assess
We baseline what you have: delivery metrics, test coverage, version-control maturity, review culture, and where AI has already leaked into the team unmanaged. This determines whether you need enablement or repair first — and we will tell you if it is repair.
02
Weeks 1–2Install
Constitution, steering files, Spec Kit initialised against your repo, MCP servers wired to your systems, the eval harness stood up, and review gates defined in CI. Your stack, your cloud, your agent of choice.
03
Weeks 3–4Run the first Bolt
A real Unit of Work, taken from Mob Elaboration to production with our senior engineers in the room. Not a workshop exercise — shipped code, on your roadmap, with your product manager running the elaboration.
04
Weeks 5–8Hand over
Your team runs Bolts without us while we observe, coach, and audit. We leave behind the artifacts, the harness, and a written operating manual. The exit is the deliverable.
Programmes
Fixed price. Named outcome. Your team runs it after.
01
Agentic Bootcamp
from $6,000
1 week
A working team fluent in the vocabulary and the loop — engineers and product managers together, on your codebase.
- AI-DLC phases, Bolts, Units of Work
- Full Spec Kit command loop, hands-on
- One Unit of Work elaborated end to end
- Constitution drafted for your project
02
First Bolt
from $18,000
2–3 weeks
Bootcamp plus a real Unit of Work shipped to production under the new process, with our engineers alongside yours.
- Everything in Bootcamp
- Spec Kit installed on your repo
- Eval harness + review gates in CI
- One Unit of Work shipped, not simulated
03
Full AI-DLC Enablement
from $45,000
6–8 weeks
The complete install-and-hand-over programme across a multi-team engineering organisation.
- Assess → Install → First Bolt → Hand over
- MCP integration across your systems
- Multiple squads, multiple Bolts
- Written operating manual + audit trail
04
Embedded Coaching
from $4,500/mo
Monthly, cancel anytime
A senior engineer in your Bolts on an ongoing basis — reviewing specs, auditing evals, and keeping drift out.
- Bolt reviews and spec correction
- Eval drift monitoring
- Constitution upkeep as the codebase moves
- Escalation path for hard calls
Prices are per engagement, not per seat. Travel is billed at cost for on-site delivery outside the UAE. Both frameworks are open source — you are paying for the install and the coaching, never for a licence.
What Actually Changes
No multipliers, no dark factory. Here is the honest version.
Elaboration stops being a two-week lag
The measurable change teams report first is not raw coding speed — it is that the gap between an idea being described and a Unit of Work being ready to build collapses from a grooming cycle to a session.
Rework falls because ambiguity dies earlier
Most agent rework traces to a spec that never existed. Clarify-before-plan moves that cost to the cheapest possible point in the lifecycle.
AI output becomes reviewable
When an implementation is traceable to an approved spec and a constitution, review is a correctness check rather than an archaeology exercise.
The gains hold only if the fundamentals hold
Google's 2025 DORA research, across teams at roughly 90% AI adoption, is blunt: AI amplifies what a team already has. Without strong automated testing and fast feedback, it amplifies instability too. We install the control system first for exactly this reason.
FAQ
- What is AI-DLC?
- AI-DLC (AI-Driven Development Lifecycle) is an open-source, AI-native software methodology from AWS Labs. The AI drafts a detailed plan, asks clarifying questions, and defers every critical decision to a human before acting. Work flows through three phases — Inception (what and why), Construction (how), and Operations (deploy and run) — and each is elaborated by the whole team together rather than passed between silos. It is deliberately tool-agnostic: it runs on Claude Code, Cursor, Kiro, Amazon Q Developer, Cline, GitHub Copilot, or OpenAI Codex.
- What is a Bolt, and why replace the sprint?
- A Bolt is AI-DLC's smallest iteration, measured in hours or days rather than the two weeks of a sprint. The two-week sprint exists because elaboration, building, and review each needed their own calendar slot. When the AI drafts the plan in a live session and implements against an approved spec, that batching is no longer necessary — so the iteration shrinks to match the real cycle time. Epics become Units of Work over the same logic.
- What is Spec Kit, and how does it relate to AI-DLC?
- Spec Kit is GitHub's open-source toolkit for Spec-Driven Development. It provides concrete commands — /speckit.constitution, /speckit.specify, /speckit.clarify, /speckit.plan, /speckit.tasks, /speckit.analyze, /speckit.implement — that turn a specification into an executable artifact rather than a document nobody reads. AI-DLC gives you the methodology and the team rituals; Spec Kit gives you the mechanism inside the Construction phase. We teach them together because each covers the other's gap.
- What does a product manager actually do differently?
- Three things change. You write Intents instead of tickets — one paragraph of outcome, before decomposition. You attend Mob Elaboration and answer the AI's clarifying questions live alongside engineering, security, and ops, rather than fielding them asynchronously for a week. And you write acceptance criteria that are machine-verifiable, because those criteria become the verification gate the agent is checked against. Estimation in story points largely disappears; you specify the condition that proves it worked instead.
- How is this different from just giving the team Cursor or Copilot?
- Tools are the easy part and most teams already have them. What is missing is the operating model: who approves what, what a spec must contain before an agent touches it, how output is verified, and what happens when the agent is confidently wrong. Handing a team an agent without that produces fast, unreviewable output. AI-DLC and Spec Kit supply the process; the evals, review gates, and audit logs we install supply the enforcement.
- Do we have to use AWS, Kiro, or GitHub for this?
- No. AI-DLC's stated tenets include being agnostic to IDE, agent, and model, and Spec Kit supports 30-plus coding agents. We install both against whatever you already run — your cloud, your repository host, your model provider. Model independence is a design requirement in every Codenovai engagement, not a preference.
- Does this work on a legacy codebase, or only greenfield?
- Both, and brownfield is the more common engagement. Spec Kit's /speckit.converge command assesses an existing codebase against your artifacts and reports what is genuinely outstanding, which gives you a real starting position instead of a rewrite fantasy. On legacy work we usually spend more of the Assess phase on test coverage, because that is what determines whether agentic delivery is safe there yet.
- How long until the team is independent?
- For a single squad, teams typically run their own Bolts without us by week five or six, with the first two of those still supervised. Across a multi-team organisation, six to eight weeks covers install, first Bolts, and hand-over. Independence is the explicit deliverable — the written operating manual and the eval harness stay with you, and we will not build a dependency we would then have to sell you out of.
- We already run Scrum. Do we have to throw it out?
- No, and you should not start by trying. In practice teams keep the intent behind their ceremonies and change the mechanism: grooming becomes Mob Elaboration, planning collapses into the Bolt itself, and retro becomes a Bolt review whose output is a correction to the constitution or the spec. We migrate one squad first, measure it, and only then decide what to do with the rest.
- Who owns the artifacts and the setup afterwards?
- You do, from day one. The constitution, specs, steering files, eval harness, and every generated artifact live in your repository. Both AI-DLC and Spec Kit are open source — AI-DLC from AWS Labs, Spec Kit from GitHub under MIT — so there is nothing proprietary to Codenovai in the process you are left running. Our commercial interest is that you keep running it, not that you keep needing us.