AWS Builder Center
AI-DLC in Practice: Delivering a Feature Autonomously

AI-DLC in Practice: Delivering a Feature Autonomously

A candid retro on running a 6-unit AgentCore feature through an AI-DLC method with an autonomous orchestrator + worker loop.

AI-DLC in Practice: Delivering a Feature Autonomously

Most write-ups about AI-assisted development stop at the demo — a prompt goes in, a pull request comes out, everyone claps. What I wanted to know was messier: what does it actually look like to run a whole feature — a spike, several buildable slices, docs, an end-to-end test, an upstream PR — through a disciplined method, with an AI doing the construction and me acting as the arbiter? Where does it shine, and where does it grind?
So I did it, kept honest records, and this is the retro.
The method is an  AI-Driven Development Lifecycle (AI-DLC)  approach I've been working on. The feature was a new  Nx  generator that wires a generated  CopilotKit  React frontend to a managed  Amazon Bedrock AgentCore  runtime that speaks the  AG-UI protocol  natively. The construction engine was an autonomous orchestrator-plus-worker loop I've  written about before . The whole thing landed in about two and a half calendar days — but the interesting parts are the friction, not the headline.

A one-paragraph tour of AI-DLC

AI-DLC is a framing for making AI a central delivery collaborator rather than a fancy autocomplete. The recurring loop is AI proposes a plan → asks for missing context → humans validate the decisions → AI produces the artifacts → humans approve. It renames a few Agile concepts to make the shift explicit, and the renaming is load-bearing:
Traditional concept
AI-DLC concept
Product vision / problem statement
Intent
Discovery, analysis, solution design
Inception (via Mob Elaboration)
Epic
Unit of Work
Sprint
Bolt — a short, deployable execution cycle measured in hours, not weeks
Development & test execution
Construction (via Mob Construction)
The central distinction: this is not "ask AI to generate an app." It's a design-first, artifact-driven, approval-gated approach where the AI accelerates execution but humans stay the arbiters of business, architecture, risk, and quality. The durable artifacts — requirements, decisions, the plan, the code — live in the repo so later phases keep their context. If you want a reference implementation of the stages to poke at, there's one in  awslabs/aidlc-workflows .
My twist: I ran Construction almost entirely hands-off, so the human-in-the-loop moments stand out sharply against everything the loop did on its own.

The Intent

The business-level statement, before any solution design:
A developer who scaffolds a CopilotKit React app with the Nx plugin should be able to run one generator and have their frontend talking to a deployed, memory-backed AgentCore agent — with a sane auth story — instead of hand-wiring the transport.
The context that came with it: a managed AgentCore runtime that emits  AG-UI events natively over the wire  (no client-side translation layer), a CopilotKit frontend that already speaks AG-UI through a stock  HttpAgent , and two realistic auth modes to support — IAM for the simple case and Cognito JWT-forwarding for a real user-facing app. I covered the manual version of this wiring in  an earlier post ; the Intent here was to turn that hand-wiring into a generator.

Inception: turning Intent into Units of Work

This is the phase where a human still very much drives. In a local  Claude Code  session in plan mode, I did Mob Elaboration — me and the agent, in one sitting — turning the Intent into a roadmap: a tracked backlog of six Units of Work, each with acceptance criteria and explicit  blocked-by  edges, recorded as GitHub issues under one roadmap issue.
The backlog is the contract. Everything downstream reads from issues, labels, and dependency edges — not from the planning chat. That's what lets Construction be stateless and re-derivable, which matters enormously once the AI is running unattended.
The six Units, in dependency order:
Unit of Work
Responsibility
Spike
Validate server-side AG-UI translation against a deployed runtime before committing to the design
Generator MVP
The connection generator itself, IAM auth path
Frontend + Memory
Point the stock CopilotKit  HttpAgent  at the runtime's  /agui  endpoint; wire session memory
Cognito + docs
JWT-forwarding auth decision, docs, the auth-mode compatibility matrices
E2E validation
Fresh-workspace deploy → end-to-end test → teardown
Upstream PR
Raise the change against the upstream project
The first Unit is a classic AI-DLC walking skeleton — a thin end-to-end slice that proves the architecture and the delivery path before scaling out. Getting the spike right (or wrong) shaped everything after it, which the timeline below makes vivid.

Construction as autonomous Bolts

In AI-DLC, a Bolt is one short, deployable pass through Construction for one or more Units. In my setup, each Bolt is a dispatch to a worker agent: the orchestrator picks the next unblocked Unit, hands it to a fresh worker on a hosted  Claude Code runtime on AgentCore , pauses on near-zero compute via a  Step Functions monitor loop , then wakes to review and merge. The full mechanics are in  Autonomous Epic Delivery with Orchestrator + Worker Agents  — this article is what happened when I pointed that loop at a real, six-Unit feature.
Here's every issue that had the agent invoked, plotted over the ~2.5-day window. Each column is a Unit; time runs downward. Green is the agent actively working, amber is dispatched-but-idle (waiting on the monitor loop or a review), the blue cap is a merged/closed Unit, and red dots are agent errors.
Timeline of Agentic Actions

The shape tells the whole story. The walking-skeleton spike ate roughly a full day and about five dispatch attempts (that tall green-and-amber column with two red error dots). Once the delivery pattern was dialed in on that first Unit, the four middle Units each went in on a single clean pass — you can see them as short, tidy bursts. The last Unit — raise the PR upstream — stalled, but not for a reason the AI could fix.

What worked

Deploying every Bolt caught bugs unit tests never would. This is the single most valuable discipline, and it's very much in the AI-DLC spirit — a Bolt is supposed to be deployable, not just compilable. Running each slice against a live runtime surfaced concrete defects that only exist in the seam between code and cloud:
  • Unsanitized IAM role ARNs being rejected as a  runtimeSessionId  (the characters that are legal in an ARN aren't all legal in a session ID).
  • A  .slice(0, 100)  on the session key silently dropping the thread identifier for IAM callers — which collapsed every conversation into a single memory session. A snapshot test would have happily gone green on that.
  • A crash on a missing request context during local  dev , and a TypeScript compile failure from an import that was only unused under the IAM auth path.
None of these are visible without a deploy. If you take one thing from this: make "it deployed and a real request flowed through it" part of your definition of done for a Bolt, not an afterthought.
Steering-doc capture compounded across Bolts. A standing instruction to record every deploy-time gotcha in the repo's  CLAUDE.md  meant later Units inherited what earlier ones learned the hard way — which tools weren't preinstalled in the sandbox, a disk-quota quirk on the build mount, a stale lock left behind by a timed-out deploy. Each Bolt started a little smarter than the last. This is the artifact-driven part of AI-DLC doing real work: the durable record in the repo, not the chat, is what carried context forward.
Narrow scope + commit-immediately is what made the spike converge. The breakthrough on that stubborn first Unit was shrinking the ask. Instead of "satisfy all seven exit criteria," the dispatch became "do one concrete step, commit, push, stop." Progress became durable and survived interruptions. Every Unit after the spike used that shape and landed in one pass. A Bolt that fits in one short, committable step is a Bolt that finishes.

What didn't — and the lessons

Being honest about the friction is the whole point of a retro.
I had to step in more than I wanted. Across the run I intervened around eight times — a couple of early "you're the orchestrator, dispatch a worker; don't implement it yourself" corrections, a few "please continue" nudges, and some end-of-run cleanup. Two root causes stood out: the loop occasionally stranded itself waiting on a condition that had quietly already been met, and "done" was defined as "Units merged" rather than "the whole issue tree reconciled," so I had to explicitly authorize closing the tracking issues. Lesson: define the terminal state precisely, and make the wait-loop distinguish "not done yet, keep waiting" from "give up."
Long, deploy-heavy Bolts ran into credential and time ceilings. The most wall-clock was lost to a long run that crashed partway through with an expired security token — an AWS credential TTL running out mid-deploy and taking uncommitted work with it. Combined with a batch-then-push habit, one multi-hour run produced essentially nothing durable. Lesson: commit and push after every concrete step, never batch — and scope each Bolt to comfortably finish inside the credential lifetime. A Bolt measured in hours is fine; a Bolt that holds hours of uncommitted work hostage to a single token is not.
The last Unit hit a wall the AI couldn't argue its way past. Raising the PR against the upstream project failed because the automation's token simply had no write permission there — a scope wall, not a bug. Lesson: check that the identity has the access a Bolt needs before dispatching it, and surface the gap immediately instead of discovering it at the finish line. Some blockers are human decisions or human-held credentials; the loop's job is to flag them early and stop cleanly, which is exactly what AI-DLC's approval gates are for.
The remedy I'm carrying forward: build-all-then-deploy-once. The deploy-every-Bolt discipline is where the real bugs surfaced and where nearly every failure clustered — credential expiry, time ceilings, infra flakes all live in the deploy step. For a multi-Unit roadmap, the better sequencing is to land every Unit to green compile/build/unit/snapshot first (cheap, fast, credential-free), then do a single consolidated deploy-and-e2e pass at the end. You trade the per-Unit "this exact change deployed" signal for far less exposure to the fragile step. Keep the final smoke test small, and — importantly — first classify any end-of-phase failure as infra-versus-credential-versus-code before you go bisecting, because most of my failures weren't code regressions at all.

Takeaways

  • AI-DLC's vocabulary earns its keep. Naming the walking-skeleton spike a Unit with its own acceptance criteria, and treating each dispatch as a deployable Bolt, kept the work honest in a way a loose "let the agent build it" never would.
  • Make the backlog the contract. If every Construction pass can rebuild its state from issues, labels, and dependency edges, the loop can be stateless — which is what makes it cheap and crash-proof.
  • Deploy is where truth lives, and where pain lives. Both things are true. Deploy every meaningful slice at least once, but minimize the number of deploy cycles on a long roadmap, and keep the human as the arbiter of the irreversible, outward-facing step.
  • Scope Bolts to finish. The single most effective change across the whole run was making each unit of work small enough to commit before anything could expire, stall, or time out.

Related reading

If you want the machinery underneath this retro:
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article