Pular para o conteúdo
Voltar para o blog
  • MongoDB
  • Express
  • React
  • NodeJS
  • Docker

Code Forge

A Forja do Rigor Onde a IA Audita o Processo e a Evidência é Lei

A história do Code Forge não é sobre a criação de código. É sobre a redefinição do que significa "conclusão" e "pronto" no desenvolvimento de software. Em um cenário onde a Inteligência Artificial (IA) se tornou uma ferramenta poderosa, a linha entre o código funcional e o processo auditável se tornou crítica. O Code Forge nasceu de uma premissa simples e, ao mesmo tempo, profundamente desconfortável:

"Se não existe evidência verificável, então não existe conclusão válida."

Este sistema open source não foi projetado para ser simpático. Ele foi projetado para ser **correto**. Ele é a formalização de um método de **gestão de projetos guiado por rigor**, onde a IA é elevada ao papel de auditora imparcial do processo, e a subjetividade é banida do aceite de etapas.

O Problema Silencioso da Gestão de Projetos

No desenvolvimento tradicional, a gente sempre cai nos mesmos problemas de gestão e validação:

  • A IA "concorda" com o que a gente diz, gerando um falso senso de segurança no planejamento.

  • Revisões de etapas e testes frequentemente se baseiam em critérios subjetivos ou implícitos.

  • A famosa frase "Funciona na minha máquina" vira, ironicamente, o critério de sucesso para o avanço de uma etapa.

  • Decisões de avanço de projeto não são rastreáveis, perdendo-se em *chats* ou reuniões.

O **Code Forge** resolve isso impondo uma estrutura de rigor, separando de forma clara e inegociável os papéis de criação, implementação e, principalmente, **validação do processo**. Ele é o guia de como sair de um projeto do zero e chegar ao final com **rastreabilidade total**.

A Autópsia Cronológica: A História Não Linear do Code Forge

A timeline real do desenvolvimento revela os pontos de inflexão que transformaram uma ideia vaga em um sistema com intenção clara de **auditoria de processo**.

Fase 0 – A Ideia Crua e o Escopo Nebuloso

Tudo começou com a intenção: "Quero uma aplicação de IA para me ajudar a planejar projetos."

Neste ponto inicial, a IA era vista como uma "geradora" de soluções, e não como um **sistema de validação**. A intenção era boa, mas o critério de conclusão era nebuloso. Este é o ponto onde a maioria dos projetos morre, feliz e confiante em sua própria subjetividade.

Fase 1 – Infra Primeiro, Ego Depois: O Batismo de Fogo

O primeiro corte sério com o "vamos ver depois" foi a decisão de começar pela infraestrutura. O projeto foi imediatamente ancorado em **Docker** e configurado para ser *self-hosted*. A infraestrutura mínima precisava estar viva antes de qualquer *feature*.

Isso resultou em um ambiente controlado, funcional, mas sem glamour. O projeto passou a existir no mundo real, rejeitando a tentação de começar pelo *frontend* bonito. Foi uma decisão-chave que estabeleceu o rigor desde o início.

Fase 4 – O Choque: O Ponto de Inflexão

Este foi o **momento mais importante**. A gente travou e percebeu: o objetivo não era um app genérico com LLM. O objetivo era **replicar exatamente o processo de rigor e auditoria** que a gente estava usando para construir o próprio Code Forge. A IA precisava ser **auditora do processo**, não só geradora de ideias.

"O objetivo era replicar exatamente o processo que estava acontecendo aqui: IA como geradora de plano + avaliadora de evidência + auditora do Step."

O resultado foi um **reset conceitual** e a reancoragem total da ideia. O projeto finalmente encontrou seu eixo: a **formalização do método**.

Fase 5 – Formalização do Método: O DNA do Code Forge

A partir daqui, o rigor se tornou lei. Foram definidos os elementos que compõem o DNA do sistema:

  1. **Steps Numerados:** Cada tarefa é uma etapa com escopo fechado.

  2. **Testes Obrigatórios:** Cada Step tem uma lista fechada de testes.

  3. **Evidência como Artefato:** O resultado da execução do teste é um artefato imutável.

  4. **IA como Validadora:** A IA verifica a evidência, não opina.

O sistema deixou de ser "criativo" e passou a ser **verificável**. A **separação rígida de papéis** e a **rejeição explícita de subjetividade** foram implementadas.

Fase 6 – Padrão de Evidência: O Contrato Humano-IA

O detalhe que elevou o projeto de "interessante" para **perigoso** (no bom sentido) foi a criação de um **padrão para o envio de testes**. Nasceu o **Template de Relatório de Evidências**, um contrato entre o humano e a IA:

  • O usuário ganha a **responsabilidade explícita** de fornecer a prova.

  • A IA ganha **limites claros** para sua atuação.

O sistema se tornou auditável, um ponto onde empresas tradicionais começariam a suar frio. A evidência é o contrato.

A Arquitetura Conceitual: O Rigor em 10 Passos

O **Code Forge** estrutura o desenvolvimento em **passos verificáveis**, cada um com critérios objetivos e evidências auditáveis. A arquitetura segue um fluxo de 10 passos, onde o avanço é um *gate* automatizado.

Passo 1 – Definição do Projeto

O projeto é criado com metadados iniciais, contexto técnico e de negócio. A entrega é um Project Descriptor versionado.

Passo 2 – Quebra em Steps

Cada projeto é dividido em Steps numerados e nomeados. Cada Step possui um objetivo explícito, escopo fechado, critérios de conclusão e testes obrigatórios. A entrega é o Step Definition Document.

Passo 3 – Planejamento Assistido por IA

A IA atua como analista técnico e questionador de ambiguidade, gerando um plano inicial e mapeando pontos de risco. Mas ela não decide nada sozinha. A entrega é o Plano Técnico Proposto.

Passo 4 – Implementação Humana ou Assistida

O código, configuração ou documentação são produzidos. A regra é clara: a implementação não avança o Step automaticamente. A entrega são os Artefatos Técnicos (código, config, docs).

Passo 5 – Definição Formal de Testes

Cada Step tem uma lista fechada de testes, com ID único, descrição objetiva e **critérios verificáveis**. A entrega é a Test Spec imutável para o Step.

Passo 6 – Execução Manual dos Testes

O usuário executa os testes no mundo real (CLI, UI, Logs, Prints). O sistema não confia no resultado, apenas no artefato. A entrega são as Evidências Brutas.

Passo 7 – Geração do Relatório de Evidências

Um relatório em Markdown padronizado é gerado, com blocos por teste, evidência verificável e resultado explícito (PASS | FAIL). A entrega é o Evidence Report.

Passo 8 – Validação Automatizada

Um Agente de IA atua como **auditor**. Ele não executa testes, não corrige relatório e não interpreta intenções. Ele apenas responde: accepted, partial ou rejected. A entrega é o Decision Trace e o Status do Step.

Passo 9 – Bloqueio ou Avanço

O Step rejeitado bloqueia o avanço. O Step aceito libera o próximo. Nenhum "jeitinho". O sistema impõe o rigor.

Passo 10 – Histórico e Rastreabilidade

Tudo fica registrado: quem fez, quando, com qual evidência e qual decisão foi tomada. A entrega é o Audit Log completo.

Diferenciais e Funcionalidades: Onde o Code Forge Força o Rigor

O valor do Code Forge reside em seus diferenciais técnicos, que o separam de qualquer ferramenta de gestão de projetos tradicional.

Diferencial 1: IA como Auditor, Não como Autoridade

A IA não é o autor do código, nem a autoridade final. Ela é o **auditor do processo**. Ela não "acha" que o processo está bom; ela **verifica** se a evidência apresentada cumpre o contrato. Este é um uso de IA que impõe rigor, não complacência.

Diferencial 2: Evidência como Contrato Inegociável

O sistema opera sob a lei da evidência. Sem evidência, não há conclusão. Isso força o desenvolvedor a ser explícito sobre o que está testando e o que está entregando. O Evidence Report é o contrato. Se o relatório diz PASS, a evidência deve provar isso de forma irrefutável.

Diferencial 3: Separação Rígida de Papéis da IA

Para evitar o viés cruzado, o Code Forge separa os papéis da IA:

  • IA de Planejamento: Questiona a ambiguidade do Step.

  • IA de Validação: Atua como auditor, verificando a evidência.

Nenhuma mistura. Nenhum viés cruzado. A decisão final de aceite é baseada em um Decision Trace gerado por um agente especializado.

Diferencial 4: Zero Subjetividade no Aceite

O processo de aceite é binário, rastreável e reproduzível. O sistema não aceita "talvez" ou "quase". O resultado é accepted ou rejected, com o Decision Trace como justificativa. Isso garante que o avanço do projeto seja sempre baseado em fatos.

Diferencial 5: Open Source de Verdade (GPL v3)

O Code Forge é licenciado sob **GPL v3**. O motivo é estratégico: garantir que a lógica, os *prompts* e as validações permaneçam abertas e auditáveis. Em um sistema que toma decisões técnicas, a transparência é fundamental. Isso evita a apropriação silenciosa do *core* e força a comunidade a manter o rigor.

Stack Tecnológica e Infraestrutura

O Code Forge é construído sobre uma stack moderna e robusta, projetada para ser *self-hosted* e portátil.

Componente Tecnologias Chave Função Backend Node.js / Bun, TypeScript, API REST Gerenciamento de Steps, Armazenamento de Evidências, Exposição da API de Validação. Frontend React, Vite, UI baseada em Steps e Evidências Interface para o usuário definir Steps, executar testes e fazer *upload* de Evidências. IA LLMs externos via API, Prompts versionados, Agentes especializados Atua como Agente de Planejamento e Agente de Validação (Auditor). Infraestrutura Docker, Ambiente local ou self-hosted Garante a portabilidade e o isolamento do ambiente de execução.

Planos Futuros: Evolução Coerente

O *roadmap* do Code Forge é focado em evolução coerente, sem promessas mágicas, apenas em aprimoramento do rigor.

Curto Prazo

  • Plugin de CI/CD: Integração para que a validação de Steps possa ser disparada automaticamente em *pipelines*.

  • Validação Automática de Evidências Sintáticas: Uso de IA para validar a sintaxe do Evidence Report antes de enviá-lo para o auditor principal.

  • Dashboard de Status: Visão clara do progresso e dos *gates* bloqueados por projeto.

Médio Prazo

  • Integração com GitHub/GitLab: Sincronização de Steps com *issues* e *pull requests*.

  • Assinatura de Evidência: Uso de criptografia para garantir a imutabilidade e a origem da evidência.

  • Multi-LLM Consensus Validator: Uso de múltiplos LLMs para validar a mesma evidência, aumentando a imparcialidade do aceite.

Longo Prazo

  • Evidence-as-Code: Definição de testes e critérios de evidência diretamente em código.

  • Compliance Audit Mode: Geração de relatórios de auditoria técnica para *compliance* (ISO, SOC, LGPD).

Conclusão: O Code Forge Não Tenta Ser Simpático

O Code Forge assume algo que a indústria de *software* muitas vezes evita: Pessoas erram, IA erra, e processos frouxos geram *software* frágil. Este sistema existe para quem valoriza a verdade técnica acima do conforto. É para quem prefere um **"não" bem justificado** do que um **"sim" confortável e errado**.

O Code Forge é a **formalização do rigor** que transforma o desenvolvimento em uma ciência auditável.

O projeto está aberto. Venha auditar o processo.

Repositório Open Source: Código Fonte do Code Forge

Vídeo Demonstrativo: Veja como o Code Forge funciona