Estoy desarrollando una aplicación SaaS de gestión de tareas con:
- Frontend: React 18 + TypeScript
- Backend: Node.js + Express
- Base de datos: PostgreSQL
- Autenticación: JWT

Actúa como un desarrollador fullstack senior con 10 años de
experiencia en arquitectura de sistemas escalables.

Necesito implementar un endpoint de API REST para obtener tareas
filtradas por estado. Los usuarios deben estar autenticados y solo
ver sus propias tareas.

Proporciona:
1. Controlador Express con manejo de errores
2. Validaciones de entrada usando Joi
3. Pruebas unitarias con Jest
4. Documentación API en comentarios JSDoc

Preferencias:
- Respeta la arquitectura existente del proyecto
- Usa los middlewares de autenticación existentes
- Rendimiento: debe responder en < 200ms
- Paginación: máximo 50 items por página

ROL:
Eres un experto en [dominio específico] con [años] de experiencia.

CONTEXTO:
Nuestro sistema usa [tecnologías].
Las restricciones son [lista de limitaciones].
El objetivo general del proyecto es [objetivo].

TAREA PRINCIPAL:
Realiza [acción principal].

DETALLES ESPECÍFICOS:
- Considera [parámetro 1]
- Asegura [restricción 2]
- Incluye [elemento 3]

CRITERIOS DE ÉXITO:
- [Criterio 1]
- [Criterio 2]
- [Criterio 3]

FORMATO DE SALIDA:
[Especifica el formato esperado]

Antes de generar código, explica tu enfoque:
1. ¿Qué problema estamos resolviendo?
2. ¿Cuáles son las consideraciones de rendimiento?
3. ¿Qué casos límite debemos manejar?
4. ¿Cuál será la arquitectura general?

LUEGO proporciona el código completo.

Aquí hay un ejemplo de cómo estructuramos nuestros servicios:

Ejemplo 1 - Servicio de Usuarios:
[ejemplo de código]

Ahora, crea un servicio similar para tareas usando la misma
estructura y convenciones de nombres.

Eres un asistente de codificación para un equipo de desarrolladores fullstack.
- Siempre usa TypeScript en lugar de JavaScript
- Proporciona código listo para producción con manejo de errores
- Siempre incluye pruebas unitarias
- Documenta tu código con comentarios JSDoc claros
- Respeta la arquitectura hexagonal
- Maximiza el rendimiento y la seguridad

PASO 1: Analiza los requisitos
PASO 2: Propone una arquitectura
PASO 3: Implementa el componente principal
PASO 4: Añade pruebas
PASO 5: Documenta la API

Quiero crear un componente React reutilizable llamado [NombreComponente].

Especificaciones:
- Props: [lista de props con tipos]
- Estilos: [CSS/TailwindCSS]
- Responsividad: Mobile-first, optimizado para [breakpoints]
- Accesibilidad: WCAG 2.1 AA
- Usado en [contexto de uso]

Proporciona:
1. Componente TypeScript con tipos completos
2. Historia de Storybook para probar variantes
3. Pruebas de accesibilidad
4. Documentación de uso

Crea un formulario React para [objetivo].

Campos requeridos:
- [Campo 1]: [tipo] [validación]
- [Campo 2]: [tipo] [validación]

Requisitos:
- Validación del lado cliente en tiempo real
- Manejo elegante de errores
- Estados de carga y error
- Integración con [endpoint API]
- Accesibilidad WCAG completa

Incluye: componente principal, hook personalizado, pruebas

Implementa un componente Modal que:
- Respete los patrones de accesibilidad ARIA
- Maneje el focus correctamente
- Soporte escape del teclado
- Tenga un sistema de confirmación
- Funcione perfectamente en mobile

Usa: [librería: radix-ui/headless-ui]
Estilo: [TailwindCSS/CSS-in-JS]

Crea un endpoint de API REST POST /api/[recurso] que:
- Autenticación: JWT Bearer token
- Validación: [especificaciones validación]
- Lógica de negocio: [descripción]
- Manejo de errores: códigos HTTP apropiados
- Logging: todas las operaciones importantes
- Rate limiting: [límites]

Proporciona:
1. Controlador/ruta con manejo de errores
2. Servicio con lógica de negocio
3. Validación de datos (Joi/Zod)
4. Pruebas de integración
5. Documentación OpenAPI/Swagger

Crea un servicio TypeScript para gestionar [entidad] en PostgreSQL:
- Operaciones CRUD completas
- Transacciones para operaciones multi-tabla
- Optimización de queries (índices, eager loading)
- Manejo de errores específicos
- Soft deletes si es aplicable

Stack: [ORM: Prisma/TypeORM], [QueryBuilder]
Incluye: pruebas, migraciones, tipos TypeScript

Implementa un middleware de autenticación JWT para [framework]:
- Extracción del token desde [ubicación: headers/cookies]
- Validación y decodificación
- Manejo de tokens expirados
- Refresco automático del token
- Logging de intentos fallidos
- Pruebas de seguridad

Requisitos: [gestión de secretos], [CORS si es aplicable]

Crea una suite completa de pruebas Jest para [función/clase]:
- Casos de éxito estándar
- Casos límite y edge cases
- Manejo de errores
- Mocks y stubs si es necesario
- Cobertura > 90%
- Pruebas de rendimiento si es relevante

Función: [código proporcionado o descripción]

Escribe pruebas de integración para [feature]:
- Setup de base de datos de prueba
- Seeds de datos de prueba
- Pruebas del flujo completo: solicitud → lógica → respuesta
- Cleanup después de cada prueba
- Manejo de transacciones de prueba

Framework: [Jest/Vitest], DB: [PostgreSQL/etc]
Incluye: fixtures, helpers, teardown

Crea pruebas E2E para el escenario de usuario:
1. [Paso 1 del escenario]
2. [Paso 2 del escenario]
3. [Paso 3 del escenario]

Incluye:
- Selectores robustos (data-testid preferido)
- Esperas explícitas (sin esperas fijas)
- Screenshot en caso de error
- Pruebas multi-navegador si es relevante

Optimiza esta función/componente para rendimiento:

Código actual:
[código]

Análisis:
- Identifica los cuellos de botella
- Mide el impacto de cada optimización
- Propone alternativas

Restricciones:
- Mantén la legibilidad
- Compatibilidad con [versión Node/navegador]
- Sin nuevas dependencias externas

Proporciona: código optimizado, explicaciones, benchmarks

Crea un pipeline [GitHub Actions/GitLab CI] para:
- Pruebas automatizadas (unit, integración, E2E)
- Linting y formateo de código
- Seguridad: escaneo de dependencias
- Build y optimización
- Despliegue automático hacia [environment]

Stack: [tecnologías usadas]
Disparadores: [PR, commit, tags]

Crea un Dockerfile optimizado para una app [tipo]:
- Multi-stage build para reducir tamaño
- Listo para producción con security best practices
- Variables de entorno
- Health checks
- Logs dirigidos a stdout

Stack: [Node/Python/etc]
Tamaño de imagen objetivo: [límite]

Genera documentación OpenAPI/Swagger para estos endpoints:
[lista de endpoints]

Incluye para cada endpoint:
- Descripción clara
- Parámetros con tipos y ejemplos
- Respuestas (éxito y errores)
- Códigos de autenticación
- Rate limiting
- Ejemplos cURL y JavaScript

Formato: OpenAPI 3.0 en YAML

Propone una arquitectura [funcionalidad] para:
- [Restricción 1]
- [Restricción 2]
- [Restricción 3]

Incluye:
- Diagrama textual de la estructura
- Explicaciones de las opciones
- Justificaciones de los patterns usados
- Consideraciones de escalabilidad y mantenimiento

Crea un README completo para [proyecto] incluyendo:
- Descripción del proyecto
- Features principales
- Stack tecnológico
- Instrucciones de instalación
- Variables de entorno requeridas
- Comandos de desarrollo
- Estructura de carpetas
- Guía de contribución
- Troubleshooting común

Audiencia: nuevos contribuyentes
Idioma: [ES/EN según el proyecto]

Crea una interfaz para [objetivo].

Diseño:
- Moderno y limpio, inspirado en [referencia de diseño]
- Colores: [paleta especificada]
- Responsivo: desktop, tablet, mobile
- Modo oscuro soportado

Funcionalidades:
- [Lista de interacciones]

Dependencias: [React, TailwindCSS, etc]

Crea una aplicación fullstack para [objetivo]:

Frontend:
- Framework: React
- Estilo: TailwindCSS
- State management: [opción]
- Páginas: [lista]

Backend (opcional si Node.js):
- Endpoints de API: [especificaciones]
- Base de datos: [tipo]

Features principales:
1. [Feature 1]
2. [Feature 2]
3. [Feature 3]

// En .cursor/rules o prompt del sistema

Eres un asistente de codificación para este proyecto específico.
Convenciones:
- Nombres de archivos: kebab-case
- Variables/funciones: camelCase
- Clases: PascalCase
- Constantes: UPPER_SNAKE_CASE

Estilo de código:
- Usa tipos TypeScript estrictos
- Incluye JSDoc para funciones públicas
- Prefiere componentes funcionales
- Exporta tipos con implementaciones

Antes de escribir código:
1. Explica tu enfoque
2. Identifica las dependencias
3. Explica las opciones arquitectónicas

ITERACIÓN 1:
Genera la estructura básica del componente [Componente].

ITERACIÓN 2:
Añade la lógica de estado y los handlers.

ITERACIÓN 3:
Añade validaciones y manejo de errores.

ITERACIÓN 4:
Añade pruebas y documentación.

Basado en este servicio existente:
[código del servicio]

Crea un servicio similar para [nueva entidad] respetando
los mismos patrones, convenciones de nombres y estructura de errores.

Aquí está el código propuesto:
[código]

Antes de concluir:
1. Critica este código: ¿cuáles son los problemas potenciales?
2. ¿Qué edge cases faltan?
3. ¿Cómo mejorar el rendimiento?
4. Propón una versión optimizada del código.