Construí e lancei um RPG Idle completo usando IA como único "engenheiro"

Fazer um "hello world" ou uma landing page com IA é simples. O meu objetivo com este projeto foi testar algo diferente: até onde um agente de IA de código (Claude Code) consegue ir em um produto real, complexo e publicável, desde que as decisões de arquitetura sejam estritamente controladas por um humano experiente?

O resultado desse experimento é o Therryn, um RPG idle/management gratuito que roda direto no browser. Mas o foco deste post não é divulgar o jogo em si, e sim compartilhar os aprendizados técnicos, de arquitetura e de fluxo de trabalho.

A Dinâmica do Experimento
Tratei o projeto como se eu estivesse liderando uma equipe onde o único desenvolvedor era a IA. Eu assumi a arquitetura, o design do modelo de dados, as regras de negócio, os trade-offs e, principalmente, o code review. O Claude escreveu essencialmente toda a implementação.

O ciclo era rígido: especificar a intenção técnica -> deixar implementar -> revisar criticamente -> testar -> iterar.

A Arquitetura e a Stack (Como não deixar a IA criar um código espaguete)
Para que o agente não se perdesse e o projeto não virasse um legado intratável em duas semanas, impus limites arquiteturais claros:

O Core (O maior acerto): C# puro (.NET 9). Criei um motor de jogo server-authoritative sem dependências de frameworks no core. Todas as regras vivem em uma biblioteca isolada, fortemente tipada e testável via xUnit.

Simulação "Lazy" vs. Tempo Real: Em vez de manter um loop em tempo real rodando no servidor, o progresso idle é uma simulação preguiçosa. Quando o jogador retorna, o servidor resolve todas as missões e "N" execuções de uma só vez (processando até ~12h de inatividade em uma passada).

API & Persistência: ASP.NET Minimal API e PostgreSQL para o banco de dados.

O Client é "Burro": React + TypeScript + Vite. A regra máxima foi: "o cliente apenas renderiza, o servidor decide". Isso eliminou uma classe gigantesca de potenciais bugs gerados por IA e fechou as portas para trapaças fáceis.

Infra: Backend hospedado na Railway, pagamentos (para aceleradores no jogo) via Stripe com webhooks idempotentes.

O que realmente funcionou
Isolar as regras de negócio em um core C# puro pagou muitos dividendos. A IA conseguia raciocinar muito bem sobre lógicas de domínio em arquivos isolados e gerar testes unitários eficientes para validar aquela regra específica.

Ciclos de feedback curtos (build + execução de testes de domínio + verificação no browser) foram o que geraram confiança no código que estava sendo entregue.

Onde a IA quebra (e onde o humano é vital)
"Taste" e Senso de Produto: A IA não sabe o que é divertido, se a economia está justa ou se a interface do usuário está passando a sensação correta.

Consistência Cross-cutting: Garantir que uma alteração estrutural no banco de dados propagasse corretamente para a DTO da API e, depois, para o estado do React exigia supervisão constante. O agente perde o contexto do "todo" facilmente.

Bugs sutis e Lógica de Negócio: Em um momento, a IA implementou um botão de "finalizar missão" que funcionava perfeitamente no código, mas a lógica que ela escreveu finalizava todas as missões ativas silenciosamente, em vez de apenas a selecionada. Sem revisão focada no contexto de negócio, isso iria para produção.

O jogo está no ar e estável, e provou o ponto: a IA é um excelente braço de execução, mas se não houver um humano segurando a fundação arquitetural, o projeto desmorona.

Se alguém quiser testar a carga do servidor jogando, fiquem à vontade. Queria abrir o espaço para debatermos: alguém mais tem usado agentes de código com arquiteturas estritas dessa forma? Como vocês estão lidando com a perda de contexto deles em projetos que começam a escalar?