OpenCode + GitHub Actions: Casos prácticos, multi-review y automatizaciones avanzadas

Si ya has leído el artículo anterior sobre cómo integrar OpenCode con GitHub Actions, sabes lo básico: comentar /oc fix this en un issue y que OpenCode te abra un PR con la solución. Eso es solo la punta del iceberg. Este artículo asume que ya tienes configurada la integración base; si no es así, empieza por el artículo anterior.

OpenCode tiene capacidades avanzadas que la mayoría de desarrolladores desconocen: reviews multi-agente paralelos, custom agents con permisos granulares, workflows programados y patrones de manejo de errores que transforman tu CI/CD. En este artículo vamos a cubrir todo eso con ejemplos reales listos para copiar y pegar.

1. Review de PRs con /review-pr: el flujo que deberías estar usando

El comando /review-pr es un flujo bundled de solo lectura que ejecuta una revisión completa usando agentes child sesiones en paralelo:

1. Construye un mapa de cambios y riesgo
2. Despacha sesiones child de solo lectura en paralelo
3. Valida hallazgos de forma independiente
4. Publica hallazgos confirmados inline en líneas específicas

Configuración básica

Con dceoy/opencode-action, activas la review con una línea:

- uses: dceoy/opencode-[email protected]
  with:
    prompt: /review-pr

Aspectos soportados

OpenCode puede enfocar la review en diferentes aspectos:

Review personalizada con prompt

Para un control más fino, define tu propio prompt:

prompt: |
  Review this pull request focusing on:
  - Check for code quality issues and anti-patterns
  - Look for potential bugs and edge cases
  - Identify security vulnerabilities
  - Assess performance bottlenecks
  - Suggest specific improvements with code examples

2. Multi-Agent Review paralelo: el hallazgo más potente

Esta es la capacidad más subestimada de OpenCode. La herramienta sun-praise/opencode-actions ejecuta múltiples agentes de review en paralelo, cada uno con un enfoque diferente, y luego un coordinador sintetiza los resultados.

Arquitectura

• N sesiones de reviews en paralelo via OpenCode SDK
• Roles de reviewer predefinidos: quality, security, performance, architecture, regression-test, feature-missing, test-value, spec-coverage
• Una sesión coordinator lee todos los outputs y produce una síntesis deduplicada
• Output de cada reviewer en sección <details> colapsable
• Una sola instancia opencode serve compartida (un solo MCP cold start)

Configuración

- name: Run OpenCode multi-review
  uses: sun-praise/opencode-actions/multi-review@v4
  with:
    github-token: ${{ secrets.GITHUB_TOKEN }}
    model: deepseek/deepseek-v4-flash
    default-team: "quality:1,security:1,performance:1"
    timeout-seconds: "900"
    deepseek-api-key: ${{ secrets.DEEPSEEK_API_KEY }}

El parámetro default-team define qué reviewers ejecutar. Cada {persona}:{count} crea N instancias de ese reviewer. Con quality:1,security:1,performance:1 tienes tres reviews simultáneas que cubren las áreas más críticas.

3. Cadenas de pasos: Test → Lint → Review → Auto-fix

OpenCode no tiene un "chain" integrado, pero se combina perfectamente con GitHub Actions para crear pipelines completas:

name: CI Pipeline
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm test
  
  lint:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm run lint
  
  ai-review:
    needs: lint
    runs-on: ubuntu-latest
    permissions:
      id-token: write
      contents: read
      pull-requests: read
    steps:
      - uses: actions/checkout@v4
        with:
          persist-credentials: false
      - uses: anomalyco/opencode/github@latest
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        with:
          model: anthropic/claude-sonnet-4-20250514
          use_github_token: true
          prompt: |
            Review this PR after tests and lint pass:
            - Verify code quality
            - Check for regressions
            - Suggest improvements

El orden importa: solo llega a review si los tests y el lint pasan. Así la IA gasta tokens en análisis de calidad, no en encontrar errores que un linter detectaría en segundos.

4. Custom agents con permisos granulares

Una de las capacidades menos conocidas de OpenCode es la posibilidad de crear agents personalizados con permisos específicos. Esto es crucial para escenarios donde necesitas que la IA revise pero no modifique tu código.

Agent en Markdown

Crea el archivo en .opencode/agents/security-reviewer.md:

---
description: Security-focused code reviewer
mode: subagent
model: anthropic/claude-sonnet-4-5  # reasoning effort alto
color: danger
steps: 10
permissions:
  - action: edit
    resource: "*"
    effect: deny
  - action: shell
    resource: "*"
    effect: deny
---

You are a security expert reviewing code changes.
Focus on:
- Injection vulnerabilities (SQL, XSS, command injection)
- Authentication and authorization flaws
- Sensitive data exposure
- Insecure deserialization
- Security misconfigurations

Report findings with severity levels and remediation steps.

Agent en JSON

Si prefieres un solo archivo de configuración:

{
  "$schema": "https://opencode.ai/config.json",
  "agents": {
    "reviewer": {
      "description": "Reviews changes for correctness, security, and missing tests",
      "mode": "all",
      "model": "anthropic/claude-sonnet-4-5",
      "system": "Review the current changes. Report findings before any summary.",
      "color": "warning",
      "steps": 8,
      "permissions": [
        { "action": "edit", "resource": "*", "effect": "deny" },
        { "action": "shell", "resource": "*", "effect": "deny" }
      ]
    }
  }
}

La clave está en los permisos: deny en edit y shell garantiza que el agent solo lee y analiza. Puedes crear tantos agents como necesites: uno para performance, otro para accesibilidad, otro para arquitectura.

Temperature para diferentes tareas

{
  "agents": {
    "plan": { "temperature": 0.1 },
    "build": { "temperature": 0.3 },
    "brainstorm": { "temperature": 0.7 }
  }
}

Un temperature bajo (0.1) para planificación determinista, medio (0.3) para código, y alto (0.7) para brainstorming creativo.

5. Tareas programadas con cron: mantenimiento automático

Los workflows programados son donde OpenCode realmente brilla para el mantenimiento a largo plazo.

Limpieza semanal de código

name: Weekly Code Cleanup
on:
  schedule:
    - cron: "0 8 * * 1"  # Lunes 8am UTC

jobs:
  cleanup:
    runs-on: ubuntu-latest
    permissions:
      id-token: write
      contents: write
      pull-requests: write
      issues: write
    steps:
      - uses: actions/checkout@v4
        with:
          persist-credentials: false
      - uses: anomalyco/opencode/github@latest
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        with:
          model: anthropic/claude-sonnet-4-20250514
          prompt: |
            Review the codebase for any TODO comments and create a summary.
            If you find issues worth addressing, open an issue to track them.
            Also check for:
            - Dead code that can be removed
            - Unused imports
            - Deprecated API usage
            - Console.log or debug statements left in production code

Reporte mensual de deuda técnica

name: Technical Debt Report
on:
  schedule:
    - cron: "0 9 1 * *"  # Primer día de cada mes

jobs:
  report:
    runs-on: ubuntu-latest
    permissions:
      id-token: write
      contents: write
      issues: write
    steps:
      - uses: actions/checkout@v4
        with:
          persist-credentials: false
      - uses: anomalyco/opencode/github@latest
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        with:
          model: anthropic/claude-sonnet-4-20250514
          prompt: |
            Analyze the codebase and generate a technical debt report:
            - Count TODO/FIXME/HACK comments
            - Identify files with highest complexity
            - List deprecated dependencies
            - Check for unused exports
            - Create a GitHub issue with the full report
            - Prioritize items by impact and effort

Auditoría semanal de dependencias

name: Dependency Audit
on:
  schedule:
    - cron: "0 9 * * 1"

jobs:
  audit:
    runs-on: ubuntu-latest
    permissions:
      id-token: write
      contents: write
      pull-requests: write
      issues: write
    steps:
      - uses: actions/checkout@v4
        with:
          persist-credentials: false
      - uses: anomalyco/opencode/github@latest
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        with:
          model: anthropic/claude-sonnet-4-20250514
          prompt: |
            Review the codebase for outdated dependencies.
            Check package.json, requirements.txt, or go.mod.
            For each outdated dependency:
            - List current version and latest version
            - Note breaking changes if known
            - Create a summary issue with findings

6. Security audit con prompts personalizados

No confíes en el review genérico cuando se trata de seguridad. Un prompt dedicado marca la diferencia.

Prompt de auditoría de seguridad completo

prompt: |
  Perform a security audit of this pull request:
  - Check for SQL injection vulnerabilities
  - Look for XSS attack vectors
  - Verify authentication and authorization logic
  - Check for hardcoded secrets or API keys
  - Review input validation and sanitization
  - Assess dependency vulnerabilities
  - Report severity levels: CRITICAL, HIGH, MEDIUM, LOW

Prompt de performance

prompt: |
  Review this PR for performance issues:
  - Identify O(n²) or worse algorithms
  - Check for unnecessary database queries (N+1 problem)
  - Look for memory leaks or unbounded growth
  - Verify proper use of caching
  - Check bundle size impact for frontend changes
  - Suggest specific optimizations with code examples

Prompt de accesibilidad

prompt: |
  Review this PR for accessibility (a11y):
  - Check ARIA labels and roles
  - Verify keyboard navigation support
  - Look for missing alt text on images
  - Check color contrast ratios
  - Verify screen reader compatibility
  - Check form labels and error messages
  - Reference WCAG 2.1 AA compliance

Combinación con Dependabot

Un caso de uso especialmente útil: que OpenCode revise automáticamente los PRs de Dependabot.

name: Auto Review Dependabot PRs
on:
  pull_request:
    types: [opened, synchronize]
jobs:
  review:
    if: github.actor == 'dependabot[bot]'
    runs-on: ubuntu-latest
    permissions:
      id-token: write
      contents: read
      pull-requests: read
    steps:
      - uses: actions/checkout@v4
        with:
          persist-credentials: false
      - uses: anomalyco/opencode/github@latest
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        with:
          model: anthropic/claude-sonnet-4-20250514
          use_github_token: true
          prompt: |
            Review this dependency update PR:
            - Check if the changelog mentions breaking changes
            - Verify if any API changes affect our codebase
            - Assess risk level (low/medium/high)

7. Workflows reutilizables

dceoy/opencode-action provee workflows reutilizables que eliminan la duplicación de configuración.

Ejemplo de caller

name: My Review
on:
  pull_request:
    types: [opened, synchronize]
jobs:
  review:
    uses: dceoy/opencode-action/.github/workflows/opencode-review.yml@main
    with:
      model: anthropic/claude-sonnet-4-20250514
    secrets:
      ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

Una sola línea para activar una review completa. Sin duplicar lógica de checkout, permisos, ni configuración de OpenCode.

8. Gestión de errores y retry

Retry automático

sun-praise/opencode-actions incluye retry automático con profiles predefinidos:

- name: Run OpenCode
  uses: sun-praise/opencode-actions/run-opencode@v4
  with:
    retry-profile: github-network
    timeout-seconds: 600

El profile github-network maneja fallos de red transitorios con GitHub.

Timeout management

# dceoy/opencode-action
- uses: dceoy/opencode-[email protected]
  with:
    timeout-minutes: 30  # Default: 60 minutos

# sun-praise/opencode-actions
- uses: sun-praise/opencode-actions/github-run-opencode@v4
  with:
    timeout-seconds: 900  # 15 minutos

Siempre establece un timeout explícito. El default de 60 minutos puede gastar muchos tokens si algo sale mal.

Logging configurable

- uses: dceoy/opencode-[email protected]
  env:
    OPENCODE_LOG_LEVEL: INFO  # DEBUG, INFO, WARN, ERROR

Usa DEBUG cuando estés configurando, INFO o WARN en producción.

9. Caso práctico end-to-end

Imagina un proyecto Next.js con PRs frecuentes. Este es el workflow completo:

Pipeline de revisión completa

name: Complete PR Review Pipeline
on:
  pull_request:
    types: [opened, synchronize]

permissions:
  id-token: write
  contents: read
  pull-requests: read

jobs:
  # Paso 1: Tests y lint rápidos
  checks:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: npm ci
      - run: npm test
      - run: npm run lint

  # Paso 2: Review general de calidad
  quality-review:
    needs: checks
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          persist-credentials: false
      - uses: dceoy/opencode-[email protected]
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        with:
          prompt: /review-pr
          timeout-minutes: 15

  # Paso 3: Security audit específico
  security-review:
    needs: checks
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          persist-credentials: false
      - uses: dceoy/opencode-[email protected]
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        with:
          model: anthropic/claude-sonnet-4-5#high
          timeout-minutes: 15
          prompt: |
            Perform a focused security audit:
            - SQL injection and XSS vulnerabilities
            - Authentication/authorization flaws
            - Hardcoded secrets or API keys
            - Input validation gaps
            Report with severity: CRITICAL, HIGH, MEDIUM, LOW

Notas clave:

• checks corre en paralelo con reviews de calidad y seguridad (needs: checks pero sin dependencia entre ellos)
• Cada review usa un prompt específico para no diluir el análisis
• Timeouts explícitos para controlar costos
• persist-credentials: false por seguridad

10. Limitaciones y gotchas: lo que nadie te dice

Limitaciones de GitHub Actions

• Límite de 50 reruns por workflow (desde abril 2026)
• GITHUB_TOKEN no dispara workflows — Los PRs creados por OpenCode no triggerean otros workflows automáticos (limitación de GitHub, no de OpenCode)
• Forks — Limitaciones de acceso a secrets en PRs de forks externos
• Concurrency — Múltiples /oc en el mismo issue/PR pueden causar race conditions

Limitaciones de OpenCode

• Sin memoria entre sesiones — Cada ejecución de GitHub Actions es fresh context. No puede "recordar" decisiones anteriores
• Rate limits — Puede quedar en retry infinito con quotas de provider. Usa timeout-minutes siempre
• Costos en repos públicos — Cualquiera puede comentar /oc y triggerar ejecuciones de API. Controla esto:

# Solo el owner puede triggerar
if: github.event.issue.author_association == 'OWNER'

• Monorepos — Sin soporte nativo para trabajar en múltiples paquetes de forma selectiva
• Modelos — No todos soportan todas las funcionalidades (variant, reasoning effort)

Workarounds rápidos

Conclusión

OpenCode con GitHub Actions va mucho más allá de /oc fix this. Con reviews multi-agente paralelos, puedes obtener análisis de calidad, seguridad y performance en paralelo. Con custom agents, controlas exactamente qué puede y qué no puede hacer cada revisor. Con workflows programados, automatizas el mantenimiento del código sin intervención manual.

El próximo paso es experimentar. Empieza con un /review-pr en tu repo, añade un security audit personalizado, y cuando estés listo, configura las tareas semanales de limpieza.

Si aún no has configurado la integración base, revisa el artículo anterior sobre cómo integrar OpenCode con GitHub Actions para empezar desde cero.

Artículos relacionados

• Cómo integrar OpenCode con GitHub Actions — El básico paso a paso

Artículo escrito por Roberto Serrano — Desarrollador web, automatizaciones e IA en Tarragona, España.