Funciones de AWS Amplify: qué salió, dónde y cómo usarlas

Construyo sobre Amplify, y Amplify cambia en más sitios que cualquier otro servicio de AWS que uso: un changelog en un repositorio de GitHub para el backend, otro para la librería JavaScript, tres más para Swift, Android y Flutter, el historial de documentación de Hosting y, solo de vez en cuando, una entrada en AWS What's New. Más de una vez he descubierto una función de Amplify meses después de que saliera, normalmente después de rodear a mano el problema que resuelve. Este post es la solución, hecho igual que mis líneas de tiempo de Bedrock, Kiro y Claude: una línea de tiempo con cada función notable a un lado y los productos de Amplify que la usan al otro, la versión o el estado actual de cada producto, cómo llega la función a tu agente de código (Kiro, Claude Code, AWS AI-DLC) y, para las funciones que más importan, el mejor caso de uso y un ejemplo que puedes ejecutar hoy.

Última revisión: 25 de octubre de 2026. Un agente programado vuelve a leer cada semana los changelogs de Amplify y los anuncios de AWS, actualiza este post y me envía los cambios por correo. Cómo funciona está al final.

TL;DR

1. Amplify hoy son cuatro cosas: librerías cliente (JavaScript, Swift, Android, Flutter), una capa de backend en TypeScript sobre AWS CDK (Gen 2), Amplify Hosting con cómputo SSR y, desde septiembre de 2026, una preview de hosting autogestionado que despliega el frontend en tu propia cuenta.
2. Estado actual: aws-amplify 6.22.2, @aws-amplify/backend 1.25.1 con @aws-amplify/backend-cli 1.10.0, @aws-amplify/ui-react 6.15.7, Swift 2.63.0, Android 2.43.0, Flutter 2.16.0. Hosting ejecuta SSR en Node.js 20, 22 y 24.
3. Los mayores cambios del último año: Gen 1 está en modo mantenimiento (desde el 1 de mayo de 2026; fin de vida el 1 de mayo de 2027) con una herramienta de migración en developer preview; Amazon Pinpoint pierde el soporte el 30 de octubre de 2026, así que Analytics y Push pasan a Kinesis, Firehose y Customer Profiles; y Gen 2 aprendió a desplegarse sin Amplify Hosting.
4. En tu agente de código: no hay un servidor MCP solo para Amplify. AWS publica un plugin aws-amplify para Claude Code, un power aws-amplify para Kiro y skills del Agent Toolkit, todos apoyados en el AWS MCP Server y sus flujos de trabajo para Amplify.
5. Si solo adoptas cinco cosas: Gen 2 con sandboxes por desarrollador, carga de datos de prueba, roles de cómputo IAM para SSR, protección contra desfase y un plan para salir de Gen 1 y de Pinpoint.

Los productos y sus versiones actuales

Producto	Qué es	Versión o estado actual	Docs
Librería JavaScript (aws-amplify)	Auth, Data, Storage, IA, Analytics y Push para apps web y React Native	6.22.2 (13 oct 2026); v5 en mantenimiento; v4 y anteriores sin soporte desde el 13 abr 2026	amplify-js
Backend Gen 2 (@aws-amplify/backend)	El backend definido en archivos TypeScript, sobre AWS CDK, y la CLI ampx	1.25.1 (17 sep 2026); @aws-amplify/backend-cli 1.10.0	Construir un backend
Amplify Hosting	CI/CD gestionado, despliegues por rama y cómputo SSR	SSR en Node.js 20, 22 y 24 (24 desde el 4 may 2026); imagen de build Amazon Linux 2023; la documentación lista Next.js 12 a 15 para SSR gestionado	Guía de usuario
Hosting autogestionado (@aws-amplify/hosting)	defineHosting() y definePipeline(): CloudFront, S3 y Lambda en tu cuenta	1.0.1, preview desde el 9 sep 2026	Self-hosting
AI Kit (@aws-amplify/ai-constructs, @aws-amplify/ui-react-ai)	Rutas de conversación y generación sobre Amazon Bedrock, más componentes de React	1.7.0 y 1.5.2; perfiles de inferencia globales desde ene 2026	AI Kit
Amplify UI (@aws-amplify/ui-react)	Authenticator, Storage Browser y componentes	6.15.7 (2 oct 2026)	Amplify UI
Amplify Swift	iOS, macOS, watchOS y tvOS	2.63.0 (24 oct 2026); modo de lenguaje Swift 6	amplify-swift
Amplify Android	Librería de Android (v2)	2.43.0 (23 oct 2026)	amplify-android
Amplify Flutter	iOS, Android, web y escritorio desde Dart	2.16.0 (14 oct 2026)	amplify-flutter
CLI y Studio de Gen 1	amplify push, Studio y los backends Gen 1	CLI 14.5.1; modo mantenimiento desde el 1 may 2026; fin de vida el 1 may 2027	Aviso
DataStore	Sincronización offline-first sobre AppSync	Sin soporte en Gen 2; termina con Gen 1	Docs de Gen 1
AWS Blocks	Backends en TypeScript componibles que corren en local y se despliegan como CDK	0.3.0, preview desde el 16 jun 2026; se conecta a un backend Gen 2	Anuncio

De Gen 1 a Gen 2: el cambio que más importa en 2026

Durante seis años, "un backend de Amplify" significó Gen 1: responder a las preguntas de la CLI con amplify add, ejecutar amplify push y dejar que Amplify generara CloudFormation anidado que personalizabas con archivos de override. Desde mayo de 2024 significa Gen 2: escribes amplify/auth/resource.ts, amplify/data/resource.ts y compañía en TypeScript, cada desarrollador tiene un sandbox personal en la nube, cada rama de Git tiene su propio despliegue fullstack y todo lo que Amplify no cubre es CDK normal en el mismo proyecto.

El 1 de mayo de 2026, Gen 1 entró en modo mantenimiento: solo correcciones críticas y parches de seguridad hasta su fin de vida el 1 de mayo de 2027. Eso cubre la CLI de Gen 1, Studio y los backends Gen 1; Gen 2, Hosting y las librerías cliente no se ven afectados. Ese mismo día, la CLI 14.4.0 publicó amplify gen2-migration, todavía en developer preview. Es una migración blue/green: Gen 2 se genera a partir de tus stacks desplegados y se despliega junto a Gen 1, y después los recursos con estado (pools de Cognito, tablas de DynamoDB, buckets de S3) se mueven a él con el refactor de stacks de CloudFormation, así que tus usuarios y tus datos se quedan donde están.

npm install -g @aws-amplify/cli@^14.4.0
amplify gen2-migration assess
amplify gen2-migration lock
amplify gen2-migration generate
# deploy the generated Gen 2 app, then:
amplify gen2-migration refactor --to <gen2-root-stack-name>
amplify gen2-migration retain

Tres cosas no se migran. DataStore no tiene equivalente en Gen 2; usa el cliente de datos de Gen 2 con tu propia caché. Analytics y Push basados en Pinpoint terminan con Pinpoint el 30 de octubre de 2026; las librerías ahora apuntan a Kinesis, Firehose y Customer Profiles. Y categorías como Geo y Predictions pasan a ser CDK que escribes tú. El equipo de Amplify dice claramente que la herramienta todavía no es para entornos de producción, así que ejecuta assess primero sobre una copia. Si ya te has topado con errores de despliegue en Gen 2, mis notas sobre dependencias circulares y errores de dependencias en Lambda cubren los dos que más veo.

La línea de tiempo: función ↔ productos

De la más nueva a la más antigua. Productos de Amplify es donde usas la función hoy, no solo donde se lanzó. La columna Agentes de código dice cómo llega la función a Kiro o a Claude Code:

• ✓ tu agente de código la usa directamente: ejecuta el comando (ampx, amplify gen2-migration) mientras trabaja,
• ↔ a través de un puente: el plugin aws-amplify de Claude Code o el power de Kiro, los flujos de trabajo de Amplify del AWS MCP Server, o una skill,
• — algo que construyes en tu aplicación; tu agente te ayuda a escribirlo.

Las filas con ★ tienen un caso de uso y un ejemplo más abajo.

Fecha	Función	Productos de Amplify	Agentes de código
2026‑10‑30	Fin de soporte de Amazon Pinpoint: Analytics y Push basados en Pinpoint dejan de tener soporte	JavaScript, Swift, Android, Flutter	—
2026‑10‑24	AmplifyCognitoClient (beta): un cliente de Cognito independiente y con varias sesiones	Swift 2.63	—
2026‑09‑23	Modo de lenguaje Swift 6, con Sendable en todos los plugins	Swift 2.62	—
2026‑09‑15	createAmplifyContext(): contextos aislados por petición o por tenant; eventos de auth entre pestañas	JavaScript 6.21	—
2026‑09‑09	★ Hosting autogestionado (preview): defineHosting(), definePipeline() y ampx deploy en tu propia cuenta	Backend Gen 2, @aws-amplify/hosting	✓ ampx deploy
2026‑07‑30	Proveedor de push con Customer Profiles y clientes de Connect	JavaScript 6.20, Swift 2.59, Android 2.39, Flutter 2.14	—
2026‑07‑29	defineNotifications sobre Customer Profiles	Backend Gen 2	—
2026‑07‑21	Avisos de obsolescencia de Pinpoint en Analytics; seguimiento automático para Kinesis y Firehose	JavaScript 6.19	—
2026‑06‑16	★ AWS Blocks (preview): backends en TypeScript, componibles y locales, que se despliegan como CDK	AWS Blocks, backend Gen 2	↔ skill aws-blocks
2026‑05‑28	keepOnDelete para storage; stackMappings reparte resolvers en stacks anidados	Backend Gen 2	—
2026‑05‑14	gen2-migration añade inicio de sesión social, recursos CDK propios, resolvers sobrescritos y retain	CLI Gen 1 14.5	✓ amplify gen2-migration
2026‑05‑05	uploadData en el servidor	JavaScript 6.17	—
2026‑05‑04	Node.js 24 para apps SSR	Hosting	—
2026‑05‑01	★ Gen 1 en modo mantenimiento, fin de vida el 1 de mayo de 2027; amplify gen2-migration (developer preview)	CLI Gen 1, Studio, DataStore	✓ amplify gen2-migration
2026‑04‑13	amplify-js v4 y anteriores pierden el soporte	JavaScript	—
2026‑03‑25	Node.js 16 retirado para funciones	Backend Gen 2	—
2026‑03‑11	Despliegue independiente: un backend Gen 2 sin Amplify Hosting	Backend Gen 2	✓ ampx
2026‑02‑10	Node.js 22 por defecto para funciones, Node.js 24 como opción	Backend Gen 2	—
2026‑02‑05	Sin contraseña en el Authenticator	Amplify UI 6.14	—
2026‑01‑27	Perfiles de inferencia globales entre Regiones	AI Kit	—
2026‑01‑18	Herramienta de migración de Gen 1 a Gen 2 (beta)	CLI Gen 1	✓ CLI
2026‑01‑16	Configuración de funciones durables; descripciones en las programaciones de funciones	Backend Gen 2	—
2026‑01‑15	Next.js 16 en el adaptador de Next.js	JavaScript (adapter-nextjs 1.7)	—
2025‑12‑08	Inicio de sesión sin contraseña	Backend Gen 2 1.19	—
2025‑05‑29	Instancias de build: Standard, Large (16 GB) y XLarge (72 GB)	Hosting	—
2025‑04‑29	★ Carga de datos de prueba (seeding) para sandboxes	Backend Gen 2	✓ ampx sandbox seed
2025‑03‑26	★ Integración con AWS WAF GA	Hosting	—
2025‑03‑13	★ Protección contra desfase (skew protection)	Hosting	—
2025‑02‑18	★ Roles de cómputo IAM para apps SSR	Hosting	—
2025‑01‑28	Cliente de Amplify Data dentro de funciones Lambda	Backend Gen 2	—
2024‑11‑19	★ AI Kit para Amazon Bedrock: rutas de conversación y de generación, AIConversation	AI Kit, Amplify UI	—
2024‑06‑01	Amplify iOS v1 y Android v1 obsoletos	Swift, Android	—
2024‑05‑06	★ Gen 2 GA: backends en TypeScript, sandboxes por desarrollador, despliegues fullstack por rama	Backend Gen 2, Hosting	✓ ampx sandbox
2023‑11‑21	Gen 2 en preview	Backend Gen 2	—
2023‑11‑20	SSR para cualquier framework con una especificación de despliegue: Nuxt, Astro, SvelteKit	Hosting	—
2023‑11‑15	★ JavaScript v6: APIs funcionales con tree-shaking y soporte de servidor para Next.js	JavaScript	—
2023‑06‑29	Soporte de monorepos: workspaces de npm, Yarn y pnpm, Turborepo, Nx	Hosting	—
2023‑06‑27	watchOS y tvOS	Swift	—
2023‑04‑20	Amplify Flutter v1 en Dart, con web y escritorio	Flutter	—
2022‑12‑13	Android v2 GA; JavaScript v5	Android, JavaScript	—
2022‑11‑17	Hosting compute con Next.js 12 y 13: middleware, ISR, optimización de imágenes	Hosting	—
2022‑11‑16	In-App Messaging GA	JavaScript	—
2022‑10‑18	Amplify Swift v2, reescrito por completo en Swift	Swift	—
2022‑04‑21	Studio GA con Figma a React	Studio	—
2021‑12‑02	Amplify Studio (preview) sustituye a Admin UI	Studio	—
2021‑11‑19	Componente Authenticator para React, Angular y Vue	Amplify UI	—
2021‑09‑30	Amplify Geo GA con Amazon Location Service	JavaScript	—
2021‑05‑18	SSR de Next.js en Hosting	Hosting	—
2021‑02‑15	Amplify Flutter GA	Flutter	—
2020‑12‑01	Admin UI	Admin UI	—
2020‑08‑20	Amplify Flutter (developer preview)	Flutter	—
2019‑12‑04	DataStore; librerías Amplify para iOS y Android	JavaScript, iOS, Android	—
2018‑11‑26	Amplify Console, hoy Amplify Hosting	Hosting	—
2018‑08	Amplify CLI	CLI Gen 1	—
2017‑11‑21	Librería JavaScript de Amplify	JavaScript	—

Mejores casos de uso, con un ejemplo para cada uno

Agrupados por lo que te ayudan a hacer, no por fecha. Cada uno dice cuándo compensa y trae un ejemplo que puedes pegar.

Definir un backend en TypeScript: Gen 2, sandboxes y datos de prueba

Gen 2 (GA mayo 2024) · Backend Gen 2. Cada recurso es un archivo TypeScript. Auth, datos y reglas de autorización viven juntos, y el tipo Schema llega hasta tu frontend. Ideal para: cualquier app nueva de Amplify, y cualquier app donde dos desarrolladores se pisan los cambios del backend.

// amplify/data/resource.ts
import { a, defineData, type ClientSchema } from '@aws-amplify/backend';

const schema = a.schema({
  Todo: a.model({
      content: a.string(),
      isDone: a.boolean()
    })
    .authorization(allow => [allow.publicApiKey()])
});

export type Schema = ClientSchema<typeof schema>;

export const data = defineData({
  schema,
  authorizationModes: {
    defaultAuthorizationMode: 'apiKey',
    apiKeyAuthorizationMode: { expiresInDays: 30 }
  }
});

// in the frontend
import { generateClient } from 'aws-amplify/data'
const client = generateClient<Schema>()
await client.models.Todo.create({ content: "...", isDone: false })

La carga de datos de prueba (abr 2025) llena un sandbox con usuarios y registros de prueba, así que un sandbox nuevo es usable con un solo comando. Instala @aws-amplify/seed, escribe amplify/seed/seed.ts y ejecútalo:

npm install @aws-amplify/seed --save-dev
npx ampx sandbox
npx ampx sandbox seed

En tu agente de código ✓: Claude Code y Kiro ejecutan npx ampx sandbox y npx ampx sandbox seed por su cuenta, y --stream-function-logs les deja leer los logs de las funciones mientras corrigen un error. En Linux, el observador de archivos del sandbox puede chocar con un límite del sistema; escribí la solución. Si un build no encuentra amplify_outputs.json, mira esta otra.

Sal de Gen 1 antes de que Gen 1 se vaya: la herramienta de migración

Gen 1 en modo mantenimiento y amplify gen2-migration (mayo 2026) · CLI de Gen 1. Los comandos están en la sección de arriba. Ideal para: cualquier equipo que siga con amplify push. Tienes hasta el 1 de mayo de 2027, y el orden más seguro es evaluar ahora, migrar un entorno que no sea de producción y sustituir primero DataStore y Pinpoint, porque no tienen un camino automático.

Ejecutar SSR con seguridad: roles de cómputo, protección contra desfase y WAF

Roles de cómputo IAM (feb 2025), protección contra desfase (mar 2025) y AWS WAF (mar 2025) · Hosting. Un rol de cómputo da permisos de AWS a tu código SSR sin claves de acceso en variables de entorno; se configura en App settings → IAM roles → Compute role, con una política de confianza para amplify.amazonaws.com. La protección contra desfase envía a cada navegador al código de servidor del despliegue que cargó, así que un despliegue a mitad de una sesión no la rompe; actívala por rama en Branch settings → Actions → Enable skew protection y vuelve a desplegar. WAF asocia una web ACL a la app para reglas gestionadas, límites de peticiones y bloqueo por país, por 15 dólares por app al mes más los cargos propios de WAF. Ideal para: cualquier app SSR en producción. Un rol de cómputo sustituye los secretos que si no meterías en el build; la protección contra desfase elimina una clase de errores del tipo "se rompió justo después del despliegue"; WAF se paga solo en cuanto alguien abusa de un formulario o de una ruta de API.

Son ajustes de la consola, así que no hay código que pegar. El compromiso que eliminan es real en este sitio: mira el caso práctico más abajo.

Elegir dónde corre el frontend: Hosting, independiente y autogestionado

Hosting compute (nov 2022, cualquier framework nov 2023), despliegue independiente (mar 2026) y hosting autogestionado (preview, sep 2026) · Hosting, backend Gen 2. Hosting gestionado sigue siendo el camino más sencillo. El hosting autogestionado es para equipos que necesitan la distribución de CloudFront, los buckets y las funciones en su propia cuenta, por ejemplo para cumplir una norma de compliance o para controlar WAF y los logs. Ideal para: hosting autogestionado cuando una política descarta Amplify Hosting; Hosting gestionado en todos los demás casos. Es una preview, así que todavía no es para producción.

npm add @aws-amplify/hosting

// amplify/hosting.ts
import { defineHosting } from '@aws-amplify/hosting';

export const hosting = defineHosting({
  framework: 'nextjs',
  buildCommand: 'npm run build',
  buildOutputDir: '.next'
});

npx ampx deploy --identifier my-app             # backend, frontend and hosting
npx ampx deploy --identifier my-app --frontend  # frontend only

definePipeline() añade un CodePipeline que despliega cada etapa con cada push, y defineHosting acepta las opciones domain, waf y compute. En Hosting gestionado, la documentación lista Next.js 12 a 15; el adaptador de Next.js soporta la 16 desde enero de 2026, y cuento lo que costó ejecutar Next.js 16 en Amplify SSR y qué versión de Node construye tu app.

Añadir IA generativa desde el esquema: el AI Kit

AI Kit para Amazon Bedrock (nov 2024; perfiles de inferencia globales ene 2026) · AI Kit, Amplify UI. Una ruta de conversación es un chat en streaming con el historial guardado para cada usuario; una ruta de generación devuelve una salida tipada y estructurada a partir de una sola petición. Las dos forman parte de tu esquema de datos, así que la autorización funciona igual que en un modelo. Ideal para: un chat de soporte o un botón de "redáctalo por mí" en una app que ya usa Amplify Data, sin montar tu propio proxy hacia Bedrock.

// inside a.schema({ ... }) in amplify/data/resource.ts
  chat: a.conversation({
    aiModel: a.ai.model('Claude 4.5 Haiku'),
    systemPrompt: 'You are a helpful assistant',
  })
  .authorization((allow) => allow.owner()),

  generateRecipe: a.generation({
    aiModel: a.ai.model('Claude 4.5 Haiku'),
    systemPrompt: 'You are a helpful assistant that generates recipes.',
  })
  .arguments({ description: a.string() })
  .returns(a.customType({ name: a.string(), ingredients: a.string().array(), instructions: a.string() }))
  .authorization((allow) => allow.authenticated()),

import { generateClient } from "aws-amplify/api";
import { createAIHooks } from "@aws-amplify/ui-react-ai";
export const client = generateClient<Schema>({ authMode: "userPool" });
export const { useAIConversation, useAIGeneration } = createAIHooks(client);
// in a component:
const [{ data: { messages }, isLoading }, handleSendMessage] = useAIConversation('chat');

La lista de modelos del AI Kit llega hoy hasta las familias Claude 4.5 y 4.6, que funcionan con perfiles de inferencia globales; los modelos de Claude más nuevos llegan antes a Bedrock, como muestra mi línea de tiempo de Bedrock. Comparo el AI Kit con GenU de AWS en GenU vs el Amplify AI Kit.

Componer backends: AWS Blocks

AWS Blocks (preview, jun 2026) · AWS Blocks, backend Gen 2. Cada Block es una capacidad independiente (Postgres, mensajería en tiempo real, almacenamiento clave-valor, trabajos en segundo plano, agentes de IA) que corre por completo en tu portátil sin cuenta de AWS y se despliega como CDK. En un proyecto Gen 2 se despliega como un stack anidado y reutiliza el user pool de Cognito de Amplify. La documentación de Amplify lo presenta como un complemento de Gen 2, no como un sustituto. Ideal para: una capacidad que Gen 2 no cubre bien, como Postgres o los trabajos en segundo plano, en una parte nueva y no crítica de una app. Mantén Gen 2 como columna vertebral mientras Blocks esté en preview.

npx @aws-blocks/create-blocks-app

Ejecutado en la raíz de un proyecto Gen 2, detecta amplify/backend.ts, crea aws-blocks/ y amplify/blocks.ts, y los conecta al backend. En tu agente de código ↔: la skill aws-blocks del plugin aws-core del Agent Toolkit.

Clientes más pequeños y tipados: JavaScript v6 y las reescrituras nativas

JavaScript v6 (nov 2023), Swift v2 (oct 2022, modo Swift 6 sep 2026), Android v2 (dic 2022) y Flutter v1 en Dart (abr 2023) · librerías cliente. v6 sustituyó las APIs basadas en clases por funciones que importas una a una, lo que redujo una app de ejemplo con Auth y Storage de 77 KB a 31 KB, y añadió soporte de servidor para Next.js. Ideal para: cualquier app que siga en JavaScript v5 o anterior, o en las librerías nativas v1, que ya no reciben correcciones. Gen 2 necesita aws-amplify 6.2.0 o posterior.

import { signIn } from 'aws-amplify/auth'

Cómo se integra Amplify con Kiro, Claude Code y AWS AI-DLC

Amplify no es algo sobre lo que corre tu agente de código, como Claude Code corre sobre Bedrock. Es algo con lo que tu agente construye, y AWS ya publica las piezas para eso. No hay un servidor MCP solo para Amplify; la documentación de Amplify apunta al AWS MCP Server, que aloja tres flujos de trabajo de Amplify ("agent SOPs") que un agente carga con retrieve_agent_sop: amplify-backend-implementation, amplify-frontend-integration y amplify-deployment-guide.

Claude Code: el plugin aws-amplify

La documentación de Amplify recomienda el plugin aws-amplify del marketplace propio de AWS (Claude Code 2.1.29 o posterior). Incluye una skill amplify-workflow, un hook que comprueba los requisitos previos y el AWS MCP Server:

/plugin marketplace add awslabs/agent-plugins
/plugin install aws-amplify@agent-plugins-for-aws

El Agent Toolkit for AWS, que AWS describe como el sucesor de sus servidores MCP y plugins anteriores, está en el marketplace por defecto de Anthropic. Su plugin aws-core incluye la skill aws-blocks:

/plugin install aws-core@claude-plugins-official

Si prefieres solo un servidor de documentación, el AWS Knowledge MCP Server remoto no necesita credenciales de AWS y cubre la documentación de Amplify:

claude mcp add --scope project --transport http aws-knowledge https://knowledge-mcp.global.api.aws

La documentación de Amplify también publica llms.txt y llms-full.txt en https://docs.amplify.aws/ai/, más una copia en Markdown de cada página, algo útil cuando pegas una página en un prompt. Sigo lo que cambia del lado de Claude en mi línea de tiempo de Claude.

Kiro: el power aws-amplify

En Kiro, instala el power aws-amplify ("Build full-stack apps with AWS Amplify Gen2") desde el panel de Powers. No necesita configuración manual: trae 16 archivos de steering (scaffolding, auth, datos, storage, funciones, IA, despliegue y más, para web y móvil) y esta entrada MCP, que también funciona tal cual en .kiro/settings/mcp.json:

{
  "mcpServers": {
    "aws-mcp": {
      "command": "uvx",
      "timeout": 100000,
      "transport": "stdio",
      "args": [
        "mcp-proxy-for-aws@latest",
        "--log-level",
        "ERROR",
        "https://aws-mcp.us-east-1.api.aws/mcp"
      ]
    }
  }
}

La documentación de Amplify sugiere un archivo de steering para que Kiro recurra siempre a esos flujos de trabajo:

# Amplify Development Guidelines

When working on Amplify projects, use the AWS MCP Server guided workflows:

- For backend features (auth, data, storage, functions, AI), call `retrieve_agent_sop` with `amplify-backend-implementation`
- For frontend integration, call `retrieve_agent_sop` with `amplify-frontend-integration`
- For deployment tasks, call `retrieve_agent_sop` with `amplify-deployment-guide`

Guárdalo como .kiro/steering/amplify.md. Escribe primero los requisitos como una spec de Kiro y deja que el power construya los archivos de amplify/; cuento cómo encadeno specs y hooks en flujos de trabajo de Kiro y sigo los cambios del propio Kiro en la línea de tiempo de Kiro.

AWS AI-DLC: el proceso alrededor

AI-DLC es el método de AWS para construir con agentes: Inception, Construction y Operation, con un equipo que valida las preguntas de la IA en cada puerta. Se instala como harness para Claude Code o Kiro, y --mcp defaults añade el AWS MCP Server:

curl -fsSL https://github.com/awslabs/aidlc-workflows/releases/latest/download/install.sh | sh
aidlc config --harness claude --mcp defaults   # or --harness kiro-ide
aidlc doctor

AI-DLC no menciona Amplify, y no le hace falta: en Inception, el equipo decide si una función necesita un backend Gen 2, un Block o solo ajustes de Hosting; en Construction, el plugin o el power de Amplify lo construye; en Operation, los despliegues por rama y los logs de CloudWatch dan al equipo la evidencia para la siguiente puerta. Comparo AI-DLC con el playbook de Anthropic y con mi propio flujo de trabajo en Anthropic's AI SDLC vs AWS AI-DLC vs Cursor pstack vs my workflow.

Cómo se integra Amplify con el ecosistema de AWS

El valor de Amplify es que es una capa fina de TypeScript sobre servicios que ya conoces, así que todo lo que crea es un recurso normal de AWS en tu cuenta:

• Identidad y acceso. defineAuth crea un user pool de Cognito con grupos y proveedores de identidad externos, incluido el inicio de sesión sin contraseña. Para los desarrolladores, la guía de configuración usa IAM Identity Center con la política AmplifyBackendDeployFullAccess. Cognito tiene límites que muerden más tarde; los atributos de un user pool no se pueden cambiar una vez creados.
• Datos y almacenamiento. defineData construye una API GraphQL de AppSync sobre DynamoDB, o se conecta a una base de datos MySQL o PostgreSQL existente; defineStorage crea un bucket de S3 con reglas por ruta.
• Seguridad y gobierno. Los valores de secret() viven en SSM Parameter Store, por rama o compartidos; AWS WAF protege las apps de Hosting; los roles de cómputo IAM mantienen las claves fuera de los entornos SSR.
• Observabilidad. Los logs de SSR y de funciones van a CloudWatch; defineData puede activar los logs de AppSync con un periodo de retención.
• Cómputo y build. Las funciones son Lambda en Node.js 22 o 24, y todo lo demás es CDK: backend.createStack() añade tu propio stack, y backend.data.resources expone los generados.

// amplify/backend.ts
const customResourceStack = backend.createStack('MyCustomResources');
new sqs.Queue(customResourceStack, 'CustomQueue');

const { cfnResources } = backend.data.resources;
for (const table of Object.values(cfnResources.amplifyDynamoDbTables)) {
  table.pointInTimeRecoveryEnabled = true;
}

• Facturación. Hosting cobra por minuto de build, GB almacenado, GB servido y petición SSR, WAF añade una tarifa fija de 15 dólares por app al mes, y los servicios del backend se facturan igual que sin Amplify. El uso de Bedrock del AI Kit lo factura Bedrock. Para costes y límites por rama, mira por qué cada rama de Amplify necesita su propio webhook de Stripe.

Un caso práctico: sacar del build la clave del newsletter de este sitio

Este sitio es una app Next.js en Amplify Hosting SSR sin backend Gen 2. El alta al newsletter es un route handler que llama a Kit, y como las variables de entorno de Hosting solo existen en tiempo de build, el build vuelca la clave de Kit en .env.production para que el servidor pueda leerla. El comentario de amplify.yml lo registra como un compromiso: un radio de impacto pequeño frente a montar un backend Gen 2 para una sola llamada. Dos funciones de esta línea de tiempo eliminan ese compromiso, así que este es el plan que seguiría. Es un plan, no algo que ya esté en el repositorio.

1. Enmarcarlo (AI-DLC). Ejecuta /aidlc Move the Kit key out of the build en Claude Code. Inception compara las dos opciones: un rol de cómputo IAM que lea la clave de un almacén de secretos en tiempo de ejecución, o una función de Gen 2 que guarde la clave y a la que llame la ruta. La segunda también da al sitio un backend para futuras funciones, así que registraría esa elección y el motivo.
2. Especificar (Kiro). Convierte la decisión en una spec de Kiro con requisitos EARS: THE SYSTEM SHALL NOT incluir la clave de Kit en ningún artefacto de build; WHEN un lector se suscribe en un despliegue de rama THE SYSTEM SHALL usar la clave de esa rama.
3. Andamiaje (Gen 2). Añade un backend amplify/ a la app existente con npm create amplify@latest, con el power o el plugin aws-amplify rellenando los archivos.
4. Sandbox. npx ampx sandbox me da un backend personal, y npx ampx sandbox secret set KIT_API_KEY guarda la clave allí, nunca en Git.
5. Función. Una función subscribe en Node.js 22 lee la clave con secret(), el mismo patrón que el ejemplo de la documentación:

import { defineFunction, secret } from '@aws-amplify/backend';

export const subscribe = defineFunction({
  environment: {
    KIT_API_KEY: secret('KIT_API_KEY')
  }
});

6. Conectarla (Amplify Data). Una mutación personalizada con .handler(a.handler.function(subscribe)), llamada desde el route handler existente con el cliente de datos de servidor, generateServerClientUsingCookies.
7. Proteger (Hosting). Una regla de límite de peticiones de WAF delante del formulario, y protección contra desfase para que un despliegue durante un alta no envíe el formulario al código de servidor equivocado.
8. Publicar. Los despliegues por rama mantienen la puerta staging → main; el build añade npx ampx pipeline-deploy --branch $AWS_BRANCH --app-id $AWS_APP_ID a amplify.yml, y desaparece la línea que vuelca las variables KIT_ en .env.production. El error de TypeScript que solo veía CI es el que hay que vigilar cuando amplify_outputs.json entra por primera vez en el build.

Esta es la arquitectura después del paso 8, con las seis peticiones en orden:

El reparto es el mismo que en mis otras líneas de tiempo. Amplify lo ejecuta; Kiro es dueño de la spec; Claude Code construye; AI-DLC deja la decisión explícita antes de que exista código. Si trabajas como forward deployed engineer, este es el tipo de cambio que el equipo de un cliente puede revisar en un solo pull request y mantener después. Las preguntas sobre tu propia configuración son bienvenidas en la página de contacto.

Cómo se mantiene al día este post

Mis líneas de tiempo de Bedrock, Kiro y Claude usan la misma configuración, así que la copié:

1. Una tarea programada en Claude Code en la web se ejecuta cada lunes por la mañana en una sesión nueva en la nube con este repositorio.
2. Sigue una skill del repositorio, .claude/skills/amplify-features-update/SKILL.md. Como Amplify anuncia la mayoría de los cambios solo en changelogs, la skill lee las fuentes oficiales en este orden: los archivos CHANGELOG y los tags de release de amplify-backend, amplify-js, amplify-ui, amplify-swift, amplify-android, amplify-flutter y amplify-cli; el historial de documentación de Hosting; AWS What's New; y el blog Front-End Web & Mobile. La prensa y los posts de la comunidad solo le señalan cosas que confirmar allí.
3. Añade filas nuevas a la línea de tiempo, actualiza la tabla de productos, las versiones y la fecha de "Última revisión" en los dos idiomas, ejecuta los tests del sitio y abre un pull request a staging.
4. Me envía un correo con un resumen: qué hay de nuevo, qué productos de Amplify toca, cómo llega a Kiro o a Claude Code y un enlace al pull request. Si no cambió nada, el correo lo dice en una línea.

Si quieres lo mismo sin un repositorio, una tarea programada de Claude o una Kiro Automation con el prompt "cada lunes, lista lo que AWS Amplify publicó desde el lunes pasado según los changelogs de aws-amplify en GitHub y envíamelo por correo" te lleva casi todo el camino.

Fuentes

• Changelogs y tags: amplify-backend, amplify-js, amplify-ui, amplify-swift, amplify-android, amplify-flutter y amplify-cli
• Gen 1: aviso de modo mantenimiento, discusión de la herramienta de migración y migrar una app existente
• Migración de Pinpoint, hosting autogestionado y AWS Blocks (preview)
• Gen 2: anuncio de GA, blog de la preview, AI Kit, cliente de datos en Lambda y carga de datos de prueba
• Hosting: roles de cómputo, protección contra desfase, instancias de build, precio de WAF, soporte de SSR y Next.js 12 y 13 en compute
• Historia: lanzamiento de Amplify JavaScript, DataStore, Studio y JavaScript v6
• Agentes de código: AWS MCP Server, awslabs/agent-plugins, Agent Toolkit for AWS, power aws-amplify de Kiro, awslabs/mcp, MCP en Claude Code y awslabs/aidlc-workflows