Closed-Loop AI Delivery: Integrating Quick, Kiro, and Claude Code
A best-practices guide for integrating Amazon Quick, Kiro, and Claude Code as a closed-loop delivery system. Covers the synergy model, team onboarding checklists, integration patterns (Research→Spec→Build, Context Injection, ADR Pipeline, Quality Gates), steering file templates, role-based workflow matrices, MCP extensibility, reusable Skills/commands, scheduled automation, and anti-patterns. Enables teams to eliminate context loss between tools and enforce conventions at scale.
This post was developed jointly with Kayode Sanni-Olodo and Jain Thomas.
Executive Summary
Amazon Quick (desktop AI companion), Kiro (agentic IDE), and Claude Code (terminal-based agentic coding agent) are complementary tools that, when integrated effectively, create a closed-loop AI-augmented delivery system. Quick handles research, analysis, documentation, and cross-tool orchestration. Kiro handles structured code generation with persistent project context. Claude Code handles rapid prototyping, complex refactoring, and terminal-native development workflows. Together, they eliminate the "empty context" problem that plagues traditional AI-assisted development.
This document provides a reusable playbook for any team onboarding these tools to maximize delivery velocity.
The Synergy Model
| AMAZON QUICK | KIRO | CLAUDE CODE |
|---|---|---|
| (Research & Orchestrate) | (Build & Validate) | (Rapid Build & Refactor) |
| Deep analysis & research | Spec-driven implementation | Multi-file rapid prototyping |
| Cross-system context | Steering-enforced conventions | Complex refactoring at scale |
| Document generation | Hook-automated quality gates | Terminal-native workflows |
| Slack/Email synthesis | Persistent codebase context | Git operations & PR creation |
| Knowledge graph queries | Task-sequenced development | Shell command orchestration |
| Data pipeline analysis | Skills for reusable workflows | Test generation & debugging |
| Stakeholder comms | File-scoped AI guidance | Infrastructure scaffolding |
Golden Rule: Use Quick for thinking and connecting. Use Kiro for building and enforcing. Use Claude Code for rapid execution and refactoring.
Part 1: Team Onboarding — Setup Checklists
Amazon Quick Setup
| Step | Action | Why It Matters |
|---|---|---|
| 1 | Connect local project folder (Settings → My computer → Local folders) | Gives Quick read/write access to your codebase |
| 2 | Enable Search Indexing on the folder | Enables semantic search across all project files |
| 3 | Enable Knowledge Graph | Maps people, projects, decisions, and relationships |
| 4 | Connect messaging — Slack, Teams (Settings → Capabilities → Connections) | Synthesizes team discussions into actionable context |
| 5 | Connect email & calendar — Outlook, Gmail | Captures requirements, decisions, and schedules |
| 6 | Enable Memory (Settings → My context) | Quick learns your patterns and preferences |
| 7 | Add MCP Servers (Settings → Capabilities → MCP → "+ Add MCP") | Extends Quick with AWS CLI, documentation, and more |
| 8 | Add Kiro as Coding Agent (Settings → Capabilities → MCP → Coding Agents) | Enables @Kiro delegation directly from Quick |
| 9 | Add Claude Code as Coding Agent | Enables @claude-code delegation directly from Quick |
Kiro Setup
| Step | Action | Why It Matters |
|---|---|---|
| 1 | Create .kiro/steering/product.md (inclusion: always) | Every AI interaction knows your product context |
| 2 | Create .kiro/steering/tech.md (inclusion: always) | Enforces language, framework, and service standards |
| 3 | Create .kiro/steering/architecture.md (inclusion: always) | Prevents architectural drift across the team |
| 4 | Create module-specific steering (inclusion: fileMatch) | Context-appropriate guidance per subsystem |
| 5 | Configure Hooks for quality gates | Automated checks on every file save |
| 6 | Define initial Specs for active features | Structured requirements → design → tasks |
| 7 | Commit .kiro/ folder to git | Every team member inherits the same AI context |
Claude Code Setup
| Step | Action | Why It Matters |
|---|---|---|
| 1 | Install Claude Code CLI (claude command available in terminal) | Terminal-native agent accessible from any working directory |
| 2 | Create CLAUDE.md in project root | Persistent project context loaded every session |
| 3 | Create .claude/commands/ directory | Reusable prompt templates for common workflows |
| 4 | Configure allowed tools (Bash, Read, Write, Edit) | Controls what Claude Code can do autonomously |
| 5 | Set up MCP servers for extended capabilities | Connect to GitHub, JIRA, or custom APIs |
| 6 | Add CLAUDE.md to git | Shared project context for the whole team |
Walkthrough: Building a Serverless App with Amazon Quick
The following demonstrates the complete setup and build workflow — from configuring MCP servers to generating a full AWS application.
Step 1: Add the AWS MCP Server
Navigate to Settings → Capabilities → MCP:
The MCP tab in Settings → Capabilities shows connected MCP servers and coding agents.
Click "+ Add MCP" and configure the AWS MCP server:
- Connection type: Local
- Name:
aws-mcp - Command:
uvx - Arguments:
mcp-proxy-for-aws@latest https://aws-mcp.us-east-1.api.aws/mcp --metadata AWS_REGION=us-east-1
Note: Theuvxcommand comes fromuv(see Prerequisites). On first run, it will prompt you to authenticate via browser — sign in with your AWS Builder ID or IAM Identity Center credentials.
Configure the AWS MCP Server with the
uvx command and the managed endpoint URL.Click "+ Add MCP" to save. The server connects and shows its status:
AWS MCP shows "Connected" with 11 tools (5 write, 6 read) — including call_aws, run_script, and search_documentation.
Step 2: Add Coding Agents (Kiro + Claude Code)
In the CODING AGENTS section, click "+ Add Agent":
Amazon Quick supports Kiro and Claude Code as ACP (Agent Communication Protocol) coding agents.
Add both agents. Once enabled, they appear in your Coding Agents list:
Kiro and ClaudeCode showing "Enabled" — you can now delegate tasks with @Kiro or @claude-code in any chat.
Step 3: Connect Your Project Folder
Navigate to Settings → My computer and click "+ Add folder":
The "My computer" panel lets you add local folders for Quick to read, write, and search.
Select your project directory and enable "Agent access". Optionally enable Keyword search, Semantic search, and Knowledge graph extraction for deeper analysis capabilities.
Step 4: Issue the Build Prompt
With everything configured, open a new chat and enter your prompt:
A single, detailed prompt instructs Amazon Quick to build a complete serverless application.
The full prompt:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Build me a complete serverless "Quick Notes" app on AWS. It's a simple notepad
where users sign in, create notes, view their notes, and delete them.
Architecture: Cognito → API Gateway → Lambda → DynamoDB, with an S3 + CloudFront
frontend protected by WAF.
I need you to:
1. Create the full CDK (Python) project structure with all stacks (auth, database,
API, frontend, monitoring)
2. Write all the application code (Lambda handler, frontend HTML/JS/CSS)
3. Generate an architecture diagram
4. Validate everything against the AWS Well-Architected Framework using AWS
documentation — ensure it follows best practices for Security, Reliability,
Operational Excellence, Performance, Cost Optimization, and Sustainability
5. Produce a Well-Architected decision log showing which best practice IDs each
design choice satisfies
6. Save everything to ./amazon-quick-demo/What happens: Amazon Quick parallelizes the work — spawning multiple background tasks for CDK infrastructure, application code, architecture diagram, Well-Architected validation, and documentation. The AWS MCP server provides real-time access to AWS documentation for validating best practices.
Generated Project Structure
Amazon Quick produces the complete application in under 3 minutes:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
amazon-quick-demo/
├── README.md # Project documentation
├── app.py # CDK app entry point
├── cdk.json # CDK configuration
├── requirements.txt # Python dependencies
├── stacks/
│ ├── __init__.py
│ ├── auth_stack.py # Cognito User Pool + MFA
│ ├── database_stack.py # DynamoDB (on-demand, PITR, encryption)
│ ├── api_stack.py # API Gateway + Lambda + Cognito Authorizer
│ ├── frontend_stack.py # S3 + CloudFront + WAF + OAC
│ └── monitoring_stack.py # CloudWatch dashboards + alarms + SNS
├── lambda/
│ └── handler.py # CRUD handler (X-Ray, validation, logging)
├── frontend/
│ ├── index.html # Single-page application
│ ├── styles.css # Modern responsive CSS
│ ├── app.js # Auth + Notes + UI modules
│ └── config.js # Cognito/API configuration placeholders
└── docs/
├── architecture-diagram.html # Interactive architecture visualization
└── well-architected-decision-log.md # 6-pillar compliance documentation17 files | ~124KB total | 5 CDK stacks | 30+ Well-Architected decisions documented
Deploying the Generated App
Once Quick generates the project, deploy it with:
1
2
3
4
cd amazon-quick-demo
pip install -r requirements.txt # Install CDK Python dependencies
cdk bootstrap # One-time: provision CDK toolkit stack in your AWS account
cdk deploy --all # Deploy all stacks (Auth, Database, API, Frontend, Monitoring)After deployment, CDK outputs the CloudFront URL, API endpoint, and Cognito User Pool ID. Updatefrontend/config.jswith these values, then redeploy the frontend stack:cdk deploy QuickNotesFrontend.
Key Code Snippet: CDK Entry Point (app.py)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#!/usr/bin/env python3
import aws_cdk as cdk
from stacks.auth_stack import AuthStack
from stacks.database_stack import DatabaseStack
from stacks.api_stack import ApiStack
from stacks.frontend_stack import FrontendStack
from stacks.monitoring_stack import MonitoringStack
app = cdk.App()
auth = AuthStack(app, "QuickNotesAuth")
database = DatabaseStack(app, "QuickNotesDatabase")
api = ApiStack(app, "QuickNotesApi", user_pool=auth.user_pool,
user_pool_client=auth.user_pool_client, table=database.table)
frontend = FrontendStack(app, "QuickNotesFrontend", api_url=api.api_url)
monitoring = MonitoringStack(app, "QuickNotesMonitoring",
api=api.api, function=api.handler, table=database.table)
app.synth()Well-Architected Design Decisions
| Decision | WA Pillar | Best Practice | Rationale |
|---|---|---|---|
| ARM64/Graviton2 Lambda | Cost + Sustainability | COST-02, SUS-01 | 20% cheaper, better energy efficiency |
| DynamoDB On-Demand | Cost Optimization | COST-01 | Zero idle cost, automatic scaling |
| WAF managed rules | Security | SEC-04 | OWASP protection + rate limiting |
| Origin Access Control | Security | SEC-06 | S3 private, only CloudFront can access |
| X-Ray tracing | Ops Excellence | OPS-04 | Distributed tracing for debugging |
| Cognito with MFA | Security | SEC-01 | Enterprise auth without custom code |
| Point-in-time Recovery | Reliability | REL-09 | Continuous backups for DR |
| CloudWatch alarms + SNS | Ops Excellence | OPS-05 | Automated anomaly alerting |
Part 2: The Seven Integration Patterns
Pattern 1: Research → Spec → Build
| Phase | Tool | Action |
|---|---|---|
| Research | Quick | Deep analysis of requirements, existing patterns, edge cases |
| Document | Quick | Generate technical brief with findings and decisions |
| Build | Kiro or Claude Code | Implement with steering (Kiro) or rapid iteration (Claude Code) |
| Review | Quick | Analyze generated code against project standards |
Pattern 2: Cross-System Context Injection
Neither Kiro nor Claude Code can read your Slack or email. Quick bridges the gap:
- Quick gathers context from Slack threads, emails, documents
- Quick generates a structured requirements document
- Kiro/Claude Code implements using that document as context
Pattern 3: Architecture Decision Records
| Phase | Tool | Action |
|---|---|---|
| Research | Quick | Deep analysis of options and trade-offs |
| Draft | Quick | Generate ADR (Context, Decision, Consequences) |
| Codify | Kiro | Update steering files to reflect the decision |
| Implement | Claude Code | Apply the decision across the codebase |
Pattern 4: Delegation Syntax
To Kiro:
1
2
and content (max 10000 chars). Return 400 with descriptive error messages.To Claude Code:
1
2
@claude-code — Add unit tests for all Lambda handler routes (create, list, delete).
Use pytest with moto for DynamoDB mocking. Run tests and fix any failures.Pattern 5: Automated Documentation Loop
Quick reads code → generates API docs, data flow diagrams → stores in project folder → Kiro steering references these docs → hooks trigger regeneration on changes.
Pattern 6: Stakeholder Communication
Quick gathers from Slack + email + git → identifies completed items + blockers → generates formatted report → distributes via Outlook/Slack.
Pattern 7: Quality Gate Enforcement
| Component | Tool | Implementation |
|---|---|---|
| Pre-commit checks | Kiro | Hooks on file save (lint, type check, security) |
| Architecture compliance | Kiro | Steering files define patterns; hooks validate |
| Batch lint/fix | Claude Code | Run linter across repo, auto-fix, commit |
| Test coverage | Quick + Claude Code | Identify gaps (Quick) → Generate tests (Claude Code) |
Part 3: Steering & Context Templates
Kiro: .kiro/steering/product.md
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
inclusion: always
## Product Context
[PRODUCT_NAME] is a [TYPE_OF_SYSTEM] for [DOMAIN].
It processes [SCALE] of [DATA_TYPE] [FREQUENCY].
Core capabilities:
- [Capability 1]
- [Capability 2]
- [Capability 3]
Success metrics:
- [Metric 1]: [Target]
- [Metric 2]: [Target]Kiro: .kiro/steering/tech.md
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
inclusion: always
## Technology Stack
### Languages and runtimes
- [Language] [Version] for [Use case]
### Cloud services
- Compute: [Services]
- Storage: [Services]
### Code standards
- Formatter: [tool]
- Linter: [tool]
- Type checking: [required/optional]Claude Code: CLAUDE.md
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Project Context
## Overview
[PRODUCT_NAME] — [one-line description]
Stack: [Language] + [Framework] + [Cloud Provider]
## Commands
- Run tests: `[command]`
- Lint: `[command]`
- Deploy (dev): `[command]`
## Key Constraints
- [Never modify files in /generated/]
- [All new handlers must extend BaseHandler]
- [Use DynamoDB single-table design]Part 4: Anti-Patterns to Avoid
| ❌ Anti-Pattern | ✅ Fix |
|---|---|
| Using Quick for code generation | Quick for analysis/specs → delegate to Kiro/Claude Code |
| Using Kiro for cross-system research | Quick gathers context → inject via steering |
| Claude Code without CLAUDE.md | Create it — loaded automatically every session |
| Not committing .kiro/ to git | Commit it — every dev inherits conventions |
| One giant steering file | Use fileMatch for module-specific rules |
| Ignoring Quick's Memory | Enable it — Quick learns your patterns |
| Manual status reporting | Use Quick's scheduled tasks for auto-reports |
| Treating tools as independent | Establish Research → Build → Monitor loop |
Part 5: MCP — Extending Capabilities
MCP (Model Context Protocol) allows all three tools to connect to external services:
| Tool | MCP Configuration | Use Case |
|---|---|---|
| Quick | Settings → Capabilities → MCP | Query JIRA, create GitHub PRs, search AWS docs |
| Kiro | .kiro/mcp.json in project root | Access databases, query APIs during development |
| Claude Code | .claude/mcp.json or ~/.claude/mcp.json | Create PRs, manage issues from terminal |
Common MCP Servers
| Server | What It Adds | Install |
|---|---|---|
| AWS MCP (Managed) | All AWS APIs + docs + scripts | uvx mcp-proxy-for-aws@latest <endpoint> |
| GitHub | PR creation, issue management, repo search | npx @modelcontextprotocol/server-github |
| Atlassian (JIRA) | Ticket management, wiki search | npx @modelcontextprotocol/server-atlassian |
| Git | Local git operations | uvx mcp-server-git |
| PostgreSQL | Direct database queries | npx @modelcontextprotocol/server-postgres |
Tip: MCP servers run locally on your machine — credentials and data stay local.
Part 6: Skills — Reusable Workflow Automation
| Tool | Feature | How It Works |
|---|---|---|
| Quick | Skills | Saved multi-step workflows triggered by natural language |
| Kiro | Skills | Structured coding templates in .kiro/skills/ |
| Claude Code | Custom Commands | Prompt templates in .claude/commands/ (invoke with /project:<name>) |
Example Workflows
| Skill | Trigger | What It Does |
|---|---|---|
| Sprint Status (Quick) | "sprint status" | Gathers Slack + email + git → generates report |
| New Handler (Kiro) | Creating a Lambda | Scaffolds handler + config + tests following conventions |
| Fix Tests (Claude Code) | /project:fix-tests | Runs failing tests, analyzes, fixes, re-runs until green |
| PR Ready (Claude Code) | /project:pr-ready | Lint + test + commit + push + create PR |
Part 7: Workflow Optimization Matrix
| Task | Quick | Kiro | Claude Code | Best Combo |
|---|---|---|---|---|
| New feature (structured) | ✓ research | ✓ spec+build | Quick → Kiro | |
| New feature (prototype) | ✓ research | ✓ rapid build | Quick → Claude Code | |
| Bug investigation | ✓ analyze logs | ✓ trace code | Quick + Claude Code | |
| Large refactoring | ✓ plan | ✓ execute | Quick → Claude Code | |
| Documentation | ✓ generate | Quick | ||
| Infrastructure scaffolding | ✓ CDK/Terraform | Claude Code | ||
| Sprint planning | ✓ gather context | ✓ spec breakdown | Quick + Kiro | |
| Git operations | ✓ rebase/merge/PR | Claude Code |
Prerequisites
| Tool | Install Command | Purpose | Docs |
|---|---|---|---|
| Python 3.11+ | brew install python@3.11 | CDK + Lambda runtime | python.org |
| Node.js 18+ | brew install node | AWS CDK CLI dependency | nodejs.org |
| AWS CDK v2 | npm install -g aws-cdk | Infrastructure deployment | CDK Getting Started |
| uv | curl -LsSf https://astral.sh/uv/install.sh | sh | Python tool/MCP runner | astral.sh/uv |
| AWS CLI v2 | brew install awscli | AWS credentials & config | AWS CLI Install |
AWS Credentials: Ensure you have valid AWS credentials configured before deploying. Run
aws configure (for access keys) or aws sso login (for SSO). Your credentials need permissions for CloudFormation, Lambda, DynamoDB, S3, CloudFront, Cognito, WAF, CloudWatch, and IAM. For a full list, see the CDK bootstrapping docs .AI Tools:
- Amazon Quick: Desktop AI companion — Download & Install
- Kiro: Agentic IDE by AWS — Download | Installation Guide | Docs
- Claude Code: Terminal agent by Anthropic —
brew install --cask claude-code| Getting Started - Git:
brew install git| git-scm.com
Quick Reference Card
Daily Workflow
🌅 MORNING (Quick)
- Check feed → overnight synthesis
- Review pipeline health alerts
- Identify today's priorities from Slack/email
🔨 BUILD (Kiro — structured | Claude Code — rapid)
- Spec-driven implementation (Kiro)
- Rapid prototyping / refactoring (Claude Code)
- Tests + hooks validate + commit
🔄 CONTEXT SWITCH (Quick)
- Research unfamiliar pattern → generate brief
- Analyze data/logs/metrics
- Draft stakeholder communication
🌙 END OF DAY (Quick + Claude Code)
- Auto-generated PR summary (Quick)
- Final test run + cleanup (Claude Code)
- Update team via Slack (Quick)
This document is a living artifact. Update it as your team discovers new integration patterns.
Applicability: Any team using Amazon Quick Desktop + Kiro IDE + Claude Code
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article