AWS Kiro IDE 2026: The Complete Guide to Spec-Driven Development

Traditional AI coding workflow is "write prompt → generate code → pray it works." The problems: - AI may misunderstand requirements - Generated code may drift from design intent - No traceability or accountability **Kiro's spec-driven approach** divides development into three clear phases: 1. **Requirements Spec** — AI helps transform vague ideas into structured requirement documents 2. **Design Doc** — Generates detailed technical design based on requirements 3. **Task List** — Breaks design into executable specific tasks Each phase has human review checkpoints, ensuring AI stays on the right track. Use our [JSON to YAML tool](/en/tools/json-to-yaml) to structure your config files.

**1. Specs (Specification Files)** Specs are Kiro's core. Every feature development starts with creating a Spec: ```yaml # .kiro/specs/user-authentication.yaml name: User Authentication System status: approved created: 2026-07-25 requirements: - id: REQ-001 description: Users must be able to register with email and password priority: must_have acceptance_criteria: - Email validation with RFC 5322 compliance - Password minimum 8 characters, max 128 - Unique email constraint - id: REQ-002 description: Support OAuth2 with Google and GitHub priority: should_have acceptance_criteria: - Google OAuth2 flow complete - GitHub OAuth2 flow complete - Account linking for existing users design: architecture: "JWT-based stateless authentication" database: "PostgreSQL with users table" security: "bcrypt password hashing, rate limiting on auth endpoints" tasks: - id: TASK-001 title: "Create User model and database migration" spec_ref: REQ-001 estimated_effort: "2 hours" status: completed - id: TASK-002 title: "Implement registration endpoint" spec_ref: REQ-001 depends_on: TASK-001 estimated_effort: "3 hours" status: in_progress ``` **2. Hooks (Checkpoint System)** Hooks are checkpoints that automatically execute before and after code generation: ```typescript // .kiro/hooks/pre-generation.ts import { Hook, HookContext } from '@kiro/sdk'; export default new Hook({ name: 'validate-spec-compliance', trigger: 'before-code-generation', async execute(context: HookContext) { const spec = await context.getSpec(); const proposedCode = context.getProposedCode(); // Check if code addresses all requirements const uncoveredReqs = spec.requirements.filter( req => !context.codeAddresses(proposedCode, req) ); if (uncoveredReqs.length > 0) { return { action: 'block', reason: `Missing implementation for: ${uncoveredReqs.map(r => r.id).join(', ')}` }; } return { action: 'allow' }; } }); // .kiro/hooks/post-generation.ts export default new Hook({ name: 'auto-test-generation', trigger: 'after-code-generation', async execute(context: HookContext) { const spec = await context.getSpec(); const code = context.getGeneratedCode(); // Auto-generate tests based on acceptance criteria for (const req of spec.requirements) { for (const criteria of req.acceptance_criteria) { await context.generateTest({ requirement: req.id, criteria, code }); } } return { action: 'continue' }; } }); ``` **3. Steering Files (Behavior Constraints)** Steering Files define project coding standards and AI behavior constraints: ```markdown <!-- .kiro/steering/project-standards.md --> # Project Standards ## Code Style - Use TypeScript strict mode - Prefer functional patterns over classes - Maximum function length: 30 lines - All public APIs must have JSDoc comments ## Architecture - Follow hexagonal architecture - Business logic in /domain layer - External integrations in /infrastructure layer - No circular dependencies ## AWS Integration - Use AWS CDK for infrastructure - All services must have CloudWatch alarms - Use Step Functions for complex workflows - Prefer managed services over self-hosted ## Security - No secrets in code — use AWS Secrets Manager - All API endpoints require authentication - Input validation on all user-facing endpoints ``` Use our [HTML to Markdown tool](/en/tools/html-to-markdown) to write documentation.

| Feature | Kiro | Cursor | Claude Code | |---------|------|--------|-------------| | **Approach** | Spec-driven | Prompt-driven | Prompt-driven | | **Requirements Tracking** | Built-in Spec system | None | None | | **Auto Testing** | Hooks auto-generate | Manual | Manual | | **AWS Integration** | Native deep integration | Basic | Basic | | **Enterprise Compliance** | GovCloud support | None | None | | **Price** | Free + Bedrock usage | $20/mo | $20/mo | **Kiro's Unique Advantages**: 1. **Spec-Driven** — Traceable chain from requirements to code 2. **AWS Native** — Deep CDK, CloudFormation, Lambda integration 3. **Enterprise Compliance** — GovCloud and regulated industry support 4. **Hooks System** — Automated quality assurance mechanisms Use our [XML to JSON tool](/en/tools/xml-to-json) to handle config files.

```bash # 1. Install Kiro IDE (VS Code-based) # Download from https://kiro.dev # 2. Initialize project $ kiro init my-project $ cd my-project # 3. Create your first Spec $ kiro spec create "User Authentication" # Kiro guides you through: # 1. Requirements gathering (AI-assisted) # 2. Design document generation # 3. Task list breakdown # 4. Start coding $ kiro code --spec user-authentication # 5. Run Hooks checks $ kiro hooks run ``` ```typescript // Code generated by Kiro (based on Spec) // src/domain/auth/register-user.ts import { UserRepository } from '../../infrastructure/user-repository'; import { PasswordHasher } from '../../infrastructure/password-hasher'; import { EmailValidator } from '../../infrastructure/email-validator'; import { RegisterUserCommand } from './commands'; import { User } from './entities'; /** * Register a new user * Spec: REQ-001 * Acceptance: Email validation, password requirements, unique constraint */ export async function registerUser( command: RegisterUserCommand, deps: { userRepository: UserRepository; passwordHasher: PasswordHasher; emailValidator: EmailValidator; } ): Promise<User> { // Validate email (RFC 5322) if (!deps.emailValidator.isValid(command.email)) { throw new InvalidEmailError(command.email); } // Validate password (8-128 chars) if (command.password.length < 8 || command.password.length > 128) { throw new InvalidPasswordError('Password must be 8-128 characters'); } // Check uniqueness const existing = await deps.userRepository.findByEmail(command.email); if (existing) { throw new EmailAlreadyExistsError(command.email); } // Create user const hashedPassword = await deps.passwordHasher.hash(command.password); const user = User.create({ email: command.email, passwordHash: hashedPassword, }); await deps.userRepository.save(user); return user; } ``` Use our [Password Generator](/en/tools/password-generator) to test password policies.