Has escrito el mismo prompt de atención al cliente tres veces este mes. Modelos diferentes, contextos ligeramente distintos, pero fundamentalmente la misma estructura. Copias y pegas, modificas una o dos variables y esperas que la salida se mantenga consistente.
Aquí es donde la mayoría de los equipos fallan. Tratan los prompts como scripts únicos en lugar de construir plantillas: patrones reutilizables que escalan entre modelos, tareas y equipos sin degradación.
Por qué las Plantillas Importan Más que los Prompts Individuales
Un prompt individual es una solución puntual. Una plantilla es infraestructura.
Cuando codificas un prompt como una plantilla, estás haciendo tres cosas: documentando lo que funciona, creando una superficie de control de versiones y permitiendo la transferencia. Puedes rastrear qué variables importan, realizar pruebas A/B de forma segura y permitir que otra persona ejecute la plantilla sin tener que investigar tu razonamiento.
En AlgoVesta, descubrimos desde el principio que copiar prompts entre ejecuciones de inferencia causaba deriva. Temperatura ligeramente diferente, mensaje del sistema editado «solo esta vez», suposiciones de ventana de contexto integradas. Al tercer mes, tienes seis versiones del mismo prompt y no tienes idea de cuál funciona mejor.
Las plantillas resuelven esto. Imponen consistencia mientras te permiten cambiar lo que se supone que debe cambiar.
La Estructura de la Plantilla: Variables, Instrucciones, Ejemplos
Una plantilla de nivel de producción tiene tres capas:
- Capa de configuración: modelo, temperatura, tokens máximos, rol del sistema
- Capa de instrucciones: definición de la tarea, restricciones, formato de salida
- Capa de variables: marcadores de posición para entradas dinámicas (consulta del usuario, contexto, metadatos)
Así es como se ve en la práctica. Digamos que estás construyendo una plantilla para extraer datos estructurados de las reseñas de los usuarios:
{
"name": "extract_review_sentiment",
"model": "claude-sonnet-4",
"config": {
"temperature": 0.3,
"max_tokens": 500
},
"system_prompt": "Extraes información estructurada de las reseñas de clientes. Genera solo JSON válido. No expliques.",
"user_prompt": "Extrae lo siguiente de esta reseña:\n\nReseña: {{REVIEW_TEXT}}\n\nDevuelve un JSON con las claves: sentiment (positivo/negativo/neutral), main_topic, confidence_score (0-1)\n\nFormato de ejemplo:\n{\"sentiment\": \"positive\", \"main_topic\": \"shipping\", \"confidence_score\": 0.92}"
}
Nota el marcador de posición {{REVIEW_TEXT}}. Cuando invocas la plantilla, lo sustituyes con datos reales. La configuración permanece bloqueada: la temperatura, el modelo, los límites de tokens no varían entre ejecuciones.
Construyendo una Plantilla para Complejidad de Tareas Variable
No todas las plantillas manejan la misma complejidad. La clasificación es sencilla. Pero el razonamiento de varios pasos —analizar documentos, comparar opciones, generar recomendaciones— necesita más estructura.
Para tareas complejas, usa una plantilla en cadena: una secuencia de plantillas más simples que se alimentan mutuamente.
Ejemplo: análisis de documentos con respaldo. La primera plantilla resume. La segunda extrae las afirmaciones clave. La tercera valida contra la fuente. Si la validación falla por debajo de un umbral, vuelve a la extracción con parámetros más estrictos.
templates = {
"summarize_doc": {
"model": "claude-sonnet-4",
"temperature": 0.2,
"system": "Resume el documento en 2-3 frases. Extrae las afirmaciones clave.",
"user": "Documento:\n{{DOC_TEXT}}"
},
"validate_claims": {
"model": "claude-sonnet-4",
"temperature": 0.1,
"system": "Para cada afirmación, verifica si aparece en el texto fuente. Devuelve JSON: {claim, found_in_source: boolean, confidence: 0-1}",
"user": "Fuente:\n{{DOC_TEXT}}\n\nAfirmaciones del resumen:\n{{CLAIMS}}"
}
}
def run_analysis(doc_text):
summary = invoke(templates["summarize_doc"], {"DOC_TEXT": doc_text})
validation = invoke(templates["validate_claims"], {"DOC_TEXT": doc_text, "CLAIMS": summary})
if validation["confidence"] < 0.85:
return {"status": "needs_review", "data": validation}
return {"status": "complete", "data": validation}
Esta estructura te permite controlar la versión de cada paso de forma independiente. Si la validación falla más de lo esperado, cambias solo el prompt del sistema de esa plantilla, no todo el pipeline.
Cuándo Extraer una Plantilla (y Cuándo No)
No todos los prompts deben convertirse en una plantilla. Extrae a una plantilla cuando:
- Ejecutas la misma tarea lógica más de dos veces al mes
- El formato de salida necesita mantenerse consistente entre ejecuciones
- Quieres probar parámetros A/B sin edición manual
- Varias personas necesitan usar el mismo patrón
No crees plantillas si:
- El prompt es experimental: todavía estás descubriendo si funciona
- La tarea es verdaderamente única (no se repetirá en meses)
- El prompt es tan pequeño que la parametrización añade sobrecarga
Un ejemplo concreto: un equipo de marketing utilizó una plantilla para generar líneas de asunto de correo electrónico. Después de dos meses, se dieron cuenta de que la restricción de la plantilla (máximo 60 caracteres) era demasiado rígida para su nuevo estilo de campaña. No podían experimentar fácilmente con variantes de 70 caracteres. Así que se dividieron en dos plantillas: una para formato corto y otra para formato extendido. La sobrecarga se pagó por sí misma de inmediato.
Herramientas y Enfoques para la Gestión de Plantillas
Tienes opciones dependiendo de la escala:
Opción 1: Archivos JSON en control de versiones (ideal para equipos pequeños, <10 plantillas). Almacena las plantillas como JSON en un repositorio, impórtalas en tiempo de ejecución. Simple, con control de versiones, sin dependencia externa. Contras: sin UI, requiere ingeniería para modificar.
Opción 2: Plataformas de gestión de prompts (PromptFlow, LangSmith, Humanloop). Versionado integrado, UI de pruebas A/B, funciones de colaboración. Más fácil para no ingenieros pero introduce dependencia del proveedor.
Opción 3: Capa de envoltura personalizada (equipos con más de 20 plantillas). Una abstracción ligera que carga plantillas desde cualquier fuente (archivos, base de datos, S3), aplica variables, maneja reintentos. Te da control pero requiere mantenimiento.
Empieza con la Opción 1. Si llegas a 15 plantillas y te encuentras gestionando versiones manualmente, pasa a la Opción 2 o 3.
Haz Esto Hoy: Extrae Tu Primera Plantilla
Encuentra un prompt que hayas escrito en las últimas dos semanas y que sepas que ejecutarás de nuevo. Cópialo en una estructura JSON como el ejemplo anterior. Añade marcadores de posición para las partes que cambiarán entre ejecuciones. Confírmalo en el control de versiones.
Ejecútalo una vez con datos reales. Si el formato de salida se mantiene limpio y el resultado es el esperado, tienes tu primera plantilla. A partir de ahí, el patrón se vuelve obvio: detectarás las siguientes cinco inmediatamente.
