Clonei o Tella.tv com apenas um prompt — utilizando menos de 5% da minha cota semanal do claude code com o Jarvis Ade · lalves

Um prompt. Nenhum passo a passo. Um produto inteiro para construir.

Resolvi fazer um teste que, até pouco tempo atrás, pareceria absurdo:

Pedi para uma equipe de agentes de IA recriar o Tella.tv e deixei ela trabalhar.

Não fui criando página por página.

Não fiquei dizendo qual componente deveria ser implementado em seguida.

Não passei dezenas de prompts guiando cada decisão.

Dei o objetivo e deixei o Jarvis ADE assumir a execução.

O resultado foi este:

🎥 https://youtu.be/JJB9c8yQqGE

Repositório do projeto : https://github.com/Vidiio-Org/jarvis-vidiio-app

E o mais interessante não foi simplesmente ver uma IA escrevendo muito código.

Foi perceber que escrever código está começando a deixar de ser o gargalo.

O problema agora é outro:

Como fazer múltiplos agentes planejarem, dividirem e executarem um projeto inteiro sem precisar de um humano coordenando cada passo?

É exatamente isso que estamos tentando resolver com o Jarvis ADE.

A diferença entre gerar código e construir software

Hoje temos ferramentas de IA extremamente boas para programação.

Você pode pedir:

“Crie essa página.”

Depois:

“Agora implemente autenticação.”

Depois:

“Corrija esse erro.”

Depois:

“Crie os testes.”

Isso já mudou completamente a produtividade de muitos desenvolvedores.

Mas existe um detalhe:

você ainda é o gerente da IA.

**É você quem constantemente precisa decidir:
**
O que fazer
↓
Como dividir
↓
O que fazer primeiro
↓
Executar
↓
Verificar
↓
Corrigir
↓
Dar o próximo prompt

A IA programa. Mas você continua orquestrando. Foi aí que nasceu a ideia por trás do Jarvis.

E se a IA também pudesse coordenar o desenvolvimento?

Em vez de construir apenas mais um coding agent, começamos a trabalhar em algo um pouco diferente.

Um ADE — Autonomous Development Environment.

A ideia é que você não entregue necessariamente uma tarefa.

Você entrega uma missão.

Por exemplo:

“Recrie esse produto.”

O Jarvis transforma isso em um plano e coordena agentes para executar o trabalho.

                SUA MISSÃO
                     │
                     ▼
                ┌─────────┐
                │ JARVIS  │
                └────┬────┘
                     │
                   PLANO
                     │
      ┌──────────────┼──────────────┐
      ▼              ▼              ▼
  Frontend        Backend         DevOps
      │              │              │
      └──────────────┼──────────────┘
                     ▼
                    QA
                     │
                     ▼
                 ENTREGA

Algumas tarefas possuem dependências.

Outras podem acontecer simultaneamente.

Agentes podem trabalhar em diferentes partes do projeto enquanto o sistema acompanha o estado geral da missão.

A mudança parece pequena, mas conceitualmente é enorme.

Estamos tentando sair de:

Humano → prompt → código

para:

Humano → objetivo → equipe de agentes → software

Foi aí que resolvemos tentar recriar o Tella.tv

Precisávamos de um teste suficientemente grande para expor os problemas dessa abordagem.

Não queríamos:

“Faça uma landing page.”

Queríamos algo que obrigasse o sistema a lidar com um projeto significativamente maior.

Escolhemos o Tella.tv como referência.

Então entregamos a missão ao Jarvis.

E começamos a observar.

O Jarvis precisou lidar com coisas que vão muito além de simplesmente completar código:

planejamento → divisão de trabalho → implementação → coordenação → integração → validação → correções.

E vários agentes puderam atuar sobre partes diferentes da missão.

Tudo partindo daquela instrução inicial.

O resultado completo está no vídeo:

🎥 https://youtu.be/JJB9c8yQqGE

Observação importante: quando digo “recriamos o Tella”, estou me referindo à versão demonstrada no vídeo. Não estou afirmando paridade 1:1 com toda a infraestrutura, backend e funcionalidades internas do produto original.

E isso me fez perceber uma mudança maior

Acredito que estamos passando por três fases no desenvolvimento com IA.

Autocomplete
Humano escreve código
↓
IA prevê o próximo código
AI Coding
Humano descreve uma tarefa
↓
IA implementa
AI Software Engineering
Humano define um objetivo
↓
IA planeja
↓
Agentes se coordenam
↓
Agentes executam
↓
Sistema valida
↓
Software

É essa terceira etapa que considero particularmente interessante.

Porque nesse ponto gerar código deixa de ser o problema central.

Coordenação passa a ser o problema.

Contexto passa a ser o problema.

Paralelismo passa a ser o problema.

Validação passa a ser o problema.

Confiabilidade passa a ser o problema.

E esses são problemas muito parecidos com aqueles encontrados ao coordenar uma equipe de engenharia humana.

Talvez estejamos mudando a abstração da programação

Não acredito que a parte mais interessante dessa discussão seja:

“A IA vai substituir programadores?”

Existe uma pergunta tecnicamente muito mais interessante:

Qual será o nível de abstração utilizado por um programador?

Já programamos diretamente em níveis muito mais baixos.

Criamos linguagens.

Criamos frameworks.

Criamos serviços de cloud.

Cada camada permitiu que desenvolvedores expressassem uma intenção maior utilizando menos instruções.

Agentes podem representar outra mudança desse tipo.

Talvez o desenvolvedor passe cada vez mais tempo definindo:

arquitetura, requisitos, restrições, produto, critérios de qualidade e validação.

E cada vez menos tempo dizendo ao computador exatamente como implementar cada linha.

Foi assim que o Jarvis ADE nasceu

O curioso é que inicialmente o Jarvis nem deveria virar uma empresa/produto separado.

Eu estava construindo outros produtos e comecei a criar uma infraestrutura interna para coordenar agentes de desenvolvimento.

Só que ela foi crescendo.

Mais agentes.

Mais autonomia.

Mais coordenação.

Mais observabilidade.

Até chegar um momento em que percebi:

a ferramenta que estávamos construindo para criar nossos produtos estava começando a se tornar mais interessante do que alguns dos próprios produtos.

Foi daí que nasceu o:

Jarvis ADE — Autonomous Development Environment.

A ideia que estamos perseguindo é simples de explicar:

Você define a missão.
O Jarvis coordena a engenharia.

Ainda temos muitos problemas difíceis pela frente.

Contexto entre agentes, conflitos, avaliação automática, custos, execução paralela, confiabilidade, recuperação de erros e observabilidade são alguns deles.

Mas é exatamente isso que torna esse espaço tão interessante.

Estamos abrindo o projeto e mostrando esses experimentos conforme avançamos.

Quem quiser acompanhar:

Jarvis ADE

E deixo uma pergunta para quem trabalha com desenvolvimento:

Se uma equipe de agentes consegue receber um objetivo e executar horas de trabalho autonomamente, qual passa a ser o papel da IDE?

Talvez a próxima grande ferramenta para desenvolvedores nem seja uma IDE.

Talvez seja o lugar onde você gerencia quem está programando por você.