Ir al contenido principal
Español— Elegir un idioma
Menú

Meta-prompting: Generación de prompts óptimos

Lección 5 de 16 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Meta-prompting: Generación de prompts óptimos
  2. El principio
  3. Generar a partir de especificaciones
  4. Mejorar un prompt existente
  5. Generar variantes para comparar
  6. Ensamblar la canalización
  7. Lo que el meta-prompting no hará por ti
  8. Puntos clave

Lección actualizada el 3 de noviembre de 2026 según la documentación de OpenAI: los parámetros temperature y top_p solo se aceptan con un esfuerzo de razonamiento de none, mientras que los modelos GPT-5.6 razonan por defecto (medium). Por tanto, las llamadas que establezcan estos parámetros deben especificar reasoning={"effort": "none"} (API de Responses) o reasoning_effort="none" (Chat Completions). Fuentes: Uso de GPT-6 · GPT-5.6 Terra.

Meta-prompting: Generación de prompts óptimos

El meta-prompting consiste en utilizar un LLM para generar o mejorar prompts. En lugar de redactar manualmente cada instrucción, describes la tarea y pides al modelo que produzca el prompt óptimo. El ahorro de tiempo es inmediato, pero el verdadero beneficio reside en otro lugar: esta técnica saca a la luz formulaciones que quizás nunca hubieras considerado, ya que los desarrolladores suelen escribir prompts con los mismos reflejos y puntos ciegos.

El principio

Un buen prompt es un programa escrito en lenguaje natural. Al igual que con cualquier programa, a veces es más eficiente generarlo que teclearlo a mano; tampoco escribes tus migraciones de base de datos carácter por carácter. El meta-prompting aprovecha el hecho de que, durante su entrenamiento, el modelo se encontró con una vasta cantidad de prompts y debates sobre qué los hace efectivos. El ejemplo siguiente solicita un prompt de sistema para clasificar tickets de soporte. Dos detalles merecen tu atención: la especificación es precisa hasta los valores de categoría, y la última línea exige una salida en bruto sin comentarios adjuntos, garantizando que el resultado sea directamente utilizable por el código.

from openai import OpenAI

client = OpenAI()

meta_prompt = """Eres un experto en ingeniería de prompts.

Genera un prompt de sistema optimizado para la siguiente tarea:
- Objetivo: Clasificar tickets de soporte al cliente
- Categorías: bug, feature_request, question, billing
- Salida: JSON con "category", "priority" (1-5), "summary"
- Restricciones: Respuesta en francés, máx. 100 tokens

El prompt debe incluir:
1. Un rol claro
2. Las categorías con criterios de clasificación
3. El formato de salida exacto con un ejemplo
4. Casos límite (ticket ambiguo, fuera de categoría)

Devuelve SOLO el prompt de sistema, sin explicaciones."""

response = client.responses.create(
    model="gpt-5.6-sol",
    reasoning={"effort": "none"},  # temperature requiere effort none
    input=meta_prompt,
    temperature=0.7
)

generated_prompt = response.output_text
print(generated_prompt)

Generar a partir de especificaciones

El primer patrón industrializa lo que acabas de hacer manualmente: describes tus requisitos como restricciones funcionales y el modelo produce el prompt correspondiente. Al envolver el meta-prompt en una función, obtienes un generador reutilizable para cada tarea de tu aplicación. El efecto secundario es significativo: los prompts escritos por cinco desarrolladores diferentes dejan de tener cinco estilos distintos, lo que simplifica considerablemente la revisión de código.

def generate_prompt(objective: str, constraints: list[str],
                   output_format: str) -> str:
    """Genera un prompt de sistema a partir de especificaciones."""
    spec = f"""Genera un prompt de sistema para esta tarea:

Objetivo: {objective}

Restricciones:
{chr(10).join(f'- {c}' for c in constraints)}

Formato de salida esperado:
{output_format}

Incluye un ejemplo concreto de entrada/salida.
Devuelve solo el prompt, sin comentarios."""

    response = client.responses.create(
        model="gpt-5.6-sol",
        reasoning={"effort": "none"},  # temperature requiere effort none
        input=spec,
        temperature=0.5
    )
    return response.output_text

Mejorar un prompt existente

El segundo patrón parte de un prompt ya en producción y un defecto observado en el entorno real. En lugar de reescribirlo por completo —lo que corre el riesgo de romper lo que funcionaba perfectamente—, proporcionas el prompt actual junto con una descripción precisa del problema: «a veces responde en inglés» o «inventa números de pedido cuando falta la referencia». La instrucción «mantén lo que funciona» es la parte decisiva aquí. Sin ella, el modelo refactoriza espontáneamente todo el conjunto y te entrega un prompt nuevo que ya no entiendes.

def improve_prompt(current_prompt: str, problem: str) -> str:
    """Mejora un prompt existente basándose en comentarios."""
    meta = f"""Aquí tienes un prompt de sistema que tiene un problema:

--- PROMPT ACTUAL ---
{current_prompt}
--- FIN ---

Problema observado: {problem}

Reescribe este prompt para solucionar este problema.
Mantén lo que funciona; modifica solo lo necesario.
Devuelve solo el prompt mejorado."""

    response = client.responses.create(
        model="gpt-5.6-sol",
        reasoning={"effort": "none"},  # temperature requiere effort none
        input=meta,
        temperature=0.3
    )
    return response.output_text

Generar variantes para comparar

El tercer patrón genera múltiples versiones del mismo prompt: objetivo constante, pero redacción y estructuras divergentes. Esta es la materia prima para las pruebas A/B que cubriremos en la Lección 15; sin variantes, simplemente no tienes nada que comparar. La temperatura alta aquí no es un descuido: sirve precisamente para crear diversidad entre versiones, mientras que una temperatura baja te daría tres reformulaciones casi idénticas.

def generate_variants(base_prompt: str, n: int = 3) -> list[str]:
    """Genera n variantes de un prompt."""
    meta = f"""Aquí tienes un prompt de sistema:

{base_prompt}

Genera {n} variantes de este prompt que:
- Mantengan el mismo objetivo
- Utilicen una redacción diferente
- Varíen la estructura (listas frente a párrafos, orden de las instrucciones)

Separa cada variante con "---VARIANT---"."""

    response = client.responses.create(
        model="gpt-5.6-sol",
        reasoning={"effort": "none"},  # temperature requiere effort none
        input=meta,
        temperature=0.9
    )
    return response.output_text.split("---VARIANT---")

Ensamblar la canalización

Estos tres bloques de construcción se encadenan de forma natural: genera un prompt a partir del objetivo, produce variantes y ejecuta cada variante en un conjunto de pruebas representativo para juzgarlas basándote en evidencias y no en estimaciones.

def meta_prompt_pipeline(objective: str, tests: list[str]) -> str:
    """Canalización completa de meta-prompting."""

    # 1. Generar 3 variantes
    variants = generate_variants(
        generate_prompt(objective, [], "free text"), n=3
    )

    # 2. Probar cada variante
    scores = []
    for i, prompt in enumerate(variants):
        results = []
        for test in tests:
            response = client.responses.create(
                model="gpt-5.6-terra",
                reasoning={"effort": "none"},  # temperature requiere effort none
                instructions=prompt.strip(),
                input=test,
                temperature=0.2
            )
            results.append(response.output_text)
        scores.append((i, results))

    # 3. Evaluar (adaptar a tus criterios)
    print("Compara los resultados y selecciona la mejor variante.")
    return variants, scores

Lo que el meta-prompting no hará por ti

El modelo tiene una fuerte tendencia a la sobreoptimización: el prompt que devuelve suele ser demasiado verboso o estar demasiado calibrado para los ejemplos que proporcionaste, lo que hace que se comporte mal en casos ligeramente diferentes. Por tanto, la revisión humana es obligatoria antes de cualquier despliegue, si no es para verificar que no se hayan inventado reglas de negocio por el camino; un modelo que completa una especificación incompleta siempre lo hace de buena fe, y a veces incorrectamente. Vigila también el coste: cada iteración consume tokens, y un bucle de mejora sin límites puede ejecutarse durante mucho tiempo sin converger nunca. Establece el número máximo de iteraciones en tu código, no en tu disciplina personal.

Para dominar esta técnica, toma una tarea real de tu dominio, escribe su especificación completa (objetivo, restricciones, formato), genera tres variantes, pruébalas en cinco casos de tu entorno de producción y, finalmente, refina la mejor a mano. Casi siempre es ese toque manual final el que marca la diferencia entre un prompt decente y uno que estás listo para poner en producción.

Puntos clave

  • El meta-prompting utiliza el LLM como generador de prompts
  • Tres patrones: generación, mejora iterativa, variantes
  • Valida siempre los prompts generados con pruebas concretas
  • Combina la generación automática con el ajuste manual
  • Establece límites para evitar bucles de iteración costosos