# Flujos de trabajo

> Los 16 flujos de trabajo integrados de AI CodeOps y sus pasos, y cómo lanzar uno, programarlo, volver a ejecutarlo, cancelarlo y continuar una sesión terminada con seguimientos.

Fuente: https://aicodeops.dev/es/docs/workflows · Última actualización: 2026-10-18

Un flujo de trabajo es la receta que sigue una sesión: una lista fija de pasos, cada uno ejecutado por un [agente](https://aicodeops.dev/es/docs/agents). Eliges el flujo de trabajo al lanzar una [sesión](https://aicodeops.dev/es/docs/sessions). Elijas el que elijas, una sesión que escribe código termina de la misma forma: se ejecutan tus pruebas, la revisión con IA registra hallazgos y una persona aprueba antes de que se abra un pull request.

## Los flujos de trabajo integrados

Explóralos en **Develop → Workflows**, en el **Workflow Catalog**.

### Desarrollar y cambiar código

| Flujo de trabajo                             | Pasos (agente)                                                                                                                                                                    |
| -------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Plan, Build, Review & Test** (por defecto) | Plan (Architect) → Build (Builder) → Review (Reviewer) → Test (Tester)                                                                                                            |
| **Quality-Gated Change**                     | Build (Builder) → Test (Tester) → Review (Reviewer)                                                                                                                               |
| **Security-Sensitive Change**                | Scope change (Architect) → Risk analysis (Security Auditor) → Implement (Builder) → Audit diff (Security Auditor) → Validate (Tester)                                             |
| **UI Implementation**                        | UI plan (UI Designer) → Implement (Builder) → Code review (Reviewer) → Behavior test (Tester)                                                                                     |
| **DevOps Change**                            | DevOps plan (DevOps Engineer) → Risk review (Security Auditor) → Apply (DevOps Engineer) → Validate (Tester)                                                                      |
| **Feature SDLC**                             | Requirements (Product Analyst) → Delivery plan (Project Planner) → Technical design (Architect) → Backend → Frontend → E2E tests → Security review → User docs (Technical Writer) |

### Revisión y preparación

| Flujo de trabajo      | Pasos (agente)                                                                                                                  |
| --------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| **Parallel Review**   | Correctness review (Reviewer) → Security review (Security Auditor) → Test coverage review (Tester) → Merge findings (Architect) |
| **Swarm Inspection**  | Reviewer slice → Security slice → Tester slice → Merge summary (Architect)                                                      |
| **Release Readiness** | Correctness review → Security review → E2E sanity → Dependency audit → Go / no-go (Architect)                                   |

### Descubrimiento y diseño

| Flujo de trabajo        | Pasos (agente)                                                                               |
| ----------------------- | -------------------------------------------------------------------------------------------- |
| **Architecture Debate** | Architect A → Architect B → Critic review (Reviewer) → Final synthesis (Architect)           |
| **Discovery & Spec**    | Prior art (Researcher) → Requirements (Product Analyst) → Delivery plan (Project Planner)    |
| **Threat Model**        | Scope & data-flow (Architect) → STRIDE analysis (Security Auditor) → Record ADR (ADR Writer) |

Estos tres guardan su decisión como un registro de decisión de arquitectura propuesto en **Plan → ADRs**.

### Operaciones y mantenimiento

| Flujo de trabajo       | Pasos (agente)                                                                                                                |
| ---------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| **Incident Response**  | Triage (Incident Responder) → Root cause (Architect) → Mitigation (Builder) → Verify (Tester) → Postmortem (Site Reliability) |
| **Dependency Refresh** | Audit (Dependency Auditor) → Upgrade (Migration Specialist) → Test (Tester) → Verify secure (Security Auditor)                |
| **Performance Tuning** | Profile (Performance Tester) → Optimization plan (Architect) → Apply (Builder) → Re-measure (Performance Tester)              |
| **Data Migration**     | Schema (Database Engineer) → Migration (Migration Specialist) → Validate (Tester) → Security → Final review (Reviewer)        |

Los pasos siempre se ejecutan uno tras otro, y cada paso ve lo que escribieron los anteriores. Las etiquetas **Parallel**, **Debate** y **Swarm** del catálogo describen cómo los pasos se reparten el trabajo, no que se ejecuten a la vez. Un paso cuyo nombre contiene «plan» añade además sus elementos al **Plan board**.

### Cuándo se escribe el código

El código se escribe después del paso que implementa el cambio, no después del último paso:

1. Los pasos hasta el que implementa el cambio, este incluido, se ejecutan primero. Ese paso es Build, Implement, Apply, Mitigation, Upgrade o Migration, y en Feature SDLC es Frontend. En Plan, Build, Review & Test, primero se ejecutan Plan y Build.
2. Se escribe el cambio, y las pruebas de tu proyecto se ejecutan sobre él.
3. Los pasos posteriores al paso de implementación se ejecutan a continuación, como Review y Test, Audit diff y Validate, o Re-measure. En Feature SDLC son E2E tests, Security review y User docs. A cada uno se le muestra el cambio tal como se escribió y el resultado de pruebas registrado, así que comprueba el código, no un plan. Si uno de ellos falla o se queda sin tiempo, la sesión conserva su cambio y el paso se marca como fallido.
4. La revisión del diff con IA registra hallazgos.

Parallel Review, Swarm Inspection y Release Readiness no tienen paso de implementación, así que todos sus pasos se ejecutan antes de que se escriba el código. Los tres flujos de trabajo de descubrimiento y diseño escriben documentos y nada de código.

El resumen de la sesión es el texto del último paso, así que en un flujo de trabajo con pasos posteriores al código se escribe después de que se ejecutaran las pruebas. La página de la sesión muestra un aviso si lo que dice el resumen sobre las pruebas contradice el resultado registrado.

## Lanzar un flujo de trabajo

Puedes lanzar uno desde varios sitios:

- **Develop → AI Sessions → New session.** Elige cualquier flujo de trabajo en la lista **Workflow**. El flujo por defecto es **Plan, Build, Review & Test**.
- **Develop → Workflows.** Elige **Launch** en un flujo de trabajo, describe la tarea, elige un **Project** y pulsa **Start session**.
- **La página de un proyecto.** **Run workflow** lanza el flujo de trabajo por defecto en ese proyecto.
- **Fix with AI**, en un incidente, en la página **Quality** o en la página **Security**, y **Fix** en un hallazgo. Lanzan el flujo de trabajo por defecto sobre el problema. A la corrección de un hallazgo se le pide que incluya una prueba que lo reproduzca.
- **Una programación** (más abajo).

Toda ejecución de un flujo de trabajo necesita un proyecto. La política de tu espacio de trabajo puede exigir aprobación para lanzar un flujo de trabajo, o denegarlo. Consulta [Aprobaciones y políticas](https://aicodeops.dev/es/docs/approvals-and-policies).

## Programar un flujo de trabajo

Abre **Release → Schedules** y elige **New schedule**.

1. Introduce un **Name** y elige un **Workflow** y un **Project**.
2. Introduce una **Cron expression** de 5 campos y una **Timezone**. Elige **Preview next 5** para comprobar las horas.
3. Si quieres, describe la **Task**. Sin ella, la sesión ejecuta "Run the scheduled workflow" con el nombre de la programación.
4. Elige qué ocurre si se pierde una ejecución programada: catch up once (recuperar una vez), skip missed (omitir las perdidas) o exact (exacto).
5. Elige **Create schedule**.

Cada fila de programación tiene **Run now**, **History**, **Edit**, **Clone**, **Disable** y **Delete**. Las programaciones eliminadas se pueden restaurar desde **Recently deleted**.

## Cancelar una sesión

En la página de una sesión en ejecución, elige **Cancel session**. Introduce un motivo y después confirma con **Cancel session**. La sesión se detiene en unos segundos, incluida cualquier llamada al modelo en curso, y su cambio se marca como abandoned. Necesitas un rol que pueda gestionar sesiones; el rol Viewer no puede cancelar.

## Volver a ejecutar una sesión

En la página de una sesión terminada, elige **Re-run** y confirma. Lanza una sesión nueva con la misma tarea, el mismo flujo de trabajo, el mismo proyecto y el mismo modelo. La sesión nueva no queda vinculada a la original. Si el flujo de trabajo original ya no se puede lanzar, la nueva ejecución usa el flujo de trabajo por defecto y el cuadro de diálogo lo indica.

## Continuar una sesión con un seguimiento

Un seguimiento se basa en una sesión anterior en lugar de empezar de cero.

1. En la página de la sesión, escribe en el cuadro **Follow-up prompt**, por ejemplo «Gestiona también el caso de entrada vacía».
2. Elige el flujo de trabajo para el seguimiento. Por defecto es el mismo.
3. Elige **Send follow-up**.

El seguimiento es una sesión nueva, vinculada a su sesión padre: su página muestra **Parent session** en Linkage. Usa el proyecto y el modelo de la sesión padre, y recibe como contexto la tarea y el resumen de esta. Su página muestra la **Task** original una vez y, debajo, **Latest request (follow-up N)** con lo que pediste esta vez. Si el cambio de la sesión padre todavía no se ha fusionado, el seguimiento parte de él, de modo que el diff nuevo contiene los dos.

Mientras una sesión sigue en ejecución, el mismo cuadro dice **Mid-session handoff / follow-up** y el botón, **Spawn handoff**. Lanza una sesión nueva y vinculada. La sesión en ejecución continúa. Al elegir un paso en la tira de pasos de la sesión, la sesión nueva empieza desde ese paso.

## Siguientes pasos

- [Revisiones multiagente](https://aicodeops.dev/es/docs/multi-agent-reviews)
- [Controles de calidad](https://aicodeops.dev/es/docs/quality-gates)
- [Todos los agentes](https://aicodeops.dev/es/agents)

## Preguntas frecuentes

### ¿Puedo crear mi propio flujo de trabajo?

Todavía no. Cada sesión ejecuta uno de los 16 flujos de trabajo integrados, cada uno con una lista fija de pasos.

### ¿Los pasos de Parallel Review se ejecutan a la vez?

No. Todos los flujos de trabajo ejecutan sus pasos uno tras otro. Parallel, debate y swarm describen cómo los pasos se reparten el trabajo, no los tiempos.

### ¿Re-run es lo mismo que un seguimiento?

No. Re-run lanza la misma tarea otra vez desde cero, sin vínculo con la original. Un seguimiento se basa en la sesión anterior y queda vinculado a ella.
