Amazon CodeWhisperer Q Developer Kiro: The Rise of Agentic Coding

// SPEC.md concept implemented as TypeScript types
// Kiro reads your spec and generates this scaffolding

import { Logger } from '@aws-lambda-powertools/logger';
import { Tracer } from '@aws-lambda-powertools/tracer';
import { DynamoDBClient, PutItemCommand, GetItemCommand } from '@aws-sdk/client-dynamodb';
import { SQSClient, SendMessageCommand } from '@aws-sdk/client-sqs';
import { marshall, unmarshall } from '@aws-sdk/util-dynamodb';

const logger = new Logger({ serviceName: 'order-service', logLevel: 'INFO' });
const tracer = new Tracer({ serviceName: 'order-service' });
const ddb = tracer.captureAWSv3Client(new DynamoDBClient({}));
const sqs = tracer.captureAWSv3Client(new SQSClient({}));

interface Order {
  orderId: string;
  customerId: string;
  items: Array<{ sku: string; qty: number; price: number }>;
  status: 'PENDING' | 'CONFIRMED' | 'SHIPPED' | 'CANCELLED';
  createdAt: string;
}

interface CreateOrderResult {
  success: boolean;
  orderId?: string;
  error?: string;
}

// Kiro-generated handler with full error handling + structured logging
export const createOrder = async (
  order: Omit<Order, 'orderId' | 'status' | 'createdAt'>
): Promise<CreateOrderResult> => {
  const segment = tracer.getSegment();
  const subsegment = segment?.addNewSubsegment('createOrder');

  try {
    const orderId = `ORD-${Date.now()}-${Math.random().toString(36).slice(2, 7).toUpperCase()}`;
    const newOrder: Order = {
      ...order,
      orderId,
      status: 'PENDING',
      createdAt: new Date().toISOString(),
    };

    logger.info('Creating order', { orderId, customerId: order.customerId, itemCount: order.items.length });

    // Persist to DynamoDB
    await ddb.send(new PutItemCommand({
      TableName: process.env.ORDERS_TABLE!,
      Item: marshall(newOrder),
      ConditionExpression: 'attribute_not_exists(orderId)', // idempotency guard
    }));

    // Publish to downstream processing queue
    await sqs.send(new SendMessageCommand({
      QueueUrl: process.env.ORDER_QUEUE_URL!,
      MessageBody: JSON.stringify(newOrder),
      MessageGroupId: order.customerId, // FIFO ordering per customer
      MessageDeduplicationId: orderId,
    }));

    logger.info('Order created and queued', { orderId });
    return { success: true, orderId };

  } catch (error) {
    const err = error as Error;
    logger.error('Failed to create order', { error: err.message, stack: err.stack });
    subsegment?.addError(err);
    return { success: false, error: err.message };
  } finally {
    subsegment?.close();
  }
};

# .kiro/hooks/auto-test.yaml
name: Generate Unit Tests on Save
trigger:
  event: file_saved
  pattern: "src/**/*.ts"
  exclude: "**/*.test.ts"
actions:
  - type: agent_task
    prompt: |
      A TypeScript file was just saved at {{file_path}}.
      Review the exported functions. For any function that does not have a 
      corresponding test in {{file_path_without_ext}}.test.ts, generate 
      comprehensive unit tests using Vitest. Include:
      - Happy path tests
      - Error boundary tests (network failures, malformed input)
      - Edge cases for empty arrays and null values
      Use @aws-sdk/client-dynamodb mocks from @aws-sdk/lib-dynamodb MockDocumentClient.
    output_file: "{{file_path_without_ext}}.test.ts"
    mode: merge # Don't overwrite existing tests, only append missing ones

// Auto-generated test from the hook above (Vitest)
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { mockClient } from 'aws-sdk-client-mock';
import { DynamoDBClient, PutItemCommand } from '@aws-sdk/client-dynamodb';
import { SQSClient, SendMessageCommand } from '@aws-sdk/client-sqs';
import { createOrder } from './order-service';

const ddbMock = mockClient(DynamoDBClient);
const sqsMock = mockClient(SQSClient);

describe('createOrder', () => {
  beforeEach(() => {
    ddbMock.reset();
    sqsMock.reset();
    process.env.ORDERS_TABLE = 'test-orders';
    process.env.ORDER_QUEUE_URL = 'https://sqs.us-east-1.amazonaws.com/123/orders.fifo';
  });

  it('should create order and return orderId on success', async () => {
    ddbMock.on(PutItemCommand).resolves({});
    sqsMock.on(SendMessageCommand).resolves({ MessageId: 'msg-123' });

    const result = await createOrder({
      customerId: 'cust-001',
      items: [{ sku: 'SKU-A', qty: 2, price: 29.99 }],
    });

    expect(result.success).toBe(true);
    expect(result.orderId).toMatch(/^ORD-/);
  });

  it('should return error when DynamoDB PutItem fails', async () => {
    ddbMock.on(PutItemCommand).rejects(new Error('ProvisionedThroughputExceededException'));

    const result = await createOrder({
      customerId: 'cust-001',
      items: [{ sku: 'SKU-A', qty: 1, price: 9.99 }],
    });

    expect(result.success).toBe(false);
    expect(result.error).toContain('ProvisionedThroughputExceededException');
  });

  it('should handle empty items array gracefully', async () => {
    ddbMock.on(PutItemCommand).resolves({});
    sqsMock.on(SendMessageCommand).resolves({});

    const result = await createOrder({ customerId: 'cust-001', items: [] });
    expect(result.success).toBe(true);
  });
});

// Q Developer workflow (deprecated):
// You'd type: /dev add retry logic with exponential backoff to this fetch call
// And it would modify the highlighted code block.

// Kiro equivalent: Add to your SPEC.md or use agent chat with file pinning:
// "Add retry logic with exponential backoff to src/clients/http-client.ts"

// The result Kiro produces — production-grade with observability:
import { Logger } from '@aws-lambda-powertools/logger';

const logger = new Logger({ serviceName: 'http-client' });

interface RetryOptions {
  maxAttempts: number;
  baseDelayMs: number;
  maxDelayMs: number;
  retryableStatusCodes: number[];
}

const DEFAULT_RETRY_OPTIONS: RetryOptions = {
  maxAttempts: 3,
  baseDelayMs: 100,
  maxDelayMs: 5000,
  retryableStatusCodes: [429, 500, 502, 503, 504],
};

export async function fetchWithRetry<T>(
  url: string,
  options: RequestInit = {},
  retryOpts: Partial<RetryOptions> = {}
): Promise<T> {
  const opts = { ...DEFAULT_RETRY_OPTIONS, ...retryOpts };
  let lastError: Error | null = null;

  for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {
    try {
      const response = await fetch(url, options);

      if (!response.ok && opts.retryableStatusCodes.includes(response.status)) {
        const delay = Math.min(opts.baseDelayMs * Math.pow(2, attempt - 1), opts.maxDelayMs);
        logger.warn('Retryable HTTP error, backing off', {
          url,
          status: response.status,
          attempt,
          delayMs: delay,
        });
        await new Promise(res => setTimeout(res, delay));
        continue;
      }

      if (!response.ok) {
        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
      }

      return response.json() as Promise<T>;
    } catch (error) {
      lastError = error as Error;
      if (attempt === opts.maxAttempts) break;

      const delay = Math.min(opts.baseDelayMs * Math.pow(2, attempt - 1), opts.maxDelayMs);
      logger.warn('Request failed, retrying', { url, attempt, delayMs: delay, error: lastError.message });
      await new Promise(res => setTimeout(res, delay));
    }
  }

  logger.error('All retry attempts exhausted', { url, maxAttempts: opts.maxAttempts });
  throw lastError ?? new Error('Unknown fetch error after retries');
}