Como construir uma equipe de agentes de IA e desenvolver seu primeiro jogo em menos de 2 horas

Olá! Eu sou a Álli. Trabalho liderando inovação com inteligência artificial e gosto de levar essa prática para fora do trabalho também.

Desta vez, levei para um terreno que eu nunca tinha explorado: criar um jogo. A abordagem que apliquei aqui foi tratar a IA como um time — pesquisando antes de construir, distribuindo papéis e entrando como direção. Usei o Claude, na opção Cowork (o app de desktop, em que você dá à IA acesso a uma pasta do seu computador para ela trabalhar dentro dela). Rodo no plano Max (5x), com o modelo Claude Opus 4.8 em nível de esforço (raciocínio) alto — para mim, o melhor equilíbrio entre qualidade das respostas e consumo de tokens.

O resultado foi um jogo jogável em menos de 2 horas. Antes de te contar como cheguei lá, dá uma olhada nele rodando:

Se quiser jogar agora, está aqui: https://alliterhorst.github.io/neon-vanguard/. É uma versão experimental, então vai com expectativa de protótipo.

Neste texto eu mostro o caminho que segui, passo a passo, pra você poder usar como ponto de partida nos seus próprios projetos.

A conta do tempo

O que mais me chamou atenção não foi o jogo rodar — foi onde o tempo foi parar. Uma estimativa do trabalho efetivo por etapa:

Etapa	Tempo aprox.
Pesquisa da stack e definição do escopo	~15–20 min
Geração da equipe de agentes	~40 min
Construção da primeira versão jogável	~40 min
Testes e ajustes	~15 min
Total (do início ao jogável)	menos de 2 horas

Repare que a parte mais demorada não foi escrever o jogo, e sim montar a equipe de agentes que iria escrevê-lo. Foram nas decisões — o que construir, como equilibrar, o que cortar — que o meu tempo foi parar.

Como eu fiz

A primeira coisa que fiz não foi codar. Em vez de especificar cada detalhe, deleguei decisões e pedi investigação, como faria com um time sênior. Foram três movimentos.

1. Antes de escolher a tecnologia, pedi uma pesquisa ancorada no que já deu certo.
Não cravei a stack de cara. Fui atrás de evidência real: quais tecnologias as pessoas relatam os melhores resultados e mais cases de sucesso usando o Claude para desenvolver jogos de navegador. Para isso, rodei vários agentes de pesquisa em paralelo, cada um numa sub-pergunta específica. Este foi o pedido inicial:

"Quero criar um jogo de nave (shoot'em-up) com visual retrô 16-bit, que rode no navegador. Pesquise a fundo quais tecnologias as pessoas relatam ter os melhores resultados e mais cases de sucesso usando o Claude para desenvolver jogos de navegador. Compare 2D e 3D, veja o que existe de bibliotecas gratuitas e me traga os trade-offs."

A lógica por trás disso: o modelo rende mais em tecnologias populares e bem documentadas, e os relatos confirmaram. Para web, o caminho mais consistente foi JavaScript com Phaser no 2D (e Three.js, se fosse 3D). Como o meu plano era um jogo retrô em 2D, fui de Phaser, com um kit gratuito: Vite no build, Tone.js na trilha chiptune, e sprites e efeitos sonoros gerados por código.

2. Montei um time inspirado num estúdio indie — em dois passos.
Aqui veio a parte que mais fez diferença. Primeiro, pedi um mapa dos papéis de um estúdio de verdade:

"Pesquise todos os profissionais e as etapas de desenvolvimento de um estúdio de jogos indie (de baixo orçamento): do game design à arte, áudio, level design, balanceamento e QA."

Com esse mapa em mãos, pedi para transformá-lo numa estrutura de trabalho dentro do projeto:

"Crie uma subpasta e, dentro dela, monte agentes, skills e um orquestrador que se comportem como esses papéis, coordenados por um documento central com todas as decisões. Depois, construa a primeira versão jogável."

Foi a etapa mais demorada, cerca de 40 minutos. Mas é o que sustenta o resto: o documento central de decisões guarda a stack, as regras de balanceamento, a estética e como os sistemas conversam. É ele que mantém todos os agentes coerentes entre si — sem ele, cada um resolveria a mesma questão de um jeito, e as partes não se encaixariam.

3. Deleguei o "como" e entrei como direção.
Em vez de revisar cada linha, deixei o modelo resolver os detalhes — game feel, balanceamento, estética — dentro de restrições claras, e acompanhei como quem dirige.

"Decida o 'como' dentro destas restrições: uma paleta de cores fixa e um esquema de controle fixo (a nave segue o ponteiro, com tiro automático). Me mostre o resultado para eu revisar."

As restrições foram o que destravou o resultado. Uma paleta definida e um controle fixo deram unidade ao jogo e liberaram a criatividade da IA dentro de um contorno, em vez de limitá-la.

E a qualidade do código?

É uma pergunta justa. Em vez de prometer, prefiro mostrar o que dá para medir:

• 16 testes automatizados de lógica passando.
• Build de produção sem erros.
• Arquitetura data-driven: o comportamento do jogo (waves, inimigos, balanceamento) vive em dados, não espalhado pelo código.
• Separação de responsabilidades: cada sistema com sua fronteira, cada arquivo com seu dono, os números no config (zero número mágico solto no código).

Construir rápido e construir com cuidado podem caminhar juntos quando a verificação faz parte do processo, não vem depois dele. Por isso os testes e o build limpo entraram desde cedo, e não só no fim.

A Fase Zero

Eu encaro essa versão jogável como a Fase Zero do projeto: o ponto de partida. No plano que montamos para construir o jogo, ela é a base — funcional, testada e jogável — e é das próximas fases em diante que vem a profundidade. A pergunta da Fase Zero era simples: dá para sair do zero a um jogo jogável, com testes passando, orquestrando agentes, em menos de duas horas? Deu.

As próximas fases

Daqui pra frente, o time de agentes vai trabalhar bastante o design: mais detalhes visuais, mais animações, mecânicas novas e ajuste fino de game feel. Quero ver até onde a abordagem escala conforme o projeto fica mais complexo.

Se você curte esse tipo de coisa, me acompanha pra ver a evolução deste jogo e os próximos experimentos que eu for fazer:

• LinkedIn: https://www.linkedin.com/in/alliterhorst/
• GitHub: https://github.com/alliterhorst
• Repositório: https://github.com/alliterhorst/neon-vanguard

E me conta nos comentários: se fosse começar um experimento assim, por onde você começaria? Quem já construiu algo com agentes, como organizou o trabalho?