¿Quién escribe el código cuando los agentes se unen al flujo de trabajo?
Asistentes de codificación de mapas que van desde la autocompletación hasta los enjambres, y que relacionan el nivel de correspondencia con el radio de explosión, las pruebas y las etapas de revisión.
Las herramientas de programación con IA ya no se limitan al autocompletado. Incluyen programadores en pareja reactivos, agentes de tareas que ejecutan tickets, agentes autónomos de proyecto que gestionan ramas, y enjambres experimentales donde varios agentes se critican y corrigen mutuamente. La pregunta importante no es qué marca instalar, sino qué nivel se ajusta al riesgo del cambio.
De autocompletado a autonomía
Los asistentes iniciales completaban la línea debajo del cursor. Los agentes más recientes abren archivos, ejecutan pruebas y crean solicitudes de integración. La autonomía aumenta con el alcance del impacto. Lo mismo ocurre con la profundidad de las revisiones, los entornos aislados y la claridad del objetivo que se les asigna.
Nivel 1: Programadores en pareja con IA
Herramientas de autocompletado reactivo y chat dentro del IDE. Usted controla cada commit. Ideales para código genérico, renombramientos y explicar código desconocido. Son débiles en refactorizaciones de múltiples archivos sin orientación.
# Conceptual representation of a Tier 3 agent's execution loop
def execute_project_goal(goal: str):
plan = agent.generate_plan(goal)
while not plan.is_complete():
action = plan.get_next_action()
result = workspace.run(action) # Runs commands, edits files
if result.has_errors():
plan.replan(result.logs) # Self-correction loop
else:
plan.mark_step_done()
Nivel 2: Agentes específicos para tareas
Ejecutores orientados a objetivos: “añadir registro de actividades a este manejador”, “escribir pruebas para este módulo”. Planifican ciclos breves con herramientas y se detienen cuando se cumple la meta. Aún requieren aprobación humana para la integración.
import time
from typing import Dict, Any
def run_agent_loop(task_prompt: str, max_iterations: int = 15) -> bool:
# Initialize the agent's state, workspace, and execution context
state: Dict[str, Any] = {
"task": task_prompt,
"workspace_files": get_project_files(),
"history": [],
"completed": False
}
for step in range(max_iterations):
# 1. Perception: Observe current system state and tool outputs
observation = observe_environment(state)
# 2. Planning: Reason through the current state to generate a thought and next action
thought, action = LLM_reasoning_engine(state, observation)
state["history"].append({"step": step, "thought": thought, "action": action})
if action.name == "task_complete":
print(f"Task successfully completed in {step} steps.")
return True
# 3. Action: Execute the tool and capture the side effects
try:
action_result = execute_action(action)
state = update_state(state, action_result)
except Exception as execution_error:
# Feed the error back to the LLM to allow for self-correction
state = update_state(state, {"error": str(execution_error)})
time.sleep(1) # Implement rate limiting and token management
print("Agent failed: Reached maximum iteration budget.")
return False
Nivel 3: agentes de proyecto autónomos
Ingenieros de extremo a extremo para un proyecto definido: estructuración, implementación, pruebas e iteraciones. Necesitan pruebas de aceptación claras y un entorno aislado. Sin pruebas, no funcionan bien.
import subprocess
import json
import sys
def execute_agentic_workflow(specification_path: str) -> bool:
"""
Orchestrates an agent by feeding it a structured specification,
applying the generated code changes, and running unit tests to verify correctness.
"""
# Step 1: Load the structured technical specification
with open(specification_path, "r") as f:
spec = json.load(f)
print(f"🤖 Agent starting task: {spec['task_id']} - {spec['description']}")
# Step 2: Agent generates code based on spec (simulated here)
generated_code_diff = simulate_agent_generation(spec)
# Step 3: Apply the generated patches to the codebase
if not apply_patch(generated_code_diff):
print("❌ Critical: Agent-generated patch failed to apply cleanly.")
return False
# Step 4: Run automated validation suites
print("🧪 Running verification test suite...")
test_result = subprocess.run(["pytest", "tests/test_agent_features.py"], capture_output=True, text=True)
if test_result.returncode == 0:
print("✅ Success: Agent changes verified successfully.")
return True
else:
print("❌ Failure: Automated tests failed. Raw stderr output:")
print(test_result.stderr)
return False
def simulate_agent_generation(spec: dict) -> str:
# Simulates returning a git patch block matching the spec constraints
return "diff --git a/app.py b/app.py..."
def apply_patch(diff: str) -> bool:
# Logic to apply git patch
return True
if __name__ == "__main__":
execute_agentic_workflow("specs/new_feature_spec.json")
Nivel 4: enjambres de agentes
Redes colaborativas de múltiples agentes: investigador, implementador, revisor. Potentes pero costosos. Los errores de coordinación se convierten en el nuevo modo de fallo.
+----------------+ +-----------------+ +-----------------+ +-----------------+
| Define | ---> | Prompt | ---> | Test | ---> | Verify |
| (Requirements | | (Context, Specs | | (Automated | | (Human Approves |
| & Interfaces) | | & Constraints)| | Suites & Runs) | | Final Diffs) |
+----------------+ +-----------------+ +-----------------+ +-----------------+
Anatomía de un agente de programación
Percepción (herramientas de repositorio), planificación (descomposición de tareas), acción (ediciones/comandos) y memoria (papeles de trabajo, contexto de PR). La falta de cualquiera de estos elementos hace que el nivel colapse.
Generated by AI Agent: Provisions a secure, auto-scaling AWS ECS Fargate service
resource "aws_ecs_task_definition" "app" {
family = "production-api"
requires_compatibilities = ["FARGATE"]
network_mode = "awsvpc"
cpu = "256"
memory = "512"
container_definitions = jsonencode([{
name = "api-service"
image = "backend-service:latest"
essential = true
portMappings = [{
containerPort = 8080
hostPort = 8080
}]
}])
}
Elegir un nivel
Alinee el nivel de correspondencia con la criticidad del repositorio, la solidez de las pruebas y el grado de reversibilidad del cambio. Prefiera los niveles 1–2 en las rutas de pago hasta que existan herramientas de evaluación adecuadas. Utilice el nivel 3 cuando los controles de integración sean estrictos y el entorno de pruebas no pueda acceder a secretos de producción.
# safe_executor.py
import ast
# An allowlist of pre-approved libraries prevents hallucinated dependency injection.
ALLOWED_PACKAGES = {"requests", "pandas", "numpy", "json", "pydantic"}
def verify_agent_imports(agent_code: str) -> bool:
"""Parses agent code into an AST to audit imports before execution."""
try:
tree = ast.parse(agent_code)
for node in ast.walk(tree):
if isinstance(node, ast.Import):
for alias in node.names:
base_package = alias.name.split('.')[0]
if base_package not in ALLOWED_PACKAGES:
raise SecurityError(f"Blocked unapproved import: {alias.name}")
elif isinstance(node, ast.ImportFrom) and node.module:
base_package = node.module.split('.')[0]
if base_package not in ALLOWED_PACKAGES:
raise SecurityError(f"Blocked unapproved import from: {node.module}")
return True
except (SyntaxError, SecurityError) as e:
print(f"Safety Gate Tripped: {e}")
return False
class SecurityError(Exception):
pass
# Example of agent output containing a hallucinated or malicious library.
untrusted_code = "import requests\nimport fast_json_validator_fake_pkg"
is_safe = verify_agent_imports(untrusted_code)
print(f"Is code safe to execute? {is_safe}") # Prints: Is code safe to execute? False
Hábitos de flujo de trabajo que mantienen a los humanos al mando
Escriba comprobaciones de aceptación antes de invocar a un agente. Exija que las diferencias se presenten en bloques revisables. Registre cada llamada a una herramienta. Prohíba el uso de shells sin restricciones en hosts sensibles. Considere la velocidad del agente como un indicador de riesgo cuando aumenten las tasas de defectos.
El futuro de “quién escribe el código” reside en la autoría compartida con controles explícitos, y no en commits sin supervisión directa hacia la rama principal. Mantengan los fixtures en buen estado, midan cada etapa por separado y se nieguen a lanzar basándose únicamente en la intuición, cuando el próximo lanzamiento podría reintroducir el mismo modo de fallo silencioso bajo un nombre diferente. Mantengan los fixtures en buen estado, midan cada etapa por separado y se nieguen a lanzar basándose únicamente en la intuición, cuando el próximo lanzamiento podría reintroducir el mismo modo de fallo silencioso bajo un nombre diferente. Mantengan los fixtures en buen estado, midan cada etapa por separado y se nieguen a lanzar basándose únicamente en la intuición, cuando el próximo lanzamiento podría reintroducir el mismo modo de fallo silencioso bajo un nombre diferente. Mantengan los fixtures en buen estado, midan cada etapa por separado y se nieguen a lanzar basándose únicamente en la intuición, cuando el próximo lanzamiento podría reintroducir el mismo modo de fallo silencioso bajo un nombre diferente. Mantengan los fixtures en buen estado, midan cada etapa por separado y se nieguen a lanzar basándose únicamente en la intuición, cuando el próximo lanzamiento podría reintroducir el mismo modo de fallo silencioso bajo un nombre diferente.
Ase puede volver a introducir el mismo modo de fallo silencioso bajo un nombre nuevo. Mantenga los dispositivos en buen estado, mida cada etapa por separado y se niegue a enviarlos basándose únicamente en intuiciones, ya que la próxima versión puede volver a introducir el mismo modo de fallo silencioso bajo un nombre nuevo. Mantenga los dispositivos en buen estado, mida cada etapa por separado y se niegue a enviarlos basándose únicamente en intuiciones, ya que la próxima versión puede volver a introducir el mismo modo de fallo silencioso bajo un nombre nuevo. Mantenga los dispositivos en buen estado, mida cada etapa por separado y se niegue a enviarlos basándose únicamente en intuiciones, ya que la próxima versión puede volver a introducir el mismo modo de fallo silencioso bajo un nombre nuevo. Mantenga los dispositivos en buen estado, mida cada etapa por separado y se niegue a enviarlos basándose únicamente en intuiciones, ya que la próxima versión puede volver a introducir el mismo modo de fallo silencioso bajo un nombre nuevo. Mantenga los dispositivos en buen estado, mida cada etapa por separado y se niegue a enviarlos basándose únicamente en intuiciones, ya que la próxima versión puede volver a introducir el mismo modo de fallo silencioso.Mantenga los dispositivos en buen estado, mida cada etapa por separado y se niegue a lanzar algo basándose únicamente en la intuición, cuando el próximo lanzamiento podría reintroducir el mismo modo de fallo silencioso bajo un nombre diferente.Mantenga los dispositivos en buen estado, mida cada etapa por separado, y se niegue a lanzar basándose únicamente en intuiciones cuando la próxima versión pueda reintroducir el mismo modo de fallo silencioso bajo un nombre diferente.Mantenga los dispositivos en buen estado, mida cada etapa por separado, y se niegue a entregar el producto basándose únicamente en intuiciones cuando la próxima versión pueda reintroducir el mismo modo de fallo silencioso bajo un nombre diferente.Introduce el mismo modo de fallo silencioso bajo un nombre nuevo. Mantenga los dispositivos en buen estado, mida cada etapa por separado y se niegue a enviarlos basándose únicamente en intuiciones, ya que la próxima versión podría reintroducir el mismo modo de fallo silencioso bajo un nombre nuevo. Mantenga los dispositivos en buen estado, mida cada etapa por separado y se niegue a enviarlos basándose únicamente en intuiciones, ya que la próxima versión podría reintroducir el mismo modo de fallo silencioso bajo un nombre nuevo. Mantenga los dispositivos en buen estado, mida cada etapa por separado y se niegue a enviarlos basándose únicamente en intuiciones, ya que la próxima versión podría reintroducir el mismo modo de fallo silencioso bajo un nombre nuevo. Mantenga los dispositivos en buen estado, mida cada etapa por separado y se niegue a enviarlos basándose únicamente en intuiciones, ya que la próxima versión podría reintroducir el mismo modo de fallo silencioso bajo un nombre nuevo. Mantenga los dispositivos en buen estado, mida cada etapa por separado y se niegue a enviarlos basándose únicamente en intuiciones, ya que la próxima versión podría reintroducir el mismo modo de fallo silencioso bajoUn nombre nuevo. Mantenga los dispositivos en buen estado, mida cada etapa por separado y se niegue a lanzar algo basándose únicamente en la intuición, cuando el próximo lanzamiento podría reintroducir el mismo modo de fallo silencioso bajo un nombre diferente. Mantenga los dispositivos en buen estado, mida cada etapa por separado y se niegue a lanzar algo basándose únicamente en la intuición, cuando el próximo lanzamiento podría reintroducir el mismo modo de fallo silencioso bajo un nombre diferente. Mantenga los dispositivos en buen estado, mida cada etapa por separado y se niegue a lanzar algo basándose únicamente en la intuición, cuando el próximo lanzamiento podría reintroducir el mismo modo de fallo silencioso bajo un nombre diferente. Mantenga los dispositivos en buen estado, mida cada etapa por separado y se niegue a lanzar algo basándose únicamente en la intuición, cuando el próximo lanzamiento podría reintroducir el mismo modo de fallo silencioso bajo un nombre diferente. Mantenga los dispositivos en buen estado, mida cada etapa por separado y se niegue a lanzar algo basándose únicamente en la intuición, cuando el próximo lanzamiento podría reintroducir el mismo modo de fallo silencioso bajo un nombre diferente. Mantenga los dispositivos en buen estado, mida cada etapa por separado.Mantenga los dispositivos en buen estado, mida cada etapa por separado, y se niegue a enviar el producto basándose únicamente en sensaciones cuando la próxima versión pueda reintroducir el mismo modo de fallo silencioso bajo un nombre diferente.Lecturas relacionadas
- Habilidades más MCP: las herramientas brindan capacidades prácticas, mientras que las habilidades enseñan el flujo de trabajo — MCP expone las capacidades; el paquete Skills proporciona flujos de trabajo y directrices para que los agentes sepan qué herramientas usar, en qué orden y cuándo solicitar aprobación.