Claude Architect · Lección

Pipelines fijos frente a descomposición adaptativa

Encadene prompts para pasos conocidos y use un enfoque adaptativo para tareas abiertas.

Lección 1 de 413 pasos

Pipelines fijos frente a descomposición adaptativa es una lección gratuita de Claude Architect en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Claude Architect, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Claude Architect incluye 4 lecciones en total.

Dos formas de descomponer el trabajo

Cuando una tarea es demasiado grande para un solo prompt, debe descomponerla. Hay dos estrategias fundamentales, y elegir la adecuada es una competencia esencial de arquitectura.

  • Pipeline fijo (encadenamiento de prompts): se codifica una secuencia de pasos conocida. El paso 1 alimenta al paso 2, que alimenta al paso 3.
  • Descomposición adaptativa: el modelo decide qué hacer a continuación según lo que descubre y repite el proceso hasta alcanzar el objetivo.

Regla práctica: use pipelines fijos para pasos secuenciales conocidos y descomposición adaptativa para investigaciones abiertas. Esta lección precisa esa decisión.

Pipeline fijo = encadenamiento de prompts

Un pipeline fijo no es más que un encadenamiento de prompts: usted orquesta una secuencia determinista en su propio código. Conoce los pasos de antemano, así que los conecta explícitamente. Cada llamada realiza una tarea concreta y su salida se convierte en la entrada de la siguiente llamada.

Como usted controla el orden, el flujo es predecible, fácil de depurar y sencillo de analizar. No hay ramificaciones dirigidas por el modelo sobre qué hacer a continuación, sino únicamente el trabajo propio de cada paso.

# Fixed pipeline: extract -> classify -> summarize
from anthropic import Anthropic
client = Anthropic()

def step(system, user):
    r = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=1024,
        system=system,
        messages=[{"role": "user", "content": user}],
    )
    return r.content[0].text

entities = step("Extract entities as JSON.", document)
category = step("Classify this record.", entities)
summary  = step("Write a one-line summary.", category)

Cuándo conviene un pipeline fijo

Opte por un pipeline fijo cuando el trabajo tenga una estructura estable y conocida:

  • Los pasos son los mismos en cada ejecución (extraer, después validar y después dar formato).
  • El orden importa y rara vez cambia.
  • Desea costes y latencia predecibles, además de una depuración sencilla.
  • Cada etapa tiene una responsabilidad clara y acotada.

Un ejemplo clásico es la extracción de datos estructurados. Extraiga los campos, ejecute después una pasada de validación y reintento y, por último, añada la procedencia. Siempre realiza esas tres tareas, en ese orden; por tanto, encadénelas.

Descomposición adaptativa = dirigida por el modelo

La descomposición adaptativa delega la planificación en el modelo. Usted le proporciona herramientas y un objetivo; el modelo inspecciona los resultados y elige la siguiente acción. Este es el bucle agéntico: envíe una solicitud, inspeccione stop_reason y, si es tool_use, ejecute las herramientas, añada los resultados al historial y repita hasta end_turn.

No puede conectar la ruta de antemano porque no la conoce: depende de lo que revele cada paso.

# Adaptive: the model decides which tool to call next
while True:
    resp = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=2048,
        tools=tools,
        messages=messages,
    )
    if resp.stop_reason == "tool_use":
        results = run_tools(resp)          # execute requested tools
        messages.append({"role": "assistant", "content": resp.content})
        messages.append({"role": "user", "content": results})
        continue
    break  # terminate on stop_reason, never by parsing text

Cuándo conviene la descomposición adaptativa

Elija la descomposición adaptativa para investigaciones abiertas cuya ruta no pueda conocerse de antemano:

  • Depuración a partir de un síntoma impreciso: busca con grep, lee y después vuelve a buscar usos según lo que encuentra.
  • Investigación en varias fuentes, donde las consultas de seguimiento dependen de las respuestas anteriores.
  • Atención al cliente, donde la siguiente acción depende del resultado de una consulta.

Aquí, las ramificaciones SON el trabajo. Un pipeline rígido omitiría rutas o acabaría convertido en una cantidad inmanejable de condicionales.

Terminar con stop_reason, no con el texto

El error más común en un bucle adaptativo durante el examen es terminarlo buscando en el texto del modelo palabras como «listo» o «terminado». No lo haga. Las decisiones las dirige el modelo; termine según el stop_reason de la API.

El bucle termina cuando stop_reason es end_turn. Mientras sea tool_use, debe continuar. Un límite de iteraciones es únicamente una red de seguridad, nunca el mecanismo de parada principal. Reserve el control codificado para las garantías, no para decidir cuándo se ha completado conceptualmente el trabajo.

# WRONG: parsing text for completion
if "done" in resp.content[0].text.lower():
    break

# RIGHT: drive on stop_reason; cap is only a safety net
MAX_STEPS = 25
for _ in range(MAX_STEPS):
    resp = client.messages.create(...)
    if resp.stop_reason != "tool_use":
        break  # end_turn / max_tokens / stop_sequence

Híbrido: pipelines con etapas adaptativas

Los sistemas reales combinan ambos enfoques. El flujo externo suele ser un pipeline fijo, pero una de sus etapas puede ser un bucle agéntico adaptativo. Así obtiene la previsibilidad del encadenamiento en el nivel macro y la flexibilidad allí donde realmente la necesita.

Ejemplo: un pipeline de extracción cuya etapa intermedia es un agente adaptativo de «resolución de ambigüedades» que puede llamar a herramientas de consulta un número desconocido de veces, rodeado por una etapa determinista de validación y formato antes y después.

# Outer = fixed chain; one stage = adaptive loop
raw      = extract_stage(document)        # fixed
resolved = adaptive_resolver(raw)         # agentic loop inside
final    = validate_and_format(resolved)  # fixed

Revisión de código en varias pasadas: una decisión de descomposición

La descomposición no se limita a pipelines frente a bucles: también consiste en dividir una tarea para proteger la atención del modelo. La revisión de código en varios archivos es el caso paradigmático.

Una sola pasada por muchos archivos diluye la atención y hace que se pasen por alto tanto los errores locales como los problemas de integración. La solución es una descomposición deliberada: primero, una pasada local por archivo y, después, una pasada independiente de integración entre archivos. Dos pasadas centradas superan a una sola pasada sin enfoque.

# Decompose review into focused passes
for f in changed_files:
    review_local(f)          # pass 1: per-file, focused

review_cross_file(changed_files)  # pass 2: integration concerns

Los coordinadores descomponen de forma adaptativa

En un sistema multiagente de tipo hub-and-spoke, el coordinador descompone el objetivo, delega tareas a subagentes y, después, agrega los resultados. Se trata de una descomposición adaptativa en la capa de orquestación: el coordinador decide cómo dividir el trabajo en función de la solicitud.

Importante: los subagentes no heredan el historial de conversación del coordinador. Cada solicitud a un subagente debe incluir explícitamente todo el contexto necesario. Varias llamadas a Task en una misma respuesta se ejecutan en paralelo, lo que resulta útil cuando los subproblemas son independientes.

# Coordinator delegates with explicit, self-contained context
subagent_prompt = f"""You are researching ONE sub-topic.
Context (do not assume shared history):
  Goal: {goal}
  Sub-topic: {subtopic}
  Constraints: {constraints}
Return findings with source citations."""

Sesiones: reanudar, bifurcar o empezar de cero

El trabajo adaptativo suele abarcar varias sesiones. Claude Code le ofrece --resume <name> para continuar una sesión con nombre y fork_session para crear una rama desde un punto compartido y explorar alternativas en paralelo.

Pero tenga cuidado: los resultados de herramientas reanudados pueden estar obsoletos si la base de código cambió desde entonces. A veces, una sesión nueva iniciada con un resumen estructurado es mejor que reanudar: obtiene el estado actual junto con el contexto sintetizado, sin arrastrar resultados de herramientas desactualizados.

# Continue a named session
claude --resume refactor-auth

# Branch to explore an alternative path
# fork_session creates a sibling from the shared point

# When code moved on, prefer a fresh session + summary
claude -p "Here is a structured summary of prior work: ..."

Una lista de comprobación para decidir

Antes de construir, pregúntese:

  • ¿Conozco de antemano los pasos y siguen un orden fijo? -> canalización fija / encadenamiento de prompts.
  • ¿Depende el siguiente paso de lo que revelen los pasos anteriores? -> bucle agéntico adaptativo.
  • ¿La mayor parte es fija, pero hay una etapa incierta? -> enfoque híbrido: encadene el flujo exterior e incorpore un bucle adaptativo.
  • ¿Está revisando muchos archivos? -> descomponga el trabajo en una pasada por archivo y, después, una pasada entre archivos.

Y siempre: termine los bucles adaptativos según stop_reason, usando los límites de iteraciones solo como mecanismo de seguridad.

Comprobación rápida

Una decisión basada en un escenario para elegir una estrategia de descomposición.

Resumen

Ideas clave:

  • Canalización fija (encadenamiento de prompts) para pasos conocidos y ordenados: predecible, fácil de depurar y económica.
  • Descomposición adaptativa para investigaciones abiertas en las que el siguiente paso depende de lo que descubra.
  • El enfoque híbrido es habitual: un flujo exterior fijo con una etapa adaptativa incorporada.
  • Termine siempre los bucles adaptativos según stop_reason (end_turn); los límites de iteraciones son un mecanismo de seguridad, nunca el criterio principal de parada. Nunca analice el texto en busca de "done."
  • Para revisar varios archivos, descomponga el trabajo en una pasada por archivo y, después, una pasada independiente entre archivos.
  • Los subagentes no heredan el historial: transmita el contexto explícitamente. Reanude las sesiones con cuidado; una sesión nueva con un resumen estructurado puede ser mejor que resultados de herramientas reanudados y obsoletos.
Gratis para empezar

Aprende Python con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos
26
Lecciones
104

Preguntas frecuentes

¿La lección «Pipelines fijos frente a descomposición adaptativa» es gratis?

Sí — el texto completo de «Pipelines fijos frente a descomposición adaptativa» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Claude Architect, actualiza a CoddyKit PRO. El curso de Claude Architect incluye 4 lecciones en total.

¿Qué aprenderé en «Pipelines fijos frente a descomposición adaptativa»?

Encadene prompts para pasos conocidos y use un enfoque adaptativo para tareas abiertas. Practicas Claude Architect con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Claude Architect?

No se requiere experiencia previa. Claude Architect en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Pipelines fijos frente a descomposición adaptativa»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Claude Architect?

Sí. Cada lección de Claude Architect incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Pipelines fijos frente a descomposición adaptativa
  2. Descomposición en varias pasadas
  3. Gestión de sesiones
  4. Contexto obsoleto y cómo empezar de cero
← Volver a Claude Architect