Encadenar herramientas de IA en flujos diarios sin tener que escribir prompts constantemente

Usar una sola herramienta de IA es fácil. Lo difícil es encadenar varias para obtener algo que puedas ejecutar a diario sin estar encima. Si en cada paso tienes que volver a escribir las instrucciones y revisar el resultado a mano, no has construido un flujo de trabajo, has construido una tarea pesada. Veamos cómo es un flujo en la práctica, dónde falla el prompting constante y cómo un pequeño orquestador mantiene unidas las piezas.

Qué cuenta como flujo de trabajo

Un flujo de trabajo de IA es una serie de pasos automatizados que usan IA para completar un proceso concreto. Piensa en una cadena de montaje: cada puesto hace una sola tarea y la hace bien, y el producto final sale mejor porque nadie tiene que acarrear piezas de un puesto a otro. En desarrollo de software puede ser revisar código, generar documentación o ejecutar pruebas.

La idea central es partir una tarea grande y difusa en piezas más pequeñas que se puedan automatizar y ajustar por separado.

Dos términos ayudan a no liarse. Un modelo es una representación matemática entrenada de un problema que hace predicciones o toma decisiones a partir de datos. Una herramienta es una aplicación que envuelve uno o varios modelos para hacer un trabajo concreto. Una herramienta de revisión de código, por ejemplo, podría usar un modelo de lenguaje para leer un diff y redactar comentarios.

El objetivo no son las automatizaciones sueltas. Lo que buscas es un proceso coherente en el que varias herramientas se alimenten entre sí y den un buen resultado final. El bloque más simple es una función que llama a una función serverless y devuelve su respuesta:

// Import the required AWS SDK package
import { LambdaClient, InvokeCommand } from "@aws-sdk/client-lambda";
// Create a new Lambda client
const lambdaClient = new LambdaClient({ region: "us-west-2" });
// Define a function to invoke a Lambda function
async function invokeLambda(functionName: string) {
  // Create a new InvokeCommand
  const command = new InvokeCommand({
    FunctionName: functionName,
  });
  // Invoke the Lambda function
  const response = await lambdaClient.send(command);
  // Return the response
  return response;
}

Todos los ejemplos siguientes reutilizan ese helper, así que cada herramienta de IA vive detrás de su propia función y se invoca de la misma manera.

Por qué perjudica el prompting constante

Hacer un prompt significa darle a un modelo una entrada o una indicación para que produzca una salida concreta. Sin una dirección clara, el modelo da respuestas mediocres o, a veces, nada útil. La solución es una entrada clara, breve y bien definida que apunte al modelo exactamente a lo que quieres.

Una analogía lo aclara. Imagina que vas a un restaurante en una ciudad que no conoces y no tienes ni dirección ni indicaciones. Lo más probable es que des vueltas o acabes en otro sitio. Un modelo sin un prompt preciso se comporta igual.

Un prompt puede ser tan simple como un pequeño objeto con el texto:

// Define a function to prompt an AI model
function promptAIModel(promptText: string) {
  // Create a new prompt object
  const prompt = {
    text: promptText,
  };
// Return the prompt object
  return prompt;
}
// Example usage:
const prompt = promptAIModel("Generate a summary of the code review results");
console.log(prompt);

El problema de verdad aparece cuando tienes que hacerlo una y otra vez, a mano, en cada etapa. Los pequeños errores del primer paso pasan al segundo, que los amplifica, y al final el resultado es pobre. Ese efecto bola de nieve se llama error acumulado, y es la razón principal por la que trabajar a base de prompts improvisados no escala. Lo que quieres es escribir los prompts una vez, revisarlos una vez y luego ejecutarlos automáticamente.

Cómo juntar las herramientas

Para reducir los prompts al mínimo, combinas las herramientas mediante un orquestador de flujos. Es una aplicación cuyo trabajo es ejecutar varias herramientas de IA en orden y reunir sus resultados en una sola salida. Aquí un paso hace la revisión de código, el siguiente genera la documentación y el orquestador fusiona ambas respuestas en un único objeto:

// Import the required AWS SDK package
import { LambdaClient, InvokeCommand } from "@aws-sdk/client-lambda";
// Define a function to orchestrate an AI workflow
async function orchestrateWorkflow() {
  // Invoke the first AI tool (e.g., code review)
  const codeReviewResponse = await invokeLambda("code-review-function");
  // Invoke the second AI tool (e.g., documentation generation)
  const documentationResponse = await invokeLambda("documentation-generation-function");
  // Combine the outputs of the two AI tools
  const workflowOutput = {
    codeReview: codeReviewResponse,
    documentation: documentationResponse,
  };
  // Return the workflow output
  return workflowOutput;
}

Si lo conectas así, obtienes un proceso repetible en el que apenas tienes que escribir nada.

Un caso concreto: revisión más documentación

Un uso real habitual es la revisión automática de código combinada con la generación de documentación. Intervienen tres partes: una herramienta de revisión, una de documentación y un orquestador que las coordina. Con Claude encargado de la revisión, Cursor generando la documentación y una función Lambda que encadena las llamadas, el código de unión queda así:

// Define a function to integrate Claude, Cursor, and Lambda into an AI workflow
async function integrateAIWorkflow() {
  // Invoke the Claude AI tool for code review
  const claudeResponse = await invokeLambda("claude-function");
// Invoke the Cursor AI tool for documentation generation
  const cursorResponse = await invokeLambda("cursor-function");
  // Use Lambda to orchestrate the workflow
  const lambdaResponse = await invokeLambda("workflow-orchestrator-function");
  // Return the workflow output
  return lambdaResponse;
}

El mismo patrón sirve mucho más allá de la programación. El análisis de datos, los informes y muchas otras tareas se pueden dividir en etapas que se pasan el trabajo unas a otras.

Diseñar el tuyo

Tres hábitos hacen que un flujo sea fiable.

1. Define primero objetivos claros. Escribe qué debe producir el flujo, porque eso condiciona todas las demás decisiones.
2. Elige herramientas adecuadas para cada etapa. Escógelas por la tarea concreta y no por la marca, y no obligues a una sola herramienta a hacerlo todo.
3. Prueba y valida el conjunto. Comprueba que la salida es buena y que los errores no se amplifican en silencio entre pasos.

Una función de diseño puede recoger las tres cosas: los objetivos, la lista de herramientas y una ejecución real del orquestador para validarlo.

// Define a function to design an AI workflow
async function designWorkflow() {
  // Define clear goals and objectives for the workflow
  const workflowGoals = {
    objective: "Automate code review and documentation generation",
  };
// Choose the right AI tools for the workflow
  const aiTools = ["Claude", "Cursor", "Lambda"];
  // Test and validate the workflow
  const workflowOutput = await orchestrateWorkflow();
  // Return the workflow design
  return {
    goals: workflowGoals,
    tools: aiTools,
    output: workflowOutput,
  };
}

Si sigues esos pasos, acabas con un proceso que da resultados de calidad con pocos errores.

Resumen rápido

• Un flujo de trabajo es una cadena de pasos automatizados que completa un proceso definido.
• El valor está en un proceso coherente que une varias herramientas, no en automatizar tareas sueltas por separado.
• El prompting manual constante provoca errores acumulados y resultados más flojos.
• Un orquestador que combina herramientas reduce la cantidad de prompts que necesitas.
• Empieza con objetivos claros, elige herramientas que encajen en cada etapa y prueba la ejecución completa.
• El enfoque funciona en desarrollo de software, análisis de datos y muchos otros ámbitos.

Antes de fiarte del código de ejemplo en producción, contrástalo con la documentación oficial de cada herramienta, porque los detalles de los SDK cambian.