Cómo crear prompts efectivos para generar código con IA

¿Quieres que tu proyecto salga de un prompt y se convierta en un producto real… o en otro experimento bonito que nadie mantiene?

Poca gente lo dice así: usar Lovable o Bolt.new no te salva de las malas decisiones. Te da velocidad y una sensación de omnipotencia. Eso es peligroso. Si no pones reglas, estándar y criterio técnico, la IA te entregará un prototipo brillante y un desastre a medio plazo.

Resumen rápido (lectores con prisa)

Qué es: Lista de buenas prácticas para usar IA en generación de código de producción.

Cuándo usarlo: Antes de delegar generación de pantallas, esquemas o integraciones críticas a un LLM.

Por qué importa: Evita deuda técnica, fugas de seguridad y vendor lock‑in.

Cómo funciona: Define contrato y plan primero; da contexto reducido al modelo y versiona prompts.

Tiempo estimado de lectura: 6 min

Ideas clave

• Ventana de contexto es tu presupuesto: modulariza y da snippets pequeños.
• Diseña tus tablas y ERD antes de pedir esquemas a la IA.
• Plan First: valida el plan antes de generar código.
• Evita vendor lock‑in y exige código estándar y control de versiones.
• Seguridad: nunca hardcodees keys en el cliente; usa BFF y Secret Manager.

1) El Context Window es tu presupuesto real

La IA no tiene memoria infinita. La ventana de contexto es el límite de atención del modelo. Si tu app es un mamotreto con 20 componentes, 10 rutas y 3 librerías por feature, la IA terminará olvidando piezas críticas.

Síntoma

Pides una nueva pantalla y la IA borra imports o rompe tests que estaban bien ayer.

Solución

• Modulariza. Divide en microcomponentes. Un componente = una responsabilidad.
• Un prompt = el componente y sus contratos (props, eventos, estado).
• Mantén snippets pequeños y referencias externas. No le metabolismes el repo entero en una sola petición.

Truco

La ventana de contexto es la mochila del modelo. Pocas cosas, y bien organizadas —no todo el campamento adentro.

2) Base de datos: tú diseñas las tablas, no la IA

Lovable y Bolt.new son rápidos para scaffolding. Pero pedirle a la IA que “genere el esquema” suele acabar en redundancias y campos con nombres raros tipo “user_name_2”.

• Regla dura: escribe el ERD primero. Define relaciones (1:N, N:M), claves foráneas, índices y tipos. Dale ese SQL o ese esquema inicial a la IA como contexto.
• Si usas Supabase, prepara las migrations y políticas RLS antes de que la IA genere las pantallas.
• Beneficio: menos prompts, menos correcciones, menos refactors dolorosos.

3) Plan First, Code Later — no es sugerencia, es mandamiento

Las herramientas muestran un plan. Léelo como si fuera el contrato que firmarás. Si el plan falla, el código será un remiendo.

Preguntas que debes hacer al plan

• ¿Entendió el flujo del usuario?
• ¿Qué librerías propone y por qué?
• ¿Qué estrategias de estado (local/global) va a usar?
• ¿Qué testing planea (unit, e2e)?

Si la IA propone algo raro, corrígelo en el plan. Luego ejecuta la generación.

Pro-tip: agrupa requerimientos complejos en un solo prompt largo (Lovable) o en un bloque bien definido con ejemplos (Bolt.new). Gasta menos mensajes y evitas contradicciones.

4) Vendor lock‑in y exportación: piensa en huir antes de casarte

¿Y si dentro de seis meses quieres migrar? ¿Qué pasa si Bolt.new cambia modelo de negocio? No te cases por default.

• Exige código estándar: React+Vite+Tailwind o lo que tu equipo soporte.
• Control de versiones: GitHub integrado y commits humanos. Que el repo sea clonable y arranque local.
• Evita dependencias propietarias: libs que solo funcionan dentro del editor de la plataforma son bombas de tiempo.

5) Manejo de diffs y errores cíclicos: corta el bucle

La IA puede entrar en bucles de “arreglar-esto-romper-aquello”. Si ves repetidos fallos en el mismo bloque, deja de pedirle que arregle. Entra y corrige manualmente.

• Técnica simple: si falla dos veces en el mismo lugar, resetea a un commit estable y arregla a mano. Luego vuelve a la IA.
• Por qué funciona: rompes el estado de error acumulado y le das a la IA un contexto limpio.

Tokens vs mensajes: cómo pagar menos sin perder eficacia

Bolt.new cobra por tokens. Lovable, por mensajes. Eso cambia la estrategia.

• Bolt.new (tokens): haz micro-prompts, optimiza longitud y reusa templates. Bueno para iteración rápida.
• Lovable (mensajes): agrupa instrucciones complejas en un solo prompt largo. Menos interacciones, más orden.

Stack “opinada”: si quieres otra cosa, pelea por ello

Estas herramientas aman React y Tailwind. Si tu stack es Angular, Laravel o un monolito legacy, prepárate para forzar mucho al modelo.

• Opción A: adapta tu stack al flujo (si puedes).
• Opción B: usa una herramienta más abierta (Cursor, Copilot, IDEs asistidos). Menor magia visual, pero mayor control técnico.

Seguridad: las API keys no son souvenirs

El error clásico: pedir a la IA que “integre Stripe” y conseguir un .env con la API key pegada en el frontend. Eso pasa. Mucho.

• Nunca pongas keys en el cliente.
• Siempre: BFF (Backend-for-Frontend) + Secret Manager (AWS Secrets Manager, Vault).
• Recomendación: short-lived tokens y rotación automatizada. Kill-switch para revocar keys si algo huele raro.

Prompt versioning: trata el prompt como código

Un cambio de prompt puede cambiar comportamiento entero. Versiona tus prompts como si fueran migrations.

• Estructura mínima: promptId, version, author, changelog, template.
• Guarda promptId y promptVersion en metadatos de cada request para reproducibilidad y auditoría.

Moderación y trust & safety: no lo ignores

Tus usuarios intentarán generar logos, contenido protegido o imágenes que no deberías producir.

• Filtra y modera en el BFF antes de llamar al modelo.
• Bloquea términos sensibles. Si hay duda, manda a revisión humana.
• Log: guarda hashes de prompts, no texto completo si hay PII.

Observability: métricas que realmente importan

No solo logs. Métricas que salven tu día.

• Latencia E2E por prompt.
• Cost per generation (USD).
• Cache hit ratio.
• Rate of regeneration per user.
• Incidencias de prompt-injection.

Cache: ahorra dinero y tiempo

Si dos usuarios piden “perro astronauta”, no generes dos imágenes nuevas.

• Hash(prompt + constraints) → Redis.
• TTL adaptativo: prompts comerciales frecuentes TTL largo; prompts únicos TTL corto.
• Cache hit = ahorro directo.

Testing y CI: no dejes que la IA improvise tu pipeline

• Mockea LLM en tests unitarios.
• Contract tests: respuesta del modelo debe cumplir schema JSON.
• Canary releases para nuevos prompts: 1% tráfico, luego escalas.

UX que no traicione la IA

• Siempre: transparencia. Indica cuando la respuesta es generativa.
• Si confidence < 0.6: pide confirmación humana antes de acciones sensibles.
• Muestra el prompt o la interpretación antes de ejecutar (editable).

Playbook anti-abuso (lo que debes tener listo)

• Rate limits y quotas por usuario.
• Circuit breaker y fallback a placeholder.
• Kill switch global para detener generación masiva.
• Alertas de gasto (thresholds diarios).

Plantilla rápida: prompt “Plan First”

Usa esta plantilla antes de generar código. Pégala como prompt inicial.

System: “Eres un generador de código que sigue estrictamente el plan. Responde con: 1) Plan de archivos; 2) Librerías y versiones; 3) Tests a crear; 4) Código. El prompt del usuario es: {{user_prompt}}. Las reglas de la marca: {{brand_rules}}. Stack: React 18, Vite, Tailwind 3.2. Output: JSON con campos plan, files[], tests[].”

Si la IA no responde en ese formato, rechaza y reprompt.

Checklist mínimo antes de pulsar “deploy”

• [ ] ERD definido y migrations escritas.
• [ ] Prompt versionado y almacenado en repo seguro.
• [ ] BFF implementado con secret manager y rate limiting.
• [ ] Moderación automática y paths de escalado humano.
• [ ] Tests con mocks LLM.
• [ ] Canary rollout para new prompts.
• [ ] Observability y alertas de coste.

Errores que acaban con productos bonitos

• Permitir que la IA toque el schema sin revisión.
• Dejar keys en el bundle para facilitar “hackeo” por bots.
• No versionar prompts: si algo falla, no puedes reproducir.
• Depender de wrappers no oficiales (Midjourney via Discord): buen gusto para hobbies, mal gusto para negocios.

Qué hacer ahora (acción inmediata)

1. Si estás probando: agrega promptVersion y un traceId a cada petición.
2. Si vas a producción: crea el BFF en la próxima semana. No hay atajos.
3. Si tienes equipo: asigna ownership de prompts a un rol (AI Owner) con procesos de CI.

Si quieres que te lo entregue listo

Responde “QUIERO EL KIT” y te doy:

• Esqueleto BFF Node/Nest con secret manager y rate limiting.
• Plantilla de prompt versionado y CI para canary prompts.
• Component React + Vite + Tailwind con patrón Plan First integrado.
• Tests e2e que simulan LLM.

Dominicode Labs

Si quieres explorar workflows y agentes aplicados a producto, puedes ver recursos y experimentos relacionados en Dominicode Labs. Es un complemento lógico si trabajas con automatización y agentes en entornos de producción.

FAQ