
From Cloud Infrastructure to AI-Driven Development: My First Hands-on with AI-DLC, Kiro, and Claude Code
Cloud infrastructure engineer's first hands-on with AI-DLC at AWS Summit Japan 2026 Hackathon. Three AIs, three roles: Claude (claude.ai) for concept sparring, Kiro for implementation, Claude Code (CLI) for diff review. Real catches: Pinpoint EoS, Cognito x NIST gaps, cross-document drift. Why role separation surfaces what single-agent self-review misses. A solo one-week sprint over Japan's Golden Week.
TL;DR
* I joined the AWS Summit Japan 2026 AI-DLC Hackathon as a solo applicant from a cloud infrastructure background
* I split work between three AIs: Claude (claude.ai) for early concept sparring, Kiro as the implementation agent running aidlc-workflows, and Claude Code (CLI) for stage-by-stage diff review
* Output quality jumped a clear notch — across cross-document consistency, technical risk catching (e.g., service end-of-support dates), and direction-level pushback
* Got the project ready for hackathon submission in a one-week sprint over Japan's Golden Week. The classic V-model design intuition I picked up early in my career mapped cleanly onto AI-DLC's stage gates
Why I'm writing this
I'm a cloud security operations engineer covering everything from AWS architecture design and operations to cost optimization and security — a different set of muscles than application development. My career started with about 15 years of enterprise system design and development on the systems integrator side, then shifted toward cloud infrastructure over the past several years.
So I was a bit out of my comfort zone when I applied to the AI-DLC Hackathon at AWS Summit Japan 2026 as a solo entrant. The theme is "services that ruin people's lives" (intentionally provocative — more on that below), and my submission is a Japanese sake lifecycle management app called SDLC: Sake Driven Life Cycle.
This post isn't really about the implementation. It's about how I divided work between three AI agents and what that taught me about AI-driven development. If you're choosing between AI coding agents on AWS, or curious about AI-DLC as a methodology, this should be relevant.
What is AI-DLC?
AI-DLC (AI-Driven Development Lifecycle) is an AI-native development methodology proposed by AWS. The high-level structure:
- Inception phase: Requirements analysis → User stories → Application design → Unit decomposition
- Construction phase: Functional design → NFR (Non-Functional Requirements) → NFR design → Infrastructure design → Code generation → Build and test
- Operations phase: Operations
A 12-stage flow where AI and humans iterate at each step. Each stage produces markdown files under
aidlc-docs/ , and the human approves each one before moving on.
Each stage's output becomes the next stage's input. The Construction phase repeats those 6 stages N times — once per Unit.
The actual workflow is published as awslabs/aidlc-workflows by AWS Labs, and you invoke it from AI coding agents like Kiro or Claude Code.
A quick introduction to the tools:
- Kiro is AWS's agentic IDE (built on a VS Code fork) plus CLI, centered around Spec-Driven Development. It generates requirements, designs, and implementation tasks from natural-language prompts in a structured way that fits well with AI-DLC.
- Claude Code is Anthropic's terminal-based (CLI) AI coding agent that can read local repository files and git diffs directly, then review or implement interactively.
This article is about combining both, with Claude (claude.ai) also playing a role for early-stage concept sparring.
The plan: three AIs, three roles
The first decision I made was to assign different AIs to different roles.
AI | Phase | Role |
|---|---|---|
Claude (claude.ai) | Pre-launch (concept discussion) | Sparring partner for theme interpretation and ethical risk; reviewed initial pitch deck |
Kiro | Throughout development | Executes aidlc-workflows, generates docs and code (implementation agent) |
Claude Code (CLI) | Stage-by-stage review | Reads local repository diffs (git diff), checks cross-document consistency, validates design decisions, flags blind spots |
The reasoning is simple: if you let one AI both produce and self-review, it can't escape its own bias. If Kiro generates a requirements doc and you ask the same Kiro to review it, structural blind spots stay invisible. Take it to a different AI, and you immediately get things like "this number contradicts the value in another doc."
It's the same as human team development. Code review works because someone other than the author looks at it. The same logic applies to AI-driven development — separate the role, get cross-checks. As it turns out, "concept discussion before any files exist" naturally goes to Claude (claude.ai), while "diff review after files exist" goes to Claude Code (CLI). Same Claude family, different interfaces, different jobs.
Here's how data actually flowed during the Construction phase (after concept discussion was done):
The key was to give Claude Code visibility at the granularity of "what Kiro just finished" — a stage's worth of output, not line-by-line. Concretely, I'd run
claude in the terminal and ask it to "review the recent changes." Claude Code reads the diff and related files directly, with no copy-paste needed. Stage-level diffs are the right size: small enough to review thoroughly, large enough to catch structural problems.
Kiro: implementation flow
Inception phase: Pinning down requirements through dialogue
I started by handing the SDLC pitch deck PDF to Kiro:
I want to build a web app based on this concept. (PDF attached)Kiro followed aidlc-workflows and immediately generated 11 clarifying questions: "Which frontend framework?" "What's your auth approach (Amazon Cognito? Custom?)" "How far should PWA (Progressive Web App) support go?" After I answered, it followed up with 7 more questions on points still ambiguous. Once those were done, it produced
requirements.md .What struck me was how aggressively Kiro pursues ambiguity. When I gave a vague answer like "support both," it would push back: "Both meaning text input and image input? Or some other interpretation?" As an infrastructure-focused engineer who's not great at nailing down app requirements, that persistence was genuinely useful.
The whole Inception phase — Workspace Detection through Units Generation — took about a day of dialogue with Kiro.
Construction phase: Implementing per Unit
After the Inception phase divided the work into 6 Units, the Construction phase loops through "functional design → NFR requirements → NFR design → infrastructure design → code generation" per Unit.
I focused mainly on Unit 1 (Foundation): authentication on Amazon Cognito, shared infrastructure, Amazon DynamoDB schemas. Kiro generated everything end-to-end here — Terraform modules, AWS Lambda handlers, React components, and test code (Vitest + fast-check).
What's worth highlighting is that Property-Based Testing with fast-check comes built in. Tests like "password length requirements should be NIST-compliant (referring to NIST SP 800-63B, the password guidelines from the U.S. National Institute of Standards and Technology)" are auto-generated as invariants verified with random inputs. That kind of test would take serious effort to write manually.
Claude Code: the review flow
This is the part of the article I really wanted to write.
I never just took Kiro's output as-is. At every stage, I'd bring it to Claude Code (CLI) for review. Concretely, I'd start
claude in the terminal and ask "review the latest changes." Claude Code reads the local repo's diffs and related files directly, then comes back with cross-cutting feedback.Review 1: Cross-document consistency
AI-DLC artifacts span 14+ files:
requirements.md , stories.md , personas.md , unit-of-work.md , components.md , audit.md , and more. Kiro generates each stage solidly, but doesn't always propagate changes across all files.For example, partway through development I added MFA (multi-factor authentication). Kiro added the MFA fields to
business-rules.md and domain-entities.md . But when I asked Claude Code to review, this came back:The MFA addition (US-02B) is missing from these Inception artifacts:*unit-of-work.md: Unit 1's related stories don't include US-02B*components.md: FE-01's responsibilities don't include MFA*requirements.md: FR-07 has no MFA / NIST notes*unit-of-work-story-map.md: No US-02B row, story count still shows 27
This isn't Kiro's fault — it's structural. Each generation task focuses on the current stage, and propagating changes to past artifacts naturally falls behind. Claude Code, anchored on the git diff, can fan out and check the whole repository for consistency. That division of labor mapped cleanly to what each tool does well.
Review 2: Technical risks and constraints
This one stuck with me. Kiro's generated requirements doc said "Use Amazon Pinpoint for push notifications." I almost accepted it, but Claude Code's review came back:
Amazon Pinpoint reaches end of support on October 30, 2026. If this service launches in Q3 2026, you'll be running on a deprecated service from day one. I'd recommend Web Push (VAPID) + Service Worker instead.
This came out because Claude Code was aware of AWS's deprecation announcement. Kiro picks reasonably from currently available AWS services, but doesn't model future EoS (End of Support) risk during generation. It's the kind of thing an infrastructure-focused human picks up on instinctively, but easy to miss if you fully delegate to AI.
Acting on that one piece of feedback led to swapping Pinpoint → Web Push across 8 files. Catching it early was worth a lot.
Some other Claude Code findings:
- Cognito × NIST SP 800-63B gap: NIST-compliant blocklist matching can't be done natively in Amazon Cognito. A Pre-Sign-up Lambda Trigger needs to be added.
- Contradiction in Unit parallelism: Unit 2 → Unit 3 had a dependency, but the docs claimed they could be developed in parallel. Restructured into a 3-phase plan (Phase 0/1/2) where shared interfaces are locked down in Unit 1 first.
- Lambda function count mismatch:
requirements.mdsaid 22,components.md's tally came to 27.
Review 3: Product direction sparring
This one I asked Claude (claude.ai) rather than Claude Code. It was before Kiro had even started — there were no files in the repo yet, so the question was "is this concept actually any good?"
The hackathon theme is "services that ruin people's lives," and my initial SDLC concept included an "anti-abstinence" feature — basically AI nudging the user away from choosing not to drink. I shared the first draft of the pitch deck with Claude and got back:
This reads as if you're selling AI that "corrects" the choice not to drink, in front of users who might be in recovery, pregnant, or on medication. At an official AWS event, having presenters and judges publicly endorse "AI that overrides the choice not to drink" is essentially impossible from a PR standpoint.
That kicked off a longer discussion that ended with the decision to promote "Skip Deploy" to a first-class feature — designing "days I don't drink" on the same UI surface as "days I do." That's now the core idea behind the product.
Stepping back: "concept discussion before files exist" → Claude (claude.ai); "diff review after files exist" → Claude Code (CLI). Same family, different interfaces, naturally different jobs. Kiro is great at "executing a defined plan," but "negotiating tradeoffs between hackathon theme interpretation and social risk" lives more naturally in a chat-style interface.
Effects and limitations of the role split
Effects
After three review cycles, I ended up with these corrections:
- Cycle 1: Progress tracking and propagation fixes (MFA fan-out, numeric consistency)
- Cycle 2: Technical risk fixes (Pinpoint EoS, Cognito × NIST alignment, cost strategy)
- Cycle 3: Design and terminology cleanup (Unit parallelism dependency contradictions, traceability)
All of this is recorded chronologically in
audit.md , which doubles as evidence I can point to in the hackathon's "documentation quality" judging criterion.Limitations
The approach has costs.
First, review round-trip overhead. I take Kiro's output, run it through Claude Code, get feedback, send it back to Kiro to fix. About 30 minutes to an hour per stage of additional cost.
Second, sometimes the AIs disagree and the human has to mediate. Kiro's design decisions and Claude Code's review opinions clash occasionally, and the final call goes to the human. This is a feature, not a bug — but means you can't fully delegate.
Third, context length still matters.
audit.md alone is over 50KB, and even with Claude Code able to read files directly, you still need to think about what to include in any given review request.
Reflections from a cloud infrastructure engineer
Three takeaways from someone who normally lives on the infrastructure side.
1. AI-DLC actually delivers on "infrastructure engineers can build apps too"
Honestly, I don't normally write React or TypeScript. But this time, I generated a React app — auth, PWA, state management included — in the first cycle of the Construction phase. Kiro's generation strength matters, but more important was that AI-DLC's stage decomposition lets you make progress in unfamiliar areas one step at a time. Instead of "generate everything at once," it's "functional design → NFR requirements → NFR design → infra design → code generation," which makes each step easy to evaluate.
A personal note here: my early-career experience gave me natural intuition for the V-model (requirements → basic design → detailed design → implementation → testing). AI-DLC maps cleanly onto that. AI generates each stage's output, so it feels like running a classic design process at compressed speed. The intuition for what to decide at each phase — what can be deferred — translated directly to AI-DLC's decision points, which is how I made it through implementation that I'm normally bad at. For anyone with even a bit of design experience, AI-DLC has a low learning curve.
2. Kiro is the "talented junior engineer," Claude family is the "experienced senior"
Imperfect analogy, but it's how it felt. Kiro implements quickly and accurately given clear instructions, but "sensing latent risk from past experience" falls to humans (and AIs that act like one). Concept discussion → Claude (claude.ai). Diff review → Claude Code (CLI). Splitting the surface area of "Claude family" tools by job dramatically reduced my review blind spots.
3. Documentation-driven development, evolved
I've spent years watching design docs drift away from reality on infrastructure ops projects. In AI-DLC, the design doc is the source of AI's generation, so the doc is canonical. The classic problem of code racing ahead while design docs go stale just doesn't happen by construction. As an infrastructure engineer, that's a deeply satisfying experience.
Why this matters for AWS builders
Beyond my personal experience, here are takeaways that I think generalize for the AWS builder community:
- AI-DLC is reproducible. The methodology is fully open-sourced as
awslabs/aidlc-workflows. You can try it yourself with Kiro or Claude Code.
- Multi-agent role separation is a viable pattern, not a gimmick. It surfaced real bugs in my project (Pinpoint EoS, NIST gaps, Lambda count drifts) that single-agent review missed.
- AI-driven development doesn't make experience obsolete. The classic V-model intuition, the AWS service knowledge, the "this might EoS soon" instinct — all of it actively helped. AI accelerates experienced engineers more than it replaces them.
- The Spec-Driven approach (Kiro's design philosophy) and the diff-based review approach (Claude Code's strength) compose well. They're not competitive AI agents; they're complementary tools for different parts of the pipeline.
If you're an AWS builder thinking about adopting AI-driven development for production projects, I'd suggest starting with a similar role-split: one agent generates, another reviews. The cost of a second AI in the loop is much smaller than the cost of a missed structural issue six months in.
TL;DR (revisited)
Three-line summary:
- Claude (claude.ai) for concept sparring before launch, Kiro for execution during development, Claude Code for stage reviews — this three-role split bumped output quality up a notch in my experience
- The biggest wins are in cross-document consistency, forward-looking technical risk, and direction-level sparring. The further left you go (toward concept), the better claude.ai's chat interface fits
- Round-trip cost is real. You need judgment about "this needs Claude Code review," "this is fine to leave to Kiro alone"
Hackathon results are still pending, but the development style itself is something I want to keep using. Not over-relying on a single AI, treating multiple AIs as "colleagues" with different roles — that felt like a real shift, and I felt it strongly during the one-week development sprint over Japan's Golden Week holiday.
Resources
- Submission repository: otaka329/sake-dlc
- AI-DLC Workflows (AWS Labs): awslabs/aidlc-workflows
- Kiro (AWS): kiro.dev
- Claude Code (Anthropic): Claude Code documentation
- Hackathon overview: AWS Summit Japan 2026 AI-DLC Hackathon
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article