AWS Kiro Golang: Spec-First IDE Setup dan Workflow Lengkap

 1Traditional AI coding workflow:
 2  Developer → Prompt → AI generates code → Developer reviews
 3
 4Kiro workflow:
 5  Developer → Describe need → Kiro asks clarifying questions
 6  → Kiro generates spec → Developer approves spec
 7  → Kiro generates plan → Developer approves plan
 8  → Kiro implements → Kiro verifies against spec
 9
10Perbedaan yang kelihatan kecil tapi impact-nya besar:
11  → Requirement ambiguity terdeteksi SEBELUM implementation
12  → Implementation tracked against spec secara explicit
13  → Spec jadi single source of truth
14  → Onboarding developer baru: baca spec, bukan baca kode

 1# Download Kiro dari kiro.aws
 2# Install sesuai platform:
 3# macOS: open Kiro.dmg, drag ke Applications
 4# Windows: run KiroSetup.exe
 5# Linux: AppImage atau .deb package
 6
 7# Login dengan AWS account
 8# Kiro button di sidebar → Sign in with AWS
 9
10# Verify Go support:
11# Kiro otomatis detect go.mod → setup Go toolchain
12# File Go akan punya AI hints tanpa perlu config tambahan
13
14# Setup Bedrock model (jika enterprise):
15# Kiro Settings → AI Model → Amazon Bedrock
16# Region: pilih yang paling dekat
17# Model: Claude 3.5 Sonnet atau Claude 3 Opus
18
19# Create project:
20# Kiro → New Project → Go → Next
21# Atau: open existing Go project folder

 1# .kiro/steering/project.md
 2# Kiro menggunakan semua file di .kiro/steering/ sebagai persistent context
 3
 4## Project Overview
 5Santekno Shop — Go 1.22 e-commerce, high-traffic, Clean Architecture.
 6Stack: Echo v4, pgx/v5, Redis, Kafka.
 7
 8## Architecture Standards
 9Clean Architecture layers:
10  delivery/http/handler → usecase → repository → domain
11
12Rules (STRICT):
13  - handler: import ONLY usecase interfaces
14  - usecase: import ONLY domain types + repository interfaces
15  - repository: import ONLY domain types + drivers
16  - domain: ZERO external imports
17
18## Error Handling
19Repository not-found: (nil, nil) — NOT error
20Error wrap: fmt.Errorf("package.Method: %w", err)
21HTTP errors: {"error": "UPPERCASE_SNAKE_CASE"}
22
23## Type Safety
24Monetary: int64 cents ONLY
25IDs: UUID (github.com/google/uuid)
26```

 1# .kiro/steering/testing.md
 2
 3## Testing Standards
 4Framework: github.com/stretchr/testify/suite
 5Mocking: go.uber.org/mock/gomock
 6
 7## Test Naming
 8Pattern: Test[Domain]_[Scenario]_[ExpectedResult]
 9Example: TestCancelOrder_WindowExpired_ReturnsError
10
11## Test Suite Structure
12type [Name]Suite struct {
13    suite.Suite
14    ctrl     *gomock.Controller
15    mock[Repo] *mock.Mock[Repo]
16    uc      *[Name]UseCase
17}
18
19func (s *[Name]Suite) SetupTest() {
20    s.ctrl = gomock.NewController(s.T())
21    // setup mocks
22}
23
24func (s *[Name]Suite) TearDownTest() {
25    s.ctrl.Finish()
26}
27```

 1Step 1: Describe the need
 2> "Customer perlu bisa cancel order yang masih PENDING dalam 30 menit"
 3
 4Kiro generate clarifying questions (mirip speckit.clarify):
 5  Q1: Apa yang terjadi dengan stock saat cancel?
 6  Q2: Siapa yang bisa cancel — customer saja atau admin juga?
 7  Q3: Bagaimana jika cancel window sudah expired?
 8  Q4: Apakah perlu Kafka event untuk cancel?
 9
10Step 2: Answer questions → Kiro generate .kiro/features/cancel-order/spec.md
11
12# CancelOrder Feature Specification
13## Acceptance Criteria
14AC1: Customer bisa cancel order dengan status PENDING
15AC2: Order harus dibuat maksimal 30 menit yang lalu
16AC3: Stock di-restore secara atomic dalam database transaction
17AC4: Event ORDER_CANCELLED dikirim ke Kafka (best-effort)
18AC5: Respons: 204 No Content untuk sukses
19AC6: Error codes: ORDER_NOT_FOUND, ORDER_NOT_CANCELLABLE, CANCEL_WINDOW_EXPIRED
20
21Step 3: Review and approve spec (bisa edit langsung di IDE)
22
23Step 4: Generate plan → .kiro/features/cancel-order/plan.md
24## Files to Create/Modify
251. internal/domain/order/entity.go — add CanBeCancelled() bool
262. internal/domain/order/errors.go — add error types
273. internal/usecase/order/cancel_order.go — new file
284. internal/repository/postgres/order_repository.go — add methods
295. internal/delivery/http/handler/order_handler.go — add handler
30
31## Implementation Order (dependency-first)
32Phase 1: Domain (entity + errors)
33Phase 2: Repository interface + PostgreSQL impl
34Phase 3: Usecase + tests
35Phase 4: Handler + router
36
37Step 5: Implement → Kiro implement semua files sesuai plan
38
39Step 6: Verify terhadap spec:
40  AC1: ✅ — handler ada, usecase check status
41  AC2: ✅ — CanBeCancelled() check 30-minute window
42  AC3: ✅ — CancelWithStockRestore dalam transaction
43  AC4: ⚠️ — Kafka publish ada, tapi error handling perlu review
44  AC5: ✅ — handler return 204
45  AC6: ✅ — semua error codes ada
46Score: 95/100

 1# .kiro/hooks/go-quality.yaml
 2
 3name: "Go Quality Automation"
 4description: "Otomasi quality checks setiap kali file Go di-save"
 5triggers:
 6  - type: file_saved
 7    pattern: "**/*.go"
 8    exclude:
 9      - "**/*_test.go"
10      - "**/mock_*.go"
11  - type: before_commit
12
13actions:
14  - name: "Build check"
15    run: "go build ./..."
16    on_failure:
17      message: "🔴 Build failed — fix before continuing"
18      stop: true
19
20  - name: "Vet check"
21    run: "go vet ./..."
22    on_failure:
23      message: "⚠️ Vet issues found"
24      stop: false
25
26  - name: "Test changed packages"
27    run: |
28      CHANGED_PKG=$(dirname $KIRO_CHANGED_FILE)
29      go test ./${CHANGED_PKG}/... -race
30    on_failure:
31      message: "🔴 Tests failing in changed package"
32      stop: true
33
34  - name: "Lint"
35    run: "golangci-lint run $KIRO_CHANGED_FILE"
36    on_failure:
37      message: "⚠️ Lint issues"
38      stop: false

 1# .kiro/hooks/spec-compliance.yaml
 2
 3name: "Spec Compliance Check"
 4triggers:
 5  - type: pull_request_ready
 6
 7actions:
 8  - name: "Run spec audit"
 9    run: "specify audit --all --fast"
10    on_failure:
11      message: "❌ Spec compliance issues detected"
12      create_issue: true
13      stop: false

 1# .kiro/hooks/mock-generation.yaml
 2
 3name: "Auto Mock Generation"
 4triggers:
 5  - type: file_saved
 6    pattern: "internal/domain/**/repository.go"
 7
 8actions:
 9  - name: "Regenerate mocks"
10    run: "go generate ./internal/domain/..."
11    on_success:
12      message: "✅ Mocks regenerated"

 1                    GitHub Spec Kit    AWS Kiro
 2─────────────────────────────────────────────────────
 3Interface           CLI                IDE-embedded
 4Installation        npm install        Desktop app download
 5Trigger mechanism   Manual command     Automatic + IDE integrated
 6Output location     .specify/          .kiro/
 7Spec format         Markdown (open)    Markdown (.kiro proprietary)
 8Portability         Any tool           Kiro-specific workflow
 9LLM                 Configurable       Claude (via Bedrock)
10Agent hooks         ❌                 ✅ Built-in
11Quality automation  Via CI only        Built-in + CI
12Open source         Yes                No (proprietary)
13AWS integration     ❌                 ✅ Native
14Pricing             Free (API cost)    Free beta; TBD post-beta
15Go-specific support via config         Good out-of-box
16
17When to use Spec Kit:
18  → Already using Claude Code (CLI workflow)
19  → Tool-agnostic requirement (not locked to one IDE)
20  → Want open source + full control
21
22When to use Kiro:
23  → Want spec-first INSIDE IDE (no CLI)
24  → AWS-heavy infrastructure
25  → Want built-in agent hooks for quality automation
26  → Team onboarding with built-in spec guidance

 1// Prompt: "Implement cancel order sebagai Lambda function"
 2package main
 3
 4import (
 5    "context"
 6    "encoding/json"
 7    "github.com/aws/aws-lambda-go/events"
 8    "github.com/aws/aws-lambda-go/lambda"
 9)
10
11type CancelOrderRequest struct {
12    OrderID string `json:"order_id"`
13    UserID  string `json:"user_id"`
14}
15
16func handler(ctx context.Context, req events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
17    var input CancelOrderRequest
18    if err := json.Unmarshal([]byte(req.Body), &input); err != nil {
19        return events.APIGatewayProxyResponse{
20            StatusCode: 400,
21            Body:       `{"error":"INVALID_REQUEST"}`,
22            Headers:    map[string]string{"Content-Type": "application/json"},
23        }, nil
24    }
25
26    // ... business logic via dependency injection
27
28    return events.APIGatewayProxyResponse{
29        StatusCode: 204,
30    }, nil
31}
32
33func main() {
34    lambda.Start(handler)
35}
36// Kiro tahu Lambda Go SDK pattern dengan benar
37// Tools lain sering generate generic HTTP handler

 1import (
 2    "github.com/aws/aws-sdk-go-v2/service/dynamodb"
 3    "github.com/aws/aws-sdk-go-v2/service/dynamodb/types"
 4    "github.com/aws/aws-sdk-go-v2/feature/dynamodb/attributevalue"
 5)
 6
 7type OrderDynamoRepository struct {
 8    client    *dynamodb.Client
 9    tableName string
10}
11
12func (r *OrderDynamoRepository) GetByID(ctx context.Context, id uuid.UUID) (*domain.Order, error) {
13    result, err := r.client.GetItem(ctx, &dynamodb.GetItemInput{
14        TableName: &r.tableName,
15        Key: map[string]types.AttributeValue{
16            "PK": &types.AttributeValueMemberS{Value: "ORDER#" + id.String()},
17        },
18    })
19    if err != nil {
20        return nil, fmt.Errorf("orderDynamoRepo.GetByID: %w", err)
21    }
22    if result.Item == nil {
23        return nil, nil  // not found
24    }
25
26    var order domain.Order
27    if err := attributevalue.UnmarshalMap(result.Item, &order); err != nil {
28        return nil, fmt.Errorf("orderDynamoRepo.GetByID unmarshal: %w", err)
29    }
30    return &order, nil
31}

 1{
 2  "family": "cancel-order-service",
 3  "networkMode": "awsvpc",
 4  "containerDefinitions": [
 5    {
 6      "name": "cancel-order",
 7      "image": "your-ecr.amazonaws.com/cancel-order:latest",
 8      "environment": [
 9        {"name": "GO_ENV", "value": "production"},
10        {"name": "DB_MAX_CONNECTIONS", "value": "10"}
11      ],
12      "secrets": [
13        {"name": "DATABASE_URL", "valueFrom": "arn:aws:secretsmanager:..."}
14      ],
15      "healthCheck": {
16        "command": ["CMD-SHELL", "curl -f http://localhost:8080/health || exit 1"]
17      }
18    }
19  ]
20}

 1✅ Yang Kiro lakukan dengan baik:
 2  - Basic CRUD features: sangat baik
 3  - Error handling patterns: automatically include standard error codes
 4  - AWS service patterns: native awareness
 5  - Acceptance criteria structure: well-formed
 6
 7⚠️ Yang perlu developer review:
 8  - Business rules yang complex: perlu manual verification
 9  - Cross-service dependencies: sering over/under-specify
10  - Performance requirements: kadang generic ("response time < 200ms")
11  - Edge cases: tidak selalu comprehensive
12
13❌ Yang Kiro sering salah atau miss:
14  - Domain-specific business rules (cancel window = 30 menit)
15  - Security requirements (authentication, authorization)
16  - Data consistency requirements di distributed system

 1Developer baru bergabung ke tim Santekno:
 2
 3Day 1 tanpa Kiro:
 4  "Baca codebase selama beberapa hari dulu"
 5  → Developer bingung, tidak tahu mana yang penting
 6  → Minta review ke senior untuk setiap langkah kecil
 7
 8Day 1 dengan Kiro + steering docs yang baik:
 9  Kiro baca semua steering docs:
10    - .kiro/steering/project.md (architecture)
11    - .kiro/steering/go-conventions.md (patterns)
12    - .kiro/steering/testing.md (test patterns)
13
14  Developer: "Implement CRUD untuk Product Review"
15
16  Kiro: "Berdasarkan architecture dari steering docs,
17   ini spec yang saya propose untuk Product Review CRUD:
18   [spec sesuai Clean Architecture convention tim]
19   Plan: [plan sesuai layer pattern yang tim pakai]"
20
21  Developer productive dari day 1,
22  karena Kiro pakai steering docs sebagai guardrail.

 1Status Kiro mid-2026: Beta (gratis)
 2
 3Known beta limitations:
 4  - Spec verification kadang false positive
 5  - Agent hooks masih experimental di beberapa edge cases
 6  - Large monorepo support masih beta
 7  - Beberapa AWS services belum di-cover (layanan baru)
 8
 9Post-beta expectations (best estimate):
10  Pricing: $15-30/dev/bulan (estimate)
11  Bedrock cost: terpisah (~$5-20/dev/bulan untuk moderate usage)
12  Total: ~$20-50/dev/bulan

1# .kiro/steering/go-version.md
2## Go Version Requirements
3This project uses Go 1.22 ONLY.
4Features available: generics (basic), for-range variables, maps.Must
5NOT available: range-over-func, slices.Collect, iter.Seq (Go 1.23+)
6```

1# .kiro/steering/architecture.md
2## Layer Rules for Spec Generation
3
4When generating spec for ANY feature:
51. Handler layer ONLY calls usecase (via interface)
62. Usecase layer ONLY calls repository (via interface)
73. Repository layer ONLY accesses database/cache
84. No direct DB access from handler or usecase
9```

1# .kiro/hooks/auto-mock.yaml
2triggers:
3  - type: file_saved
4    pattern: "internal/domain/**/repository.go"
5actions:
6  - run: "go generate ./internal/domain/..."

 1Option A: Spec Kit untuk spec generation, Kiro untuk IDE implementation
 2  1. specify feature → generate .specify/features/x/spec.md
 3  2. Copy/reference spec ke .kiro/features/x/spec.md
 4  3. Kiro: "Implement berdasarkan spec ini"
 5  4. Agent hooks Kiro untuk quality automation
 6
 7Option B: Kiro untuk spec, Spec Kit untuk audit
 8  1. Kiro → generate dan implement feature
 9  2. specify audit → verify compliance (audit Spec Kit lebih mature)
10  3. CI: specify audit di GitHub Actions
11
12Best of both worlds: Kiro's IDE-embedded workflow + Spec Kit's mature audit tools

 1Sprint 1: Kiro sebagai "IDE companion" untuk workflow yang sudah ada
 2  - Gunakan Kiro untuk inline coding (mirip Cursor)
 3  - Belum pakai spec feature Kiro
 4  - Setup steering docs dulu
 5
 6Sprint 2-3: Coba spec feature untuk fitur baru
 7  - Biarkan Kiro generate spec (tetap pakai Spec Kit untuk audit)
 8  - Compare: Kiro spec vs manual spec dari Spec Kit
 9
10Sprint 4+: Full Kiro workflow untuk satu project
11  - Kiro untuk spec + implementation
12  - Spec Kit hanya untuk audit (specify audit --all)
13  - Agent hooks untuk quality automation

 1# .kiro/features/cancel-order/test-plan.md
 2
 3## Test Plan: Cancel Order
 4
 5### Unit Tests (usecase layer)
 6- [ ] TC-01: Happy path — PENDING within 30 min → nil error
 7- [ ] TC-02: Order not found → ErrOrderNotFound
 8- [ ] TC-03: Order not owned by user → ErrOrderNotFound
 9- [ ] TC-04: Status not PENDING → OrderNotCancellableError
10- [ ] TC-05: Window expired (> 30 min) → ErrCancelWindowExpired
11- [ ] TC-06: Repository cancel fails → wrapped error
12- [ ] TC-07: Kafka publish fails → nil (best-effort, no error)
13- [ ] TC-08: Concurrent cancel → only first succeeds
14
15### Integration Tests
16- [ ] TC-09: Full flow via HTTP endpoint
17- [ ] TC-10: Database rollback on stock restore failure
18```

 1type CancelOrderSuite struct {
 2    suite.Suite
 3    ctrl          *gomock.Controller
 4    mockOrderRepo *mock.MockOrderRepository
 5    mockPublisher *mock.MockEventPublisher
 6    uc            *usecase.CancelOrderUseCase
 7}
 8
 9func (s *CancelOrderSuite) SetupTest() {
10    s.ctrl = gomock.NewController(s.T())
11    s.mockOrderRepo = mock.NewMockOrderRepository(s.ctrl)
12    s.mockPublisher = mock.NewMockEventPublisher(s.ctrl)
13    s.uc = usecase.NewCancelOrderUseCase(s.mockOrderRepo, s.mockPublisher)
14}
15
16func (s *CancelOrderSuite) TearDownTest() {
17    s.ctrl.Finish()
18}
19
20func (s *CancelOrderSuite) TestExecute_PendingWithinWindow_ReturnsNil() {
21    orderID := uuid.New()
22    userID := uuid.New()
23    order := &domain.Order{
24        ID:        orderID,
25        UserID:    userID,
26        Status:    domain.StatusPending,
27        CreatedAt: time.Now().Add(-10 * time.Minute),
28    }
29
30    s.mockOrderRepo.EXPECT().
31        GetByIDAndUserID(gomock.Any(), orderID, userID).
32        Return(order, nil)
33    s.mockOrderRepo.EXPECT().
34        CancelWithStockRestore(gomock.Any(), orderID).
35        Return(nil)
36    s.mockPublisher.EXPECT().
37        PublishOrderCancelled(gomock.Any(), orderID, userID)
38
39    err := s.uc.Execute(context.Background(), usecase.CancelOrderInput{
40        OrderID: orderID,
41        UserID:  userID,
42    })
43    s.NoError(err)
44}
45
46func (s *CancelOrderSuite) TestExecute_WindowExpired_ReturnsError() {
47    orderID := uuid.New()
48    userID := uuid.New()
49    order := &domain.Order{
50        ID:        orderID,
51        UserID:    userID,
52        Status:    domain.StatusPending,
53        CreatedAt: time.Now().Add(-31 * time.Minute), // expired
54    }
55
56    s.mockOrderRepo.EXPECT().
57        GetByIDAndUserID(gomock.Any(), orderID, userID).
58        Return(order, nil)
59
60    err := s.uc.Execute(context.Background(), usecase.CancelOrderInput{
61        OrderID: orderID,
62        UserID:  userID,
63    })
64    s.ErrorIs(err, domain.ErrCancelWindowExpired)
65}
66
67func TestCancelOrderSuite(t *testing.T) {
68    suite.Run(t, new(CancelOrderSuite))
69}

 1"Add DynamoDB table untuk orders"
 2→ Kiro generate CloudFormation template:
 3
 4Resources:
 5  OrdersTable:
 6    Type: AWS::DynamoDB::Table
 7    Properties:
 8      TableName: orders
 9      BillingMode: PAY_PER_REQUEST
10      AttributeDefinitions:
11        - AttributeName: pk
12          AttributeType: S
13        - AttributeName: sk
14          AttributeType: S
15      KeySchema:
16        - AttributeName: pk
17          KeyType: HASH
18        - AttributeName: sk
19          KeyType: RANGE
20      PointInTimeRecoverySpecification:
21        PointInTimeRecoveryEnabled: true
22
23Dan update Go code untuk match table structure:
24→ DynamoDB repository implementation
25→ Config struct dengan table name dari env var
26→ Test dengan local DynamoDB (DynamoDB Local)

 1PHASE 1 — Pilot (2 minggu):
 2  Volunteer: 2 developer yang paling open-minded
 3  Task: implement 1-2 features medium complexity pakai Kiro
 4  Deliverable: retrospective dengan pros/cons konkret
 5
 6PHASE 2 — Expanded Pilot (2 minggu):
 7  Expand ke seluruh tim
 8  New feature: gunakan Kiro; bug fixes: tetap tool lama
 9  Deliverable: team survey, metric baseline
10
11PHASE 3 — Full Adoption (jika pilot positive):
12  Kiro sebagai primary untuk new features
13  Steering documents jadi team standard (commit ke repo)
14  Agent hooks di-standardize
15
16PHASE 4 — Hybrid Post-Beta:
17  Evaluate pricing vs value
18  Jika pricing OK: continue full adoption
19  Jika pricing tinggi: Kiro untuk complex features, tool lain untuk everyday

 1Scenario 1: Kiro pricing $15-20/dev/bulan
 2  TCO dengan Bedrock: ~$20-30/dev/bulan total
 3  Comparable dengan Cursor ($20) atau Windsurf Pro ($15)
 4  Recommendation: Worth it JIKA di AWS ecosystem
 5
 6Scenario 2: Kiro pricing $30-40/dev/bulan
 7  TCO dengan Bedrock: ~$40-50/dev/bulan total
 8  Lebih mahal dari Cursor + Bedrock combo
 9  Recommendation: Evaluate berdasarkan unique value (spec-first, hooks)
10
11Scenario 3: Kiro pricing > $50/dev/bulan
12  Tidak competitive kecuali ada fitur enterprise yang sangat compelling
13  Recommendation: Stick dengan Claude Code + Spec Kit

 1AWS Kiro performance di benchmark kami:
 2
 3Overall: 88/100 (rank #2 setelah Claude Code)
 4
 5By scenario:
 6  S1 (Implement dari spec): 87/100 — spec auto-generation sangat membantu
 7  S2 (Write unit tests):    91/100 — salah satu terbaik, spec awareness kuat
 8  S3 (Refactoring):         86/100 — adequate, tidak se-powerful Cursor Composer
 9  S4 (Debug race condition):85/100 — adequate, tidak se-deep Claude Code
10  S5 (OpenAPI generation):  91/100 — generate sangat aligned dengan spec
11
12Kiro's unique strength: spec-first workflow mengurangi ambiguity
13yang sering menyebabkan deviation di tools lain.

 1Initial setup (Day 1):
 2□ Download dan install Kiro
 3□ Connect ke AWS account
 4□ Create .kiro/steering/project.md
 5□ Create .kiro/steering/go-conventions.md
 6□ Create .kiro/steering/testing.md
 7□ Setup basic agent hook (go build on save)
 8□ Test dengan simple feature
 9
10Week 1:
11□ Refine steering docs berdasarkan output yang di-generate
12□ Add more agent hooks (lint, test)
13□ Try spec generation untuk satu feature
14□ Compare spec quality dengan manual spec
15
16Week 2-4:
17□ Setup spec generation untuk setiap new feature
18□ Evaluate: apakah adoption meningkat vs Spec Kit?
19□ Decide: full Kiro atau hybrid dengan Spec Kit?