convez.ai
SkillAutomaçãoAvançado
lipefur

Sprint Orchestrator

lipefur/sprint-orchestrator

Orquestre sprints paralelos com Claude mantendo memória institucional

Ver no GitHub
BomPluginScore · de 0 a 100

Skill para orquestrar sprints de software em paralelo com Claude, usando Git worktrees e chats isolados. Mantém histórico decisório, evita context bloat e escala de 200k para 1M de tokens. Validado em 17+ sprints em produção.

Instalação

$npx convez-ai lipefur/sprint-orchestrator

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
2
Forks
1
Acompanhando
0
Saúde
71%
Último commit
há 5 meses
Versão
v1.2.0
Issues abertas
0
Contribuidores
1

Casos de uso

  • Executar múltiplas features em paralelo com Claude
  • Manter decisões e convenções de projeto persistentes entre sprints
  • Reduzir context bloat em projetos grandes dividindo em chats focados
  • Rastrear bugs e patterns aprendidos entre ciclos de desenvolvimento

Veredito

Ferramenta madura e bem pensada para times que querem usar Claude em fluxos de desenvolvimento real. Resolve de verdade o problema de context bloat em projetos longos e agrega discipline via Git. Requer conforto com CLI e Git worktrees.

README

A tradução para o português deste README ainda está na fila.

sprint-orchestrator

Orquestre sprints de software com Claude: paralelismo, isolation via git worktree, memória institucional e (em modelos menores) zero context bloat. Adaptativo a 1M ou 200k de context.

License: MIT Latest Status Claude Code PRs Welcome Discussions skills.sh

🌍 Idiomas: Português · English · Español 📚 Docs: Tutorial · FAQ


🤔 O problema

Você quer construir algo grande com Claude. Abre um chat. Explica o que quer. Claude começa a codar. Duas horas depois:

  • 😵 O chat tá enorme. Claude esqueceu as decisões que você bateu no início.
  • 🐌 Tudo acontece uma coisa por vez, mesmo quando 4 coisas podiam rodar em paralelo.
  • 🔁 Você explica as mesmas convenções várias vezes.
  • 💔 Bugs do sprint passado? Esquecidos. Claude cai neles de novo.

Conhece essa situação?

✨ A ideia

Pensa em construir software como fazer um filme:

PapelQuem
🎬 Diretor (visão criativa, aprova cortes)Você
📋 Produtor (planeja, revisa, entrega)Chat orquestrador (fica aberto pro projeto inteiro)
🎥 Equipes de filmagem (cada uma grava uma cena)Chats de sprint (um por feature, criado e descartado)

Você não filma cada quadro. Você dirige, o produtor planeja e revisa, as equipes executam em paralelo.

É isso. É essa a skill.

Demo: um comando despacha um sprint para um novo chat isolado, que executa em paralelo e abre um PR

sequenceDiagram
    actor V as Você (Diretor)
    participant O as Chat Orquestrador
    participant S as Chat de Sprint
    participant G as GitHub
    V->>O: Planejar sprint 1 (login OAuth)
    O->>O: Brainstorm, escreve plano, commita
    O->>S: Dispatch abre janela nova com o plano
    S->>S: Executa em paralelo (1-4 agents)
    S->>G: Abre PR (sem merge)
    G-->>O: Notifica que o PR está pronto
    O->>V: Review adversarial, merge e deploy

🎯 Antes / Depois

Sem essa skillCom essa skill
Estrutura do chat1 chat gigante que esquece contexto1 orquestrador + N chats de sprint focados
DecisõesTomadas no início, perdidas depoisCapturadas em planos, commitadas no git
ParalelismoUma coisa por vez1-4 agents por sprint, múltiplos sprints possíveis
Memória entre sprintsNenhumastate.md + bug-patterns.md por addon
Controle de qualidadeVocê lê cada PR manualmenteClaude adversarial revisa primeiro, você arbitra
Validação"Funciona na minha máquina"GitHub Action faz preview deploy + Playwright automático
Lições aprendidasPerdidas no histórico do chatCapturadas como bug patterns após cada deploy

👥 Pra quem é essa skill

  • Devs usando Claude Code todo dia em projetos reais (não só demos)
  • Founders solo / indie hackers construindo produtos multi-feature
  • Times pequenos que querem workflow estruturado com IA
  • Quem tem múltiplos repos querendo processo consistente entre eles

Não é pra: scripts de uso único, protótipos descartáveis, "só conserta esse typo". Pra isso, usa Claude direto.

🚀 Instalação

Via npx skills (recomendado — cross-agent: Claude Code, Cursor, Codex, Windsurf, +50):

npx skills add lipefur/sprint-orchestrator

Via installer dedicado (Claude Code, com check de dependências):

curl -fsSL https://raw.githubusercontent.com/lipefur/sprint-orchestrator/main/install.sh | bash

O installer verifica dependências, clona a skill pra ~/.claude/skills/sprint-orchestrator/ e mostra próximos passos.

Revisar o installer antes:

curl -fsSL https://raw.githubusercontent.com/lipefur/sprint-orchestrator/main/install.sh -o /tmp/install.sh
less /tmp/install.sh        # inspeciona
bash /tmp/install.sh

Clone direto (sem installer):

git clone https://github.com/lipefur/sprint-orchestrator.git ~/.claude/skills/sprint-orchestrator

Local customizado:

SPRINT_ORCHESTRATOR_DIR=/custom/path bash install.sh

Atualizar depois:

curl -fsSL https://raw.githubusercontent.com/lipefur/sprint-orchestrator/main/install.sh | bash -s -- update

📖 Quickstart (3 passos)

1. Setup do projeto (uma vez)

cd path/para/seu/projeto
bash ~/.claude/skills/sprint-orchestrator/scripts/init.sh

O script inspeciona seu repo, detecta sua stack (Postgres? Next.js? Monorepo?), pergunta umas coisas e escreve .sprint-orchestrator.yml.

2. Planejar um sprint

Abre Claude Code no seu projeto. Diz:

"Vamos planejar sprint 1 — implementar login com OAuth"

Claude faz brainstorming com você, escreve um plano detalhado, commita em main.

3. Dispatchar o sprint

bash ~/.claude/skills/sprint-orchestrator/scripts/create-worktree.sh 1 oauth-login

Uma nova janela do Claude Code abre, já rodando num worktree isolado com o plano carregado. Executa autonomamente, abre PR, e volta pra você revisar.

É isso. Walkthrough completo: docs/tutorial-getting-started.md.


Resumo técnico

Pra quem quer entender a arquitetura antes de instalar.

Como funciona por baixo

A skill é estruturada como markdown modular que Claude lê sob demanda:

sprint-orchestrator/
├── SKILL.md             # entry point — Claude sempre lê
├── core/                # workflow + anti-padrões universais + style de commits
├── addons/              # stack-specific (carrega só se profile ativa)
├── templates/           # templates de plano por tipo, prompt dispatch, memory
├── checklists/          # pre-dispatch, post-pr-review, deploy-prod, capture-learnings
└── scripts/             # init.sh, create-worktree.sh (multi-IDE dispatch)

Quando você invoca a skill no Claude Code:

  1. Claude lê .sprint-orchestrator.yml do seu projeto
  2. Carrega core/ (universal)
  3. Carrega só os addons/ que seu projeto usa (ex: postgres, nextjs)
  4. Consulta templates/checklists just-in-time por fase

Resultado: ~6-12k tokens de contexto mesmo com todos os addons ativos.

O workflow em 4 fases

┌─────────────────────────────────┐
│  CHAT ORQUESTRADOR (você fica)  │
│  1. PLAN — brainstorm + plano   │
│  2. DISPATCH — cria worktree    │
│              + abre chat novo   │
└─────────────────────────────────┘
              ↓
┌─────────────────────────────────┐
│  CHAT DE SPRINT (Claude novo)   │
│  3. EXECUTE — lê plano, coda,   │
│     testa, abre PR, update state│
└─────────────────────────────────┘
              ↓
┌─────────────────────────────────┐
│  VOLTA PRO ORQUESTRADOR         │
│  4. REVIEW + DEPLOY             │
│     (com checks automáticos)    │
└─────────────────────────────────┘

Configuração (um arquivo por projeto)

.sprint-orchestrator.yml na raiz do projeto (gerado pelo init.sh):

version: 1
project_name: meu-app
default_branch: main

paths:
  plans: docs/superpowers/plans
  worktrees: .claude/worktrees

addons: [postgres, nextjs, e2e-validation, github-actions]

dispatch:
  method: auto      # auto-detect IDE (Cursor, VS Code, Claude Code, etc.)

notifications:
  github_assignee: meu-username      # auto-assigned no PR
  github_label: ready-for-review

# Workflows avançados (opt-in)
adversarial_review:
  enabled: true                       # 3º Claude revisa PRs adversarialmente
  reviewer_model: sonnet

github-actions:
  preview_validation: true            # preview deploy + Playwright auto no PR
  preview_platform: vercel            # vercel | fly | railway | coolify | generic

Workflows avançados

Três workflows opt-in que elevam o fluxo básico:

🤖 Adversarial review

Quando o chat de sprint abre PR, um 3º Claude isolado é dispatchado como reviewer com prompt explícito: "encontre problemas que o implementer perdeu." Posta comments via gh pr review. Você vira arbitrador, não reviewer linha-por-linha.

→ core/adversarial-review.md

🚀 Preview deploy + auto-validation

Templates de GitHub Action pra Vercel/Fly/Railway/Coolify. Quando PR abre: sobe preview deploy, roda Playwright contra URL preview, posta comment estruturado com PASS/FAIL + screenshots. Orquestrador acorda via GitHub notification — sem polling.

→ addons/github-actions/preview-validation/

🧠 Capture learnings

Após cada deploy, orquestrador triagia commits fix: do sprint e propõe novos bug patterns pra adicionar nos addons. A skill evolui com o uso em vez de ficar estática.

→ checklists/capture-learnings.md

🎛️ Modos adaptativos (1M / 200k)

A skill detecta seu context window (perguntado no init.sh) e escolhe:

  • monolithic (1M / Opus 4.6+/4.8) — orquestrador + execução no mesmo chat. Menos handoff. Worktree mantido; subagents só pra áreas disjuntas.
  • split (200k / Sonnet / Foundry) — 2 chats separados. Comportamento clássico.

mode: auto decide por context window + tamanho do sprint, anuncia a decisão e aceita veto. Override fixo via model.mode no profile. Profile antigo sem model: → split (backward compat). Detalhes em core/workflow.md.

📊 Visual dashboard

Kanban board local renderizado a partir do state.md. Três modos:

bash <skill>/scripts/dashboard.sh              # HTML estático, abre no browser
bash <skill>/scripts/dashboard.sh --serve      # live server com auto-refresh (SSE)
bash <skill>/scripts/dashboard.sh --workspace  # multi-project a partir de ~/.config/sprint-orchestrator/workspace.yml

Roda 100% local, zero tokens Claude. Vê tudo de relance: sprints por fase, PRs abertos com labels, recent merges.

→ scripts/dashboard/

Suporte multi-IDE

O script de dispatch detecta seu ambiente automaticamente e adapta:

AmbienteComportamento
Claude Code standalone (Terminal/iTerm)URL scheme claude-cli:// abre nova janela com prompt pré-carregado
CursorAbre worktree no Cursor + copia prompt → ⌘L pra nova chat
VS Code + Claude extensionAbre worktree no VS Code + copia prompt → comando "Claude: New Chat"
Antigravity (Google)Copia prompt + instrução + working dir
Windsurf (Codeium)Abre worktree no Windsurf + copia prompt → nova Cascade chat
OutrosClipboard puro + arquivo temp com prompt

Sobrescreve por projeto via dispatch.method no profile.

Como difere de alternativas

AbordagemTrade-off
Chat longo únicoContext bloat, sem paralelismo, sem memória entre sprints
superpowers:executing-plansBom pra executar plano conhecido em uma sessão; não orquestra fluxo multi-sprint
TODO list / NotionSem anti-padrões aprendidos; sem automação de dispatch + review
Esta skillWorkflow multi-chat, addon-modular, estado persistente, validado em produção

Status

v1.2.0 (atual): fundação + workflows avançados + installer one-liner + dashboard visual + modos adaptativos (1M/200k).

Roadmap (v2.0):

  • Bug patterns split por addon (a maioria são placeholders hoje — maior gap)
  • Mais profiles de exemplo (Next.js+Vercel, Django, monolito simples)
  • Scripts de cleanup (cleanup-merged.sh, list-sprints.sh)
  • Checklist de recovery pra sprint travado
  • Template de kickoff pra projetos novos
  • Implementação de scheduled task (pra projetos sem GitHub Actions)

Contribuindo

Contribuições mais valiosas:

  • 🧠 Bug patterns do seu debugging real em produção → ver template de issue bug-pattern
  • 🧩 Addons novos pra sua stack (Rails, Django, Spring, Go, etc.) → ver CONTRIBUTING.md
  • 📋 Perfis de exemplo em examples/
  • 🌍 Traduções deste README

Licença

MIT — ver LICENSE. Faz fork à vontade.

Origem

Construída e validada em 17+ sprints de produção entre Maio/2026 e o release público — em um projeto BaaS multi-tenant em produção. Ver examples/multi-tenant-saas-profile.yml pra um perfil real anonimizado.

Ver o original no GitHub

Bom para

Relacionados