A utilização de agentes de IA no desenvolvimento de software está mudando a forma como as equipes organizam e distribuem o trabalho.

Um desenvolvedor pode assumir uma demanda completa e utilizar agentes para planejar, implementar, testar e revisar diferentes partes da solução. Nesse cenário, dividir cada implementação em pequenos tickets no board nem sempre faz sentido.

A decomposição técnica continua necessária, mas pode acontecer durante a execução, sob responsabilidade do desenvolvedor que coordena os agentes.

Essa mudança traz oportunidades para simplificar a gestão, reduzir a quantidade de tickets e concentrar o acompanhamento nas entregas, em vez de acompanhar cada etapa da implementação.

1. Repensando a granularidade dos tickets

Tradicionalmente, demandas extensas são divididas em tarefas menores para facilitar estimativas, distribuição de responsabilidades e acompanhamento do progresso.

Com agentes de IA, parte dessa necessidade de fragmentação diminui.

Uma funcionalidade que antes seria distribuída entre diferentes desenvolvedores pode ser implementada por uma única pessoa coordenando agentes especializados ou múltiplas sessões de desenvolvimento.

Por exemplo, uma demanda para implementar um módulo de notificações poderia gerar tickets separados para:

  • Criar as tabelas no banco de dados.
  • Implementar os serviços.
  • Desenvolver os endpoints.
  • Criar os componentes de interface.
  • Adicionar testes.

Agora, essas atividades podem fazer parte de um único ticket: Implementar o módulo de notificações.

O desenvolvedor responsável organiza as etapas internamente, determina o que pode ser executado em paralelo e coordena a integração.

Isso não significa que tickets menores deixaram de ser úteis. A divisão continua fazendo sentido quando existem responsáveis diferentes, dependências externas, entregas independentes ou necessidade de acompanhamento específico.

A granularidade dos tickets deve refletir as necessidades da gestão do projeto, não necessariamente cada etapa da implementação.

Quando separar: se a mudança de infraestrutura necessária ao módulo depender de outra equipe, tiver responsável ou aprovação própria e puder bloquear a entrega, essa parte pode justificar um ticket independente. As etapas internas sob o mesmo responsável podem continuar no checklist do ticket principal.

2. Separar a gestão do projeto da execução técnica

Uma distinção importante é separar a decomposição utilizada para gerenciar o projeto daquela necessária para executar o trabalho.

O board deve representar as entregas, suas prioridades, dependências, responsáveis e estados.

Já a decomposição técnica pode ser administrada pelo desenvolvedor durante a execução, utilizando planos, checklists, documentos e ferramentas de orquestração.

Por exemplo:

Exemplo — Organização no board e durante a execução

No board

Ticket: Implementar sistema de notificações.

Na execução

  1. Analisar requisitos e arquitetura existente.
  2. Definir os contratos necessários.
  3. Implementar persistência e serviços.
  4. Desenvolver API e interface.
  5. Executar testes e corrigir problemas.
  6. Validar a integração.

Essas etapas não precisam necessariamente se transformar em tickets independentes.

O desenvolvedor pode distribuí-las entre agentes, acompanhar seus resultados e reorganizar a execução conforme necessário.

Isso reduz a manutenção de boards excessivamente fragmentados, sem eliminar a rastreabilidade do trabalho.

Exemplo — Dependências e execução paralela

Atividade Dependência Organização
Definir contratos Requisitos e decisões aprovadas Etapa inicial
Implementar serviços Contratos definidos Pode avançar em paralelo com a interface
Desenvolver interface Contratos definidos Pode avançar em paralelo com os serviços
Validar integração Componentes implementados e integrados Etapa posterior

Essa divisão é uma possibilidade de execução dentro do ticket, não uma obrigação de criar quatro itens independentes no board.

3. Tickets orientados a resultados, não a passos de implementação

Quando a execução pode ser planejada e distribuída internamente, os tickets devem priorizar o resultado esperado.

Em vez de descrever cada operação que precisa ser realizada, o ticket pode definir o comportamento da funcionalidade, os requisitos técnicos, as restrições e as condições para sua aprovação.

Um ticket bem preparado deve fornecer:

  • Objetivo: o que precisa ser entregue.
  • Escopo: funcionalidades e comportamentos esperados.
  • Contexto: referências, documentação e decisões existentes.
  • Restrições: padrões, contratos e limitações que precisam ser respeitados.
  • Dependências: outras entregas ou decisões necessárias.
  • Critérios de aceite: condições verificáveis para aprovação.

Isso não impede que o ticket contenha detalhes técnicos. Algumas implementações exigem decisões previamente estabelecidas que não devem ficar abertas à interpretação do executor.

A diferença é evitar transformar o ticket em um roteiro excessivamente detalhado quando o desenvolvedor pode organizar a implementação com seus agentes.

O ticket define o que precisa ser entregue e quais condições devem ser respeitadas. A estratégia de execução pode ser definida por quem assume a demanda.

Para a estrutura completa e os exemplos de especificação, consulte Como criar tickets na era da IA.

4. Preparar o contexto para a orquestração

Com um desenvolvedor coordenando múltiplos agentes, a qualidade do contexto disponível se torna ainda mais importante.

Uma demanda pode envolver diferentes módulos, integrações e decisões arquiteturais. Se essas informações estiverem dispersas, o desenvolvedor e seus agentes precisarão reconstruir parte dos requisitos durante a execução.

O ticket deve centralizar ou referenciar o conhecimento necessário para iniciar o trabalho.

Isso pode incluir documentos de arquitetura, contratos de API, designs, requisitos de negócio e decisões tomadas em outras demandas.

Não é necessário reproduzir toda a documentação dentro do ticket. Referências organizadas são suficientes quando os documentos estão acessíveis e atualizados.

Também é importante distinguir requisitos obrigatórios de sugestões de implementação.

Os agentes podem avaliar alternativas técnicas, mas não devem reinterpretar decisões que já foram aprovadas ou modificar contratos compartilhados sem autorização.

Quanto mais completo e consistente for o contexto inicial, menor será a necessidade de interromper a execução para esclarecer requisitos ou corrigir interpretações.

Exemplo de contexto compartilhado: se backend e frontend forem delegados a agentes diferentes, ambos devem consultar a mesma versão aprovada do contrato da API, incluindo campos, tipos, respostas e comportamentos de erro. Sem essa referência comum, cada agente pode concluir uma implementação aparentemente correta que não funciona em conjunto.

Para aprofundar a organização das referências e decisões técnicas, consulte Arquitetura, engenharia e documentação de contexto.

5. Gerenciar dependências entre entregas

A redução da quantidade de tickets também exige uma mudança na forma de registrar dependências.

Não é necessário representar no board todas as relações técnicas internas de uma implementação.

Se um desenvolvedor é responsável por entregar um módulo completo, as dependências entre banco de dados, serviços e interface podem ser organizadas durante a execução.

Por outro lado, dependências que envolvem outras equipes, responsáveis ou entregas independentes precisam permanecer visíveis.

Considere dois módulos que dependem de uma alteração compartilhada no sistema de autenticação.

Mesmo que cada módulo seja executado por um desenvolvedor com seus agentes, a mudança na autenticação precisa ser coordenada para evitar implementações incompatíveis.

A mesma lógica se aplica a contratos de API, schemas, bibliotecas compartilhadas e alterações de infraestrutura.

O board deve evidenciar dependências que afetam a coordenação do projeto. As dependências internas de implementação podem permanecer sob controle do executor.

Essa separação permite simplificar o acompanhamento sem comprometer a organização técnica.

6. Responsabilidade pela entrega completa

A utilização de agentes não elimina a responsabilidade do desenvolvedor pela qualidade do trabalho.

Ao assumir um ticket, o responsável também assume a coordenação das implementações necessárias para concluir a demanda.

Isso inclui distribuir atividades, acompanhar execuções, resolver conflitos, revisar alterações e garantir que os resultados sejam integrados corretamente.

Não é necessário registrar cada agente como responsável por uma tarefa no board principal. A organização dos agentes pode permanecer no ambiente de desenvolvimento ou em ferramentas específicas de orquestração.

O responsável pelo ticket continua sendo o ponto de referência para o andamento e a conclusão da entrega.

Essa abordagem evita que a gestão do projeto dependa da estrutura interna de execução, que pode mudar conforme as ferramentas e os modelos utilizados.

Também permite que uma mesma equipe trabalhe com diferentes estratégias: alguns desenvolvedores podem utilizar múltiplos agentes simultaneamente, enquanto outros preferem execuções sequenciais ou mais assistidas.

O processo de gestão não precisa ser diferente para cada abordagem.

Os limites de autonomia, a autoridade sobre decisões e a aprovação são aprofundados em Divisão de trabalho entre humanos e agentes.

7. Critérios de aceite e validação automatizada

Quando um ticket representa uma entrega maior, seus critérios de aceite precisam abranger o comportamento completo da funcionalidade.

Não basta verificar se cada etapa técnica foi executada. É necessário confirmar que o resultado integrado atende aos requisitos.

Os critérios podem incluir comportamentos funcionais, contratos, compatibilidade com funcionalidades existentes e resultados de testes.

A validação também pode ser distribuída entre agentes e ferramentas automatizadas.

Por exemplo, um agente pode implementar a funcionalidade, enquanto outro executa testes de integração ou verifica o comportamento da interface em um navegador.

Essas verificações podem gerar evidências associadas ao ticket, como resultados de testes, relatórios e capturas de tela.

Entretanto, a validação automatizada não deve ser confundida com aprovação irrestrita.

Alterações críticas, comportamentos sensíveis e decisões que exigem julgamento continuam dependendo dos mecanismos de revisão estabelecidos pelo projeto.

O critério de conclusão deve ser a entrega validada, não a quantidade de etapas executadas ou agentes envolvidos.

A definição e execução das verificações são aprofundadas em Estratégia de testes para código produzido com IA.

8. Paralelismo e capacidade de execução

A possibilidade de utilizar vários agentes simultaneamente altera a capacidade de execução de um desenvolvedor, mas não elimina seus limites.

Enquanto um agente implementa uma API, outro pode desenvolver testes e um terceiro trabalhar em componentes independentes.

Isso permite avançar em diferentes partes de uma demanda sem necessariamente distribuir cada atividade entre membros da equipe.

Entretanto, o paralelismo precisa considerar dependências técnicas, conflitos de arquivos e a capacidade de acompanhamento.

Múltiplos agentes alterando componentes compartilhados podem produzir conflitos e aumentar o esforço de integração.

Da mesma forma, executar muitas tarefas simultaneamente pode gerar uma fila de alterações pendentes de revisão.

O desenvolvedor continua responsável por analisar os resultados, tomar decisões e garantir a consistência da solução.

Portanto, a capacidade de execução não deve ser medida simplesmente pela quantidade de agentes disponíveis.

O limite prático está na capacidade de coordenar, validar e integrar os resultados produzidos.

Isso também influencia como demandas devem ser distribuídas entre os desenvolvedores de uma equipe.

Um profissional que utiliza agentes para executar várias partes de uma funcionalidade pode assumir um escopo maior, mas isso não significa que qualquer quantidade de trabalho possa ser atribuída sem aumentar riscos e retrabalho.

Os cuidados com execução concorrente também são tratados em Ambientes isolados para agentes e humanos.

9. Estimativas e acompanhamento do trabalho

A utilização de agentes também exige revisar a maneira como o esforço das tarefas é estimado.

O tempo necessário para escrever uma implementação manualmente deixa de ser uma referência suficiente quando parte significativa do código pode ser produzida por agentes.

Outros fatores passam a ter maior influência:

  • Complexidade das decisões técnicas.
  • Clareza dos requisitos.
  • Dependências e integrações.
  • Necessidade de investigação.
  • Cobertura e complexidade dos testes.
  • Esforço de revisão e validação.
  • Riscos associados às alterações.

Uma implementação extensa, mas bem especificada, pode ser concluída rapidamente. Já uma alteração aparentemente pequena pode exigir horas de investigação e validação.

Isso não significa que estimativas deixaram de ser necessárias, mas que precisam considerar o processo real de execução.

Acompanhamento no board

O progresso também deve ser acompanhado pelas entregas e pelos impedimentos relevantes.

Não é necessário atualizar o board toda vez que um agente conclui uma etapa interna.

O desenvolvedor pode manter checklists ou registros próprios da execução, enquanto o board principal apresenta o estado da demanda.

Estados como Ready, In Progress, Blocked, In Review e Done continuam úteis, desde que representem o andamento real da entrega.

O objetivo é reduzir o esforço administrativo e preservar a visibilidade necessária para a equipe.

Para avaliar gargalos e ganhos efetivos ao longo do processo, consulte Observabilidade e avaliação de esteiras com agentes de IA.

10. Adaptar o processo sem criar uma metodologia paralela

A adoção de agentes não exige necessariamente substituir Scrum, Kanban ou outras práticas existentes.

Grande parte da mudança pode acontecer na maneira como as demandas são preparadas, atribuídas e executadas.

Os boards continuam organizando prioridades, responsáveis, dependências e entregas.

O que muda é a relação entre um ticket e o trabalho necessário para concluí-lo.

Um único ticket pode representar uma funcionalidade completa, enquanto o desenvolvedor utiliza agentes, planos e checklists internos para organizar a execução.

Isso permite que equipes adotem novas ferramentas sem precisar criar uma estrutura administrativa para acompanhar cada agente ou cada operação realizada.

Também evita que a gestão do projeto se torne dependente de tecnologias específicas de orquestração.

A adaptação deve ser gradual, considerando a experiência da equipe, a maturidade dos processos de validação e a confiabilidade das ferramentas utilizadas.

Uma abordagem para introduzir essas mudanças nas equipes é apresentada em Adoção gradual de agentes de IA no desenvolvimento de software.

Conclusão

A programação com agentes de IA está reduzindo a necessidade de transformar cada etapa técnica em um ticket independente.

A decomposição continua importante, mas parte dela pode sair do board e passar a ser administrada pelo desenvolvedor durante a execução.

Isso favorece tickets com escopos mais completos, orientados a resultados, com contexto consistente, dependências relevantes e critérios de aceite verificáveis.

Ao mesmo tempo, a possibilidade de executar múltiplas atividades com agentes exige atenção à capacidade de revisão, coordenação e integração.

O objetivo não é simplesmente aumentar o tamanho dos tickets ou reduzir sua quantidade. É organizar o projeto em torno das entregas que precisam ser gerenciadas, deixando a decomposição técnica para o nível em que ela realmente agrega valor.