cerebro-vip INEMA.CLUB
início › INEMA.IA CONCEITOS

Documentação e resumo prático de um experimento de 24h usando o…

INEMA.IA CONCEITOS · 2025-12-21 · ~10 min · ver no Telegram ↗

INEMA

RECOMENDADO)

  • 👉 Usado como system prompt no SDK/CLI
  • 👉 Serve para disciplina e segurança

```You are an autonomous coding agent operating inside a restricted sandbox.

Rules: - Only modify files inside the project directory. - Never delete the project or git history. - Never modify validation steps in feature_list.json. - Never skip regression checks. - Prefer small, incremental changes. - Always leave the project in a working state.```

4️⃣ COMO USAR NA PRÁTICA (RESUMO)⌗

🔹 Com CLI⌗

  1. Sessão 1 → usar initializer_prompt.md
  2. Sessão 2+ → usar coding_prompt.md
  3. Sempre reapontar para o mesmo diretório

🔹 Com SDK (Python/TS)⌗

  • Se git repo não existe → prompt do initializer
  • Caso contrário → prompt do coding agent
  • Rodar em loop

5️⃣ ARQUIVOS OBRIGATÓRIOS NO PROJETO⌗

/app_spec.md /feature_list.json /claude_progress.md /init_project.sh (ou .js/.py) .git/

6️⃣ POR QUE ISSO FUNCIONA⌗

  • Contexto é externalizado em arquivos
  • Cada agente é curto, focado e verificável
  • Git vira memória de longo prazo
  • Testes impedem alucinação
  • Pequenos passos evitam colapso

Perfeito. Abaixo estão os PROMPTS EXATOS (em versão prática) usados no método do vídeo, quando usar cada um e como usar. Eles estão adaptados para você copiar e colar (CLI, SDK ou outro agente).

1️⃣ PROMPT DO INITIALIZER AGENT⌗

  • 👉 Usar UMA ÚNICA VEZ (Sessão 1)
  • 👉 Objetivo: criar toda a base do projeto (sem implementar features)

📄 Arquivo: initializer_prompt.md⌗

```You are the FIRST agent in a long-running autonomous software development process.

You are starting with a completely empty project directory.

You are given an App Spec (PRD) that fully describes the application to be built. Your job is NOT to implement application features.

Your responsibilities are strictly limited to the following tasks:

  1. Carefully read and fully understand the App Spec.
  2. Break the App Spec into a VERY DETAILED feature list with granular, testable items.
  3. Create a feature_list.json file with at least 200 features.

Each feature MUST contain: - id - category - description - validation_steps (clear, verifiable steps) - passes (boolean, initially false)

  1. Create an initialization script that: - sets up the project structure - installs dependencies if needed - starts the application locally

  2. Create a basic project scaffold (boilerplate only). The application does NOT need to work yet.

  3. Initialize a git repository and create the first commit.

  4. Create or update claude_progress.md with: - a summary of what you created - instructions for the next agent

STRICT RULES: - Do NOT implement application features. - Do NOT mark any feature as passing. - Do NOT remove or simplify validation steps. - Focus on clarity, structure, and completeness.

When finished: - Ensure all files are saved - Ensure the project can be initialized via the init script - End the session.```

🧠 Quando usar⌗

  • Sempre no início de um projeto novo
  • Apenas uma vez
  • Sessão 1

2️⃣ PROMPT DO CODING AGENT⌗

👉 Usar em TODAS as sessões seguintes (Sessão 2 até N) 👉 Objetivo: implementar uma feature por sessão, com testes e validação

📄 Arquivo: coding_prompt.md⌗

```You are a coding agent in a long-running autonomous development system.

You are entering a NEW context window. Assume you have no memory beyond the files in the project.

Follow this process EXACTLY and IN ORDER:

──────────────────────── PHASE 1 — ORIENTATION ────────────────────────

  1. Read the App Spec (PRD) to understand the product goals.
  2. Read claude_progress.md to understand what was done previously.
  3. Read feature_list.json to identify completed and pending features.
  4. Review recent git commits to understand current project state.

──────────────────────── PHASE 2 — INITIALIZATION ────────────────────────

  1. Run the project initialization script to start the application.
  2. Verify the app starts successfully.

──────────────────────── PHASE 3 — REGRESSION CHECK ────────────────────────

  1. Select 1–3 features marked as "passes": true.
  2. Verify they still work as described in their validation steps.
  3. If any regression is found: - Mark the feature as "passes": false - Fix the issue before continuing.

──────────────────────── PHASE 4 — FEATURE IMPLEMENTATION ────────────────────────

  1. Select ONE feature marked as "passes": false.
  2. Implement the feature EXACTLY as described.
  3. Validate the feature using:
    • tests
    • manual checks
    • browser automation if applicable

STRICT RULE: - You MAY ONLY change "passes": false → "passes": true. - You MUST NOT edit descriptions or validation steps.

──────────────────────── PHASE 5 — FINALIZATION ────────────────────────

  1. Update claude_progress.md with:

    • what feature was implemented
    • files modified
    • how to validate manually
    • known limitations

  2. Create a git commit describing the feature.

  3. End the session.```

🧠 Quando usar⌗

  • Sessão 2 em diante
  • Uma execução = uma feature
  • Repetir quantas vezes quiser (horas ou dias)

3️⃣ PROMPT DO SYSTEM (OPCIONAL, MAS⌗

Aqui vai o passo a passo direto (bem prático) do método do vídeo — do zero até rodar por 24h:

  1. Escreva o App Spec (PRD)
  • Um arquivo .txt/.md descrevendo exatamente o que o app precisa ter (escopo do MVP, telas, fluxos, regras).
  1. Rode o “Initializer Agent” (Sessão 1) Ele só prepara a base e gera 4 coisas:
  • feature_list.json com ~200+ testes/itens (cada um com passes: false)
  • script de init (para subir o projeto/servidor sempre que um novo agente começar)
  • boilerplate + estrutura do projeto
  • git init + primeiro commit
  • cria/atualiza o arquivo claude_progress.md com o resumo do que foi feito

  1. Comece o loop dos “Coding Agents” (Sessões 2…N) Cada sessão é um agente novo (contexto novo), que faz sempre este ciclo:

  2. Priming (pegar contexto rápido)

  • Lê o App Spec
  • Lê o claude_progress.md (o que o último agente fez)
  • Lê o feature_list.json (o que falta)
  • Olha o git log e arquivos principais do projeto
  1. Sobe o projeto pelo script de init
  • Executa o script de inicialização para colocar o app rodando localmente.
  1. Regression check (checar se algo que estava “true” quebrou)
  • Testa 1–3 features marcadas como passes: true

  • Se falhar:

  • volta a feature para false

  • corrige antes de continuar
  1. Escolhe a próxima feature passes: false
  • Pega a primeira (ou próxima) da lista.
  1. Implementa a feature
  • Codifica exatamente o necessário para cumprir os passos de validação.
  1. Valida com testes + (opcional) navegador
  • Roda testes automatizados
  • Usa automação (tipo Puppeteer) para verificar no browser quando fizer sentido
  1. Marca a feature como concluída
  • No feature_list.json, muda somente passes: false → true (não altera os passos).
  1. Atualiza o “estado” do projeto

  • Atualiza claude_progress.md com:

  • o que fez

  • arquivos alterados
  • como validar
  • próximos itens sugeridos
  • Faz git commit (um commit por sessão/feature)
  1. Repete o loop por horas (ex.: 24h)

  • Até:

  • todos os testes/itens virarem true, ou

  • você parar e entrar como humano pra finalizar polimento

Se você quiser, eu te devolvo isso como um roteiro de implementação (arquivos obrigatórios + modelo de feature_list.json + modelo de claude_progress.md + estrutura mínima de pastas) pronto pra copiar e usar.

explícitas * Hooks personalizados * Execução autônoma real

9. Segurança e controle⌗

  • O agente:

  • Só acessa o diretório do projeto

  • Não pode apagar arquivos arbitrários
  • Não pode sair do sandbox
  • Comandos bash são filtrados por script Python.
  • Puppeteer é controlado.
  • Tudo é rastreável via Git.

10. Execução do experimento (24 horas)⌗

  • Modelo usado: Claude Opus 4.5

  • Total:

  • 54 sessões de coding agent

  • 54% dos testes passando
  • Mais de 100 features completas

  • Custos:

  • Tokens altos, mas mitigados usando assinatura Claude

  • Muito tempo gasto esperando automação do browser (não só tokens)

11. Resultado final da aplicação⌗

Mesmo com apenas 54% dos testes:

  • Interface extremamente rica
  • Conversas persistentes
  • Markdown avançado
  • Execução de código

  • Configurações:

  • Tema

  • Modelo
  • Max tokens
  • Contagem de tokens
  • Histórico
  • UI funcional (embora imperfeita)

👉 Já parece um clone real do Claude.ai, mesmo incompleto.

12. Limitações observadas⌗

  • UI não perfeita
  • Alguns bugs
  • Harness teve pequenas inconsistências (ex: numeração de sessões)
  • Ainda precisa de humano no loop
  • Últimos testes são detalhes finos (scroll, mobile, divisores)

13. Conclusões do autor⌗

  • O sistema funciona surpreendentemente bem.
  • Não entrou em colapso nem alucinou após dezenas de sessões.
  • A abordagem da Anthropic é sólida.
  • Long-running agents são o futuro do desenvolvimento assistido por IA.

  • Excelente para:

  • Provas de conceito

  • MVPs
  • Bootstrap de projetos grandes

14. Recomendações finais⌗

  • Clonar o repositório open-source
  • Modificar o App Spec para seu próprio projeto
  • Usar com qualquer stack (frontend, backend, full-stack)
  • Ideal se houver UI (para aproveitar Puppeteer)
  • Aprender mais via cursos de Agentic Coding

15. Ideia central do vídeo (em uma frase)⌗

Com um bom harness, agentes de IA conseguem construir aplicações complexas de forma autônoma por dias, com progresso real, testável e acumulativo.

1. Contexto e motivação do experimento⌗

  • A Anthropic open-sourçou um “harness” para agentes de longa duração (long-running agents).
  • Esse harness é uma camada de coordenação que permite que agentes de IA trabalhem por horas ou dias, sem estourar o limite de contexto.
  • A ideia central é dividir o trabalho em múltiplos agentes, cada um com um novo contexto, mas mantendo continuidade via arquivos compartilhados.
  • O autor decide testar na prática: forçar o Claude Code a programar por 24 horas ininterruptas.
  • Objetivo: validar se isso funciona no mundo real ou se é só marketing.

2. O que é o “harness” de agentes long-running⌗

  • Não é um modelo novo, nem magia.
  • É um conjunto de prompts + arquivos + processos.

  • Serve para:

  • Orquestrar vários agentes

  • Preservar estado entre execuções
  • Garantir progresso incremental
  • Evitar perda de contexto

👉 Pode ser usado com Claude, CodeX, OpenCode ou qualquer outro agente de código.

3. Projeto escolhido para o teste⌗

  • Aplicação construída: clone do Claude.ai (interface web).

  • Motivo:

  • É o mesmo exemplo usado pela Anthropic no artigo.

  • Permite validar se o resultado final é realmente funcional.

  • Funcionalidades esperadas:

  • Conversas

  • Upload de arquivos
  • Projetos
  • Artefatos
  • UI completa
  • Configurações
  • Histórico
  • Execução de código

4. Princípio central: Test-Driven Development (TDD)⌗

  • Tudo começa definindo os critérios de sucesso, não o código.

  • Antes de escrever código:

  • Define-se centenas de testes.

  • O sistema só considera o app “pronto” quando todos os testes passam.

  • Cada feature é:

  • Pequena

  • Validável
  • Testável
  • Marcada como true/false

5. Os 3 artefatos centrais do harness⌗

5.1 App Spec (PRD)⌗

  • Arquivo de texto descrevendo:

  • Escopo completo do MVP

  • Funcionalidades
  • Requisitos
  • Serve como contexto inicial para o sistema.

5.2 Feature List (JSON)⌗

  • Arquivo gigantesco com 200+ features/testes.

  • Cada item contém:

  • Categoria

  • Descrição
  • Passos de validação
  • Campo passes: true | false
  • O agente não pode alterar os testes, apenas marcar como concluído.

5.3 Claude Progress⌗

  • Arquivo de memória compartilhada entre agentes.
  • Atualizado ao final de cada sessão.

  • Contém:

  • O que foi feito

  • O que está funcionando
  • Próximos passos
  • Permite continuidade mesmo com contexto zerado.

6. Inicializer Agent (Agente Inicial)⌗

Primeira sessão do sistema.

Funções:

  1. Ler o App Spec (PRD)
  2. Criar o Feature List JSON
  3. Criar script de inicialização do projeto
  4. Criar boilerplate do app
  5. Inicializar repositório Git
  6. Criar o primeiro Claude Progress

👉 Ele não implementa features, só prepara o terreno.

Tempo:

  • 10 a 20 minutos
  • Principal custo: gerar os testes detalhados

7. Coding Agents (Agentes de Código)⌗

Cada nova sessão roda um novo agente, com novo contexto.

Ciclo de cada Coding Agent:⌗

  1. Priming (entendimento do estado)
  • Lê PRD
  • Lê Feature List
  • Lê Claude Progress
  • Lê histórico do Git
  1. Inicialização
  • Roda script para subir o app
  • Reconstrói ambiente
  1. Regression Testing
  • Verifica se features já marcadas como true continuam funcionando

  • Se algo quebra:

    • Marca como false
    • Corrige antes de continuar
  1. Escolha de nova feature
  • Seleciona a próxima feature com passes: false
  1. Implementação
  • Escreve código
  • Testa
  • Valida visualmente (browser)
  1. Validação automatizada
  • Usa Puppeteer MCP Server
  • Navega no site
  • Clica, carrega páginas, tira screenshots
  1. Finalização
  • Marca a feature como true
  • Atualiza Claude Progress
  • Cria commit no Git

🔁 Esse ciclo se repete indefinidamente.

8. Uso do Claude Agent SDK (não CLI)⌗

  • O autor não usa o Claude Code CLI.
  • Usa o Claude Agent SDK via Python.

  • Vantagens:

  • Controle total

  • Segurança
  • Permissões

youtube.com/watch ↗

Agente Hardness 24Horas

1

Recursos

↑ voltar ao topo · ver no Telegram ↗