AWS Builder Center

Builder Center

Building Enterprise-Ready Software with KIRO and Jira: The Spec-Driven Revolution

Learn how to integrate Kiro, AWS's agentic IDE, with Jira for spec-driven development. Transform requirements into structured specs that auto-generate Jira issues with bidirectional traceability. This guide covers Kiro's key features — specs, steering files, and hooks — showing how they create audit trails from requirements to deployment. Includes real-world examples, and best practices. Perfect for enterprise teams seeking compliance-ready workflows. Customize the approach using steering files.

Aidin Khosrowshahi

Introduction

AI coding assistants generate code fast, but the output is often undocumented, hard to maintain, and disconnected from requirements. Teams end up with vibe coding — working prototypes that lack the structure needed for production systems.
KIRO  changes this. Combined with Jira integration, Kiro enables spec-driven development that transforms chaotic AI-assisted coding into systematic, auditable, enterprise-ready applications.

What is Kiro?

Kiro is an agentic development environment from AWS that helps developers ship real engineering work with AI agents — bridging the gap between rapid prototypes and production-ready systems.
Kiro is great at "vibe coding" but goes way beyond that — its strength is getting prototypes into production systems. Unlike conventional AI assistants focused on autocomplete and chat, Kiro introduces spec-driven development. Describe what you want, and Kiro transforms it into:
  • Structured requirements with user stories and acceptance criteria
  • Technical designs with data flow diagrams, TypeScript interfaces, and schemas
  • Sequenced implementation tasks linked back to requirements
  • Coordinated multi-file code changes you can review and approve
Built on Code OSS, you keep your VS Code settings and Open VSX compatible plugins while gaining Kiro's powerful AI capabilities.

Kiro's Philosophy

Kiro sees agents as the most powerful tool yet developed for building software. Through spec-driven development, Kiro turns your prompt into structured requirements, design, and tasks that agents then implement.
Kiro is a true collaborator that doesn't just do work for you, but builds alongside you — helping you deliver robust engineering work while becoming a better engineer.

Kiro's Key Features for Enterprise Development

1. Specs: Your Single Source of Truth
Specs are the heart of Kiro's approach. When you describe a feature, Kiro unpacks your requirements into fully documented specifications:
  • Requirements: User stories and acceptance criteria
  • Design: Technical blueprints, TypeScript interfaces, database schemas, API endpoints
  • Tasks: Sequenced implementation steps with clear dependencies
Specs live in .kiro/specs/ alongside your code. Since they're regular markdown files in your repository, you can version-control them with Git to track changes and keep them in sync with your implementation.

2. Steering: Persistent Project Knowledge

Steering files in .kiro/steering/ give Kiro persistent knowledge about your project:
  • Coding standards and conventions
  • Project structure and architecture patterns
  • Technology stack preferences
  • Security requirements and compliance rules
  • Custom libraries and domain-specific languages
These are markdown files you can commit to Git, allowing your team to share project context and standards across all developers.

3. Agent Hooks: Intelligent Automation

Hooks automate repetitive tasks with intelligent triggers:
  • Generate documentation when files are saved
  • Run linting and tests on code changes
  • Update related specs when requirements change
  • Enforce coding standards across the team
Hooks are stored in .kiro/hooks/ as JSON files. Commit them to Git to share automation rules across your entire team.

4. Model Context Protocol (MCP): External Tool Integration

MCP servers connect Kiro to external tools:
  • Jira and Confluence: Read requirements, create issues, sync status
  • GitHub/GitLab: Access documentation, manage repositories
  • AWS Services: Deploy infrastructure, manage resources
  • Custom APIs: Integrate with enterprise systems
This extensibility makes Kiro a hub for your entire development workflow.

5. Autopilot and Supervised Modes

Kiro offers flexible autonomy levels:
  • Autopilot Mode: Kiro executes changes autonomously within your workspace
  • Supervised Mode: Review and approve every change before it's applied
Enterprise teams choose the control level matching their governance requirements.

Why Spec-Driven Development Matters for Enterprise

The Problem with "Vibe Coding"

Traditional AI assistants encourage "vibe coding" — rapid, chat-driven development producing working prototypes but lacking:
  • Documentation and specifications
  • Traceability to requirements
  • Consistent architecture patterns
  • Audit trails for compliance
This works for hackathons but fails in enterprise environments where maintainability, security, and compliance are non-negotiable.

The Spec-Driven Solution

Enterprise NeedSpec-Driven Solution
AuditabilitySpecs and plans stored in version control
TraceabilityBidirectional links between specs, code, and Jira
ConsistencySteering files enforce standards across the team
ComplianceReview gates before any code changes apply
MaintainabilityDocumentation generated alongside code
Knowledge TransferSpecs capture the "why" behind decisions

Using Jira as Input for Kiro Specs

Many enterprises already use Jira to define projects and requirements. Rather than duplicating effort, Kiro can directly import requirements from Jira to create comprehensive technical specifications.

Why Start with Jira Requirements?

If your company already captures requirements in Jira, you have a valuable foundation:
  • Product Managers define epics and user stories in Jira
  • Stakeholders add acceptance criteria and business context
  • Teams discuss and refine requirements through comments
Kiro's MCP integration lets you leverage this existing work rather than starting from scratch.

Importing from Jira: Best Practices

Using MCP Integration: If your requirements tool has an MCP server, you can connect directly to import requirements into your spec session. Kiro supports both local and remote MCP servers.
From a Jira Epic with linked stories:
1
2
"Read Jira epic FAL-15 and all linked stories, then create a comprehensive
technical spec in .kiro/specs/payment-system.md"
From multiple Jira issues:
1
2
"Read Jira issues FAL-20, FAL-21, and FAL-22, consolidate the requirements,
and create a unified spec with technical design"
Combining Jira with Confluence:
1
2
"Read Jira epic FAL-20 for requirements and Confluence page [URL] for
business context, then create a complete technical spec"

Writing Effective Specs from Jira Input

Kiro's specifications are designed for continuous refinement. When importing from Jira, Kiro enhances your requirements with:
  • EARS Format: Transforms user stories into structured requirements using Easy Approach to Requirements Syntax
  • Non-Functional Requirements: Adds performance, security, scalability, and maintainability specifications
  • Technical Design: Creates data flow diagrams, interfaces, and architecture decisions
  • Implementation Tasks: Sequences work items with dependencies
Example transformation:
Jira User Story:
1
As a customer, I want to view my transaction history so I can track my spending.
Kiro-Enhanced Spec:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
### 2.3 Transaction History

**User Story:** As a customer, I want to view my transaction history
so I can track my spending.

**EARS Acceptance Criteria:**
- WHEN the user navigates to transaction history,
THE system SHALL display transactions from the last 30 days
- WHERE transactions exceed 100 items,
THE system SHALL implement pagination with 20 items per page
- IF the user applies a date filter,
THE system SHALL update results within 200ms

**Non-Functional Requirements:**
- Performance: Page load < 2 seconds for 95th percentile
- Security: All queries SHALL be audit logged for SOC2
- Accessibility: WCAG 2.1 AA compliant

**Technical Details:**
- React component with virtual scrolling for performance
- API endpoint: GET /api/v1/transactions
- DynamoDB query with GSI on customerId + timestamp

Keeping Specs and Jira Synchronized

Kiro's specs stay synced with your evolving requirements. When Jira requirements change:
1
2
"Review Jira issue FAL-20 for updates and refresh the requirements
section in .kiro/specs/customer-dashboard.md"
This iterative approach ensures specifications remain synchronized with changing requirements, providing a reliable foundation for development.

Integrating Kiro with Jira: The Complete Workflow

The real power emerges when combining Kiro's spec-driven approach with Jira's project management. The principle:
Specs define WHAT and HOW. Jira tracks WHO, WHEN, and STATUS.

Architecture & Data Flow

Integration Flow Overview

Step-by-Step: From Requirements to Production

Step 1: Import Requirements into Kiro

Requirements can come from anywhere. Kiro's MCP integration with Atlassian makes it seamless:
From Confluence:
1
"Read Confluence page [URL] and create a technical spec in .kiro/specs/customer-dashboard.md"
From Jira Epic:
1
"Read Jira issue FAL-20 and create a detailed technical spec in .kiro/specs/"
From Discussion:
1
2
3
"Here's the discussion from our planning meeting:
[paste discussion]
Create a spec in .kiro/specs/ with technical implementation details"
Kiro generates a comprehensive spec with business requirements, technical architecture, API endpoints, and acceptance criteria.

Step 2: Generate Jira Issues from Specs

Once your spec is ready, Kiro creates structured Jira issues:
1
"Create Jira epic and tasks from .kiro/specs/customer-dashboard.md in project FAL"
Result:
  • FAL-25 (Epic): Customer Dashboard
  • FAL-26: Build React UI components
  • FAL-27: Create API endpoints
  • FAL-28: Set up DynamoDB tables
  • FAL-29: Deploy infrastructure to AWS
Each Jira issue contains a brief description (2-3 sentences), link to the spec section, and acceptance criteria.

Step 3: Bidirectional Linking

1
"Update the spec with the Jira issue keys"
Kiro adds Jira references back to the spec:
1
2
3
4
5
## 2.1 React UI Components
**Jira:** [FAL-26](https://yoursite.atlassian.net/browse/FAL-26)
**Status:** To Do

**User Story:** As a customer, I want to view my account summary...

Step 4: Sprint Planning

Your team uses Jira for what it does best:
  • Estimate story points
  • Prioritize the backlog
  • Assign to sprints and team members
The spec provides detail; Jira manages workflow.

Step 5: Development with Full Context

  1. Pick a Jira task from the sprint board
  2. Click the spec link to read detailed requirements
  3. Ask Kiro to implement the feature per spec
  4. Review the multi-file changes Kiro proposes
  5. Commit with Jira key: git commit -m "FAL-26: Implement dashboard UI"

Step 6: Continuous Synchronization

1
2
3
"Check if spec changes affect any Jira issues"
"Add comment to FAL-26 that implementation is blocked by API dependency"
"Update FAL-27 status to In Progress"

Real-World Enterprise Example

The Requirement

A product manager creates a Confluence page:
1
2
3
4
5
6
Customer Dashboard Feature
- View account summary with balance and status
- See recent transactions (last 30 days)
- Update profile information
- Download monthly statements as PDF
- Must comply with SOC2 audit requirements

Developer Creates Technical Spec

1
2
3
"Read Confluence page [URL] and create technical spec in
.kiro/specs/customer-dashboard.md with React architecture,
API endpoints, DynamoDB model, AWS deployment, and security controls"
Kiro generates:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
# Customer Dashboard Specification

**Project:** Customer Portal
**Version:** 1.0
**Status:** Draft

## 1. Overview
Enable customers to view account information, transaction history,
and manage their profile through a secure, responsive dashboard.

### Success Metrics
- Dashboard load time < 2 seconds
- 99.9% availability
- SOC2 compliance for all data access

## 2. Feature Requirements

### 2.1 Account Summary Component
**User Story:** As a customer, I want to see my account balance
and status at a glance.

**Acceptance Criteria:**
- [ ] Display current balance with currency formatting
- [ ] Show account status (Active, Suspended, Pending)
- [ ] Accessible via screen readers (WCAG 2.1 AA)

**Technical Details:**
- React component with real-time WebSocket updates
- Audit log all balance queries for SOC2

## 3. Technical Architecture
- Frontend: React with state management
- Backend: Python/Lambda with API Gateway
- Database: DynamoDB
- Security: IAM least privilege, encryption, audit logging

## 4. AWS Deployment
- CloudFormation/SAM templates
- CI/CD pipeline configuration

Generate Jira Issues

1
"Create Jira epic and tasks from this spec in project FAL"
Result:
  • FAL-100 (Epic): Customer Dashboard
  • FAL-101: Implement Account Summary React component
  • FAL-102: Build Transaction History with pagination
  • FAL-103: Create Profile Update form
  • FAL-104: Implement Statement Download service
  • FAL-105: Set up API Gateway and Lambda
  • FAL-106: Configure DynamoDB tables
  • FAL-107: Implement security controls and audit logging
  • FAL-108: Deploy infrastructure
  • FAL-109: Write integration tests
Each issue links to its spec section, providing full context without cluttering Jira.

Audit Trail

At any point, auditors can trace:
  • Requirement → Confluence page
  • Specification → .kiro/specs/customer-dashboard.md
  • Jira Issue → FAL-101
  • Code Changes → Git commits referencing FAL-101
  • Deployment → CloudFormation stack events
Complete traceability from business need to production.

Benefits for Enterprise Teams

  1. Reduced Onboarding — New members read specs to understand features, not reverse-engineer code
  2. Consistent Quality — Steering files enforce standards across all developers and AI-generated code
  3. Compliance Ready — Specs and audit trails satisfy SOC2, HIPAA requirements
  4. Faster Reviews — Reviewers reference specs, focus on implementation quality
  5. Knowledge Preservation — Specs capture institutional knowledge when team members leave
  6. Scalable AI Assistance — Steering and MCP integrations mean AI improves as project knowledge grows

Best Practices

DO ✅

  1. Start with source requirements — Import from Confluence/Jira, don't create from scratch
  2. Keep Jira brief — 2-3 sentences plus link to spec
  3. Always link bidirectionally — Spec ↔ Jira
  4. Use steering files — Encode team standards and conventions
  5. Configure hooks — Automate linting, testing, documentation
  6. Reference Jira keys in commits — Enable automatic tracking
  7. Review against specs in PRs — Verify acceptance criteria

DON'T ❌

  1. Don't skip specs — Even "simple" features benefit from documentation
  2. Don't copy entire specs to Jira — Creates clutter and maintenance burden
  3. Don't let spec and Jira diverge — Use Kiro to keep synchronized
  4. Don't treat specs as unchangeable — They evolve with understanding

Getting Started

Quick Start: 5 Steps

Step 1: Create a spec
1
"Create a spec for [feature] in .kiro/specs/"
Step 2: Generate Jira issues
1
"Create Jira epic and tasks from .kiro/specs/[file].md in project [KEY]"
Step 3: Update links
1
"Update the spec with the Jira issue keys"
Step 4: Sprint planning — Estimate, prioritize, assign in Jira
Step 5: Develop — Pick task → Read spec → Implement with Kiro → Commit with Jira key

Setup Checklist

  1. Install Kiro from kiro.dev 
  2. Configure Atlassian MCP for Jira/Confluence integration
  3. Create steering files with team standards
  4. Set up hooks for automated workflows
  5. Start your first spec

Conclusion

Kiro + Jira represents a new paradigm for enterprise development. By separating concerns — specs for requirements and design, Jira for workflow and tracking — teams achieve:
  • Clarity: Everyone understands what's being built and why
  • Traceability: Complete audit trail from requirement to deployment
  • Quality: Consistent standards enforced by steering and automation
  • Velocity: AI assistance that produces production-ready code
  • Compliance: Documentation and processes that satisfy auditors
Kiro transforms "vibe coding" into systematic, enterprise-grade software engineering. Combined with Jira, it's a workflow that scales from startups to Fortune 500.
The formula: Detailed Specs + Brief Jira + Bidirectional Links + Kiro Automation = Enterprise-Ready Development

Make It Your Own

This workflow is just a starting point — customize it for your team's specific needs. Every organization has different processes, tools, and requirements.
Pro tip: Document your Jira + Kiro integration workflow in a steering file (e.g., .kiro/steering/jira-workflow.md). This way, Kiro learns your team's specific patterns:
1
2
3
4
5
6
7
8
9
# .kiro/steering/jira-workflow.md

## Our Jira Integration Workflow

- Our Jira project key is: PROJ
- When creating specs, always read from Jira epic first
- Link all spec sections to Jira issues using format: **Jira:** [PROJ-XXX]
- Commit messages must include Jira key: "PROJ-123: description"
- Update Jira status when tasks are completed
With your workflow documented in steering files, Kiro automatically follows your team's conventions every time — no need to repeat instructions.
Ready to start? Visit kiro.dev  and experience spec-driven development.
For more about Kiro's features, visit kiro.dev .
# kiro# agentic-ide# jira# spec-drivien-development
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