# Entregue uma feature de ponta a ponta com uma squad

> A squad de entregar uma feature é um playbook do Tallos que constrói uma feature inteira com o template Líder divide o trabalho. Um agente líder quebra o objetivo em API, UI e testes, coloca um membro em cada parte, cada um no seu worktree, confere tudo, junta num branch só e para para você aceitar ou descartar.

- Canonical: https://runtallos.com/pt/squads/entregar-uma-feature
- English: https://runtallos.com/squads/ship-a-feature.md
- Atualizado em: 2026-09-29
- Section: Squads

## Em resumo

- Template: Líder divide o trabalho
- Líder + 3 membros: API, UI, testes
- Limites sugeridos: 5 rodadas · 4 membros ao mesmo tempo
- Cada membro trabalha no próprio worktree
- Nada é mesclado sem a sua aprovação

## Quando usar a squad de entregar uma feature?

Use quando a feature tem partes que dá para construir ao mesmo tempo sem mexer nos mesmos arquivos: uma API, uma tela e os testes que provam que as duas conversam. O líder entrega uma parte para cada membro e junta tudo num branch só, que você revisa uma vez.

- **Encaixa bem:** feature que mexe em um endpoint, uma tela e um teste end-to-end.
- **Não encaixa:** correção de um arquivo só. Um agente num [workspace paralelo](https://runtallos.com/pt/recursos/workspaces-paralelos) resolve mais rápido.
- **Não encaixa:** problema aberto, sem abordagem clara. Tente antes a [melhor de três](https://runtallos.com/pt/squads/melhor-de-tres).

## Como montar a squad?

Abra **Squads → Nova squad** e escolha **Líder divide o trabalho**. O template já vem com três membros com uma função genérica. Reescreva cada uma dizendo exatamente quem cuida do quê: o líder é instruído a nunca passar para um membro trabalho fora da função dele.

| Papel | Agente (exemplo) | O que faz |
| --- | --- | --- |
| Líder | Claude Code | Divide o objetivo, inicia os membros, confere cada resultado, junta tudo e escreve o relatório final. Não escreve código. |
| Membro 1: API | Codex | Constrói o endpoint de cancelamento e o webhook do Stripe. |
| Membro 2: UI | Gemini CLI | Constrói o diálogo de cancelamento e a página de cobrança nas configurações. |
| Membro 3: testes | OpenCode | Escreve os testes end-to-end de cancelamento → reembolso. |

_Os agentes são exemplos. Qualquer agente conectado no Tallos pode assumir qualquer papel._

> **Agente e modelo quem escolhe é você** — Cada vaga, de líder ou membro, tem seu próprio agente, modelo e nível de esforço. Quando a CLI do agente aceita flag de modelo, o Tallos aplica sua escolha no lançamento; se não aceita, vale a configuração do próprio agente. Misturar fornecedores é opcional. Configure os agentes uma vez em [Conexões](https://runtallos.com/pt/recursos/conexoes-de-agentes).

## Qual objetivo colar?

Escreva o resultado que você quer, os limites e como o líder sabe que acabou.

```text
Adicionar cancelamento de assinatura do Stripe com proporcionalidade.

Escopo
- API: POST /subscriptions/:id/cancel cancela no fim do período e calcula o reembolso proporcional.
- Webhook: tratar customer.subscription.deleted e marcar a conta como cancelada.
- UI: diálogo de Cancelar na página de cobrança, mostrando o reembolso antes de confirmar.
- Testes: end-to-end de cancelamento -> reembolso, mais o caminho do webhook.

Restrições
- Usar o cliente Stripe que já existe em src/billing/stripe.ts. Sem dependências novas.

Pronto quando
- pnpm test e pnpm e2e passarem.
- O relatório final listar todos os arquivos alterados e o que eu devo conferir na mão.
```

As **Instruções do líder** são opcionais; o template já traz um padrão razoável. Se a ordem importa, diga, tipo "junte a API primeiro, depois a UI, e rode a suíte e2e".

## Quais limites definir?

Mantenha o padrão: **5 rodadas** e **4 membros ao mesmo tempo**. Sobra espaço para um ciclo de corrigir e conferir de novo sem a squad se perder.

| Configuração | Recomendado | Por quê |
| --- | --- | --- |
| Máximo de rodadas | 5 (padrão) | Uma rodada é planejar → distribuir → revisar. O resto é folga. |
| Máximo de membros ao mesmo tempo | 4 (padrão) | Três partes em paralelo e uma vaga livre para reiniciar uma parte. |
| Teto fixo | 20 rodadas · 12 membros | O Tallos recusa membros além do seu limite; o líder precisa reportar quando as rodadas acabam. |


> Monte essa squad no Tallos: escolha o template, cole o objetivo e inicie. → https://runtallos.com/signup

## Como a execução acontece?

Abaixo, uma execução de exemplo. Os detalhes são ilustrativos; a sua depende do seu código e dos seus agentes.

1. **O líder planeja** — Divide o objetivo em API, UI e testes e inicia três membros, cada um num worktree filho novo, para que as alterações não colidam.
2. **Os membros constroem em paralelo** — Endpoint e webhook, diálogo e página de configurações, suíte e2e. Cada membro tem um terminal que você abre pela tela da squad.
3. **O líder confere cada parte** — Nesta execução de exemplo, um teste e2e falha: o reembolso está errado em um dia.
4. **Rodada 2: correção pontual** — O líder devolve a falha só para o membro de API e roda a verificação de novo.
5. **Uma pergunta para você** — Proporcionalidade é decisão de produto, então o líder pergunta: ao dia ou ao segundo? A execução mostra **Precisa da sua resposta** até você responder.
6. **Juntar e reportar** — Com tudo verde, o líder junta as partes num branch no próprio worktree e entrega o relatório com `tallos squad report`.

A tela da squad acompanha **Rodadas**, **Iniciadas**, **Concluídas**, **Falharam** e um **Custo estimado** quando os modelos têm preço conhecido.

## O que o líder pode te perguntar?

O líder só pergunta quando está realmente travado, quase sempre numa decisão de produto. Ele roda `tallos squad ask`, a execução muda para **Precisa da sua resposta**, e você escolhe uma opção ou escreve a sua.

- **Comportamento:** "Proporcional ao dia ou ao segundo?"
- **Conflito:** "A API e a UI discordam no formato do erro. Qual vale?"

Responda com precisão: resposta vaga costuma custar uma rodada.

## O que você recebe no final?

Você recebe um relatório final, os resultados por worktree e uma decisão para tomar. Nada chega no seu branch base até você agir.

- **Relatório final:** o que foi feito, o worktree recomendado, riscos em aberto e o que conferir na mão. Na execução de exemplo: cancelamento no fim do período, proporcional ao dia, seis testes e2e novos passando.
- **Resultados por worktree:** o branch combinado do líder e o worktree de cada membro, cada um com **Ver alterações**. O que o relatório aponta ganha o selo **Recomendado**.
- **Aceitar ou Descartar:** Aceitar transforma a linha recomendada em **Abrir para criar PR**. Descartar mantém os worktrees, ou também apaga os dos membros se você marcar essa opção.

Revise o diff combinado como o PR de alguém do time. Veja [como revisar código gerado por IA](https://runtallos.com/pt/aprenda/revisar-codigo-gerado-por-ia).

## Quais variações funcionam bem?

- **Adicione um revisor.** Um quarto membro com a função "Revisa o branch combinado com foco em segurança e tratamento de dados." Para trabalho que é mais revisão do que construção, comece pela [construir e revisar](https://runtallos.com/pt/squads/construir-e-revisar).
- **Divida por pacote, não por arquivo.** Num monorepo, escreva funções como "cuida de packages/api" e "cuida de apps/web", para que dois membros nunca mexam no mesmo pacote.
- **Salve.** Clique em **Salvar como squad** e reaproveite a equipe na próxima feature. Só o objetivo muda.

## Quais são os erros mais comuns?

- **Função de membro genérica.** "Ajuda na feature" não diz nada para o líder. Escreva o trabalho: "constrói o endpoint da API e a migration".
- **Partes que se sobrepõem.** Se dois membros editam o mesmo arquivo, juntar vira resolver conflito.
- **Sem critério de pronto.** Sem um comando de teste, o líder tem que adivinhar a hora de parar.
- **Subir limites para compensar objetivo ruim.** Mais rodadas não salvam um objetivo confuso. Pare, deixe o objetivo claro e comece de novo.

Primeira vez com squads? Siga o passo a passo de [sua primeira squad](https://runtallos.com/pt/aprenda/seu-primeiro-squad) ou veja como as [squads](https://runtallos.com/pt/recursos/squads) funcionam por dentro.

## Perguntas frequentes

### O líder e os membros podem usar agentes de IA diferentes?

Sim. Cada vaga escolhe seu agente, modelo e esforço. Um líder num agente pode supervisionar membros em outros três, ou os quatro podem rodar o mesmo agente.

### O líder da squad também escreve código?

Não. O líder planeja, distribui, confere e junta; quem implementa são os membros.

### E se dois membros precisarem editar o mesmo arquivo?

Cada membro trabalha no próprio worktree, então nada colide durante a construção. A sobreposição aparece quando o líder junta os branches, por isso divida bem.

### Dá para parar uma squad no meio da execução?

Dá. Parar squad encerra o líder e os membros, e tudo que já foi alterado continua no respectivo worktree para você conferir.

### O Tallos mescla a feature pronta na main?

Não. O líder é instruído a nunca mesclar, dar push ou aplicar alterações no branch base. Depois de aceitar, você abre o worktree recomendado e cria o pull request.

### Qual a diferença entre uma squad e três agentes em três terminais?

Três terminais te dão três resultados para costurar na mão. A squad adiciona um líder que divide o trabalho, confere cada parte, repete quando falha e te entrega um resultado combinado com relatório. Veja [um agente vs vários](https://runtallos.com/pt/comparar/um-agente-vs-varios).

---

**Rode seus agentes em paralelo com o Tallos** — Claude Code, Codex, Gemini e mais de 30 agentes — cada um no seu workspace, com squads, chat, terminais e revisão num só app. Usa as assinaturas que você já tem.

https://runtallos.com/signup (macOS 13+ · Windows 10+)