Anatomía de un prompt efectivo e iteración continua

Durante años hemos visto los prompts como “la frase correcta” que desbloquea una gran respuesta. Con la práctica entendemos que es algo más simple y útil; un prompt no es magia, es un proceso. Empieza con una intención clara, continúa con una primera salida “suficientemente buena” y mejora con ajustes pequeños y medibles. Sin ansiedad, con método.

En este artículo unimos dos piezas que se necesitan mutuamente; la anatomía de un prompt efectivo y la iteración continua. El objetivo es que dejes de probar suerte y empieces a trabajar con un flujo reproducible.

¿Qué aprenderás?

• Identificar las 6 partes de un prompt efectivo en un caso dado.
• Redactar un prompt con formato de salida fijo y criterios verificables.
• Aplicar un bucle de iteración (≥3 ciclos) documentando qué cambias y por qué.
• Medir la mejora con una rúbrica corta (0–3 por criterio) y aplicar autocheck.

Prerrequisitos

Nada especial. Si usas Cursor u otro editor con IA integrada, podrás aplicar todo al instante. Con saber pegar prompts y leer salidas, alcanza.

Anatomía de un prompt efectivo

Piensa tu prompt como un brief; un encargo escrito, corto y concreto, que explica qué necesitas, con qué límites y en qué formato quieres la entrega. Si completas estas piezas, la IA tendrá la misma información que tendría un colega y evitarás vueltas innecesarias:

• Objetivo - Qué necesitas exactamente (entregable, no actividad). Ejemplo: “Una función esPrimo(n) y 8 pruebas unitarias.”

• Contexto — Stack, versión, audiencia, alcance (qué incluye/excluye). Ejemplo: “Node 20 + Jest, español, sin dependencias externas.”

• Restricciones — Límites y convenciones (rendimiento, estilo, idioma). Ejemplo: “Complejidad O(√n), nombres en español, comentarios breves.”

• Formato de salida — Archivos, bloques, JSON, orden de secciones.

• Ejemplos mínimos — Incluye unos pocos ejemplos (1-2) que aclaren estándar. Ejemplo: Entrada/salida mini con 1–2 casos.

• Criterios de calidad — Cómo sabrás que está bien (tests, reglas). Ejemplo: “Debe pasar 5 casos de prueba, sin errores de linting”

No siempre usarás los seis. Cuanto más ambigua la tarea, más te conviene completarlos.

Plantilla práctica (con delimitadores y “No hagas”)

Cópiala y rellena los {placeholders}. Los delimitadores ayudan a que el modelo respete el formato.

1[OBJETIVO]
2Quiero: {resultado_concreto}
3
4[CONTEXTO]
5Stack/entorno: {tecnologia_y_version}
6Audiencia/uso: {para_quien}
7Alcance: {incluye} / {excluye}
8
9[RESTRICCIONES]
10- Límite 1: {...}
11- Límite 2: {...}
12- Convenciones: {nombres_idioma_estilo}
13
14[FORMATO DE SALIDA]
15Devuélvelo EXACTAMENTE en este formato:
16--- file: {nombre_archivo_1}
17{contenido_1}
18--- file: {nombre_archivo_2}
19{contenido_2}
20
21[EJEMPLOS (opcionales)]
22Entrada mini:
23{input_ejemplo}
24Salida mini:
25{salida_ejemplo}
26
27[CRITERIOS DE CALIDAD]
28- Debe pasar: {tests_o_casos}
29- No se permiten: {librerias_prohibidas/verbosidad}
30
31[NO HAGAS]
32- No incluyas explicaciones fuera de los bloques.
33- No cambies el formato indicado.

Iteración y mejora continua

Un buen prompt es solo el comienzo; la calidad aparece cuando recorres un bucle corto y consciente. Piensa el flujo así:

• BRIEF: define la intención (usa la plantilla).
• DRAFT: pide el primer borrador (no busques perfección).
• REVIEW: compara salida vs. criterios. Anota qué falta.
• REFINE: modifica una o dos cosas del prompt (no todo a la vez).
• REPEAT: repite hasta cumplir los criterios.

Regla de oro cambios pequeños por iteración. Si tocas todo, no sabrás qué funcionó.

Ejemplo práctico: de la idea al código en 3 iteraciones

La tarea consiste en implementar una función que detecte si un número es primo y acompañarla con pruebas unitarias. Trabajaremos en Node 20 usando Jest, y la solución debe mantener eficiencia O(√n), utilizar nombres y comentarios en español y no depender de librerías externas.

Iteración 1 — Borrador

Prompt (resumen):

Quiero una función `esPrimo(n)` en JavaScript que devuelva true/false.
Stack: Node 20, Jest.
Restricciones: O(√n), sin dependencias externas, nombres en español.
Formato: dos bloques de código, prime.js y prime.test.js.
Criterios: 5 casos de prueba (incluye 1, 2, 17, 18, 9973).

Observación (REVIEW):

• Genera la función y tests, pero no contempla enteros negativos ni no enteros.

Refine:

• Añade una precondición clara: “si n no es entero positivo, devuelve false y documenta el comportamiento”.

Iteración 2 — Precondiciones y cobertura

Prompt (ajuste):

Agrega validaciones: si n no es entero positivo, devuelve false.
Aumenta cobertura a 8 tests (negativos, 0, 1, pares, primos grandes).
Mantén O(√n).

Observación (REVIEW):

• Ahora valida, pero usa un bucle subóptimo (prueba todos los divisores hasta n). Falta optimización con 2 y múltiplos de 2.

Refine:

• Pide optimización: manejo de pares y loop desde 3 con paso 2.

Iteración 3 — Optimización

Prompt (ajuste):

Optimiza: maneja casos (n===2) y pares rápidamente; itera i de 3 a √n con paso 2.
Documenta complejidad y precondiciones en comentarios.

Resultado: Función más eficiente, validaciones correctas, 8 tests pasando. Criterios cumplidos.

Observa como en tres vueltas pequeñas obtuviste una solución clara, eficiente y testeada. No fue suerte, fue proceso.

Buenos hábitos al trabajar con prompts

• Pide menos, más seguido. Divide la tarea en pasos con entregables pequeños.
• Fija el formato. Ahorra tiempo pidiendo la salida con nombres de archivo o secciones.
• Reutiliza prompts. Guarda tus mejores briefs como plantillas.
• Explica el “por qué”. Si pides una restricción (p. ej., O(√n)), di el motivo.
• Evalúa con datos. Cuando puedas, acompaña con tests o ejemplos verificables.

Errores comunes y cómo evitarlos

• Vaguedad: “Hazlo mejor”. Es necesario que digas qué es “mejor”, esto es más rápido, más legible y usas menos memoria.
• Multipedir: tres tareas grandes en un prompt. ¡No lo hagas! Divide en subtareas.
• Sin formato: salida en prosa cuando querías archivos. Pide bloques y nombres.
• Cambiar todo a la vez: si lo haces no sabrás qué ayudó. Es importante que hagas ajustes pequeños por iteración.
• Sin criterios: ¿cómo sabrás si está bien? Pues deberas definir tests, reglas o condiciones.

La calidad en IA no depende de "inspirarte" con la frase perfecta, sino de claridad + proceso. Escribe briefs con intención, fija formatos y criterios, y mejora en ciclos pequeños. Si adoptas esta disciplina, las buenas salidas dejan de ser accidentales y se vuelven consistentes y repetibles.