💻 computer science

Jas: AI-Paired Engineering as a Revival of N-Version Programming

Este artigo apresenta um estudo de caso demonstrando que a engenharia pareada com IA, quando ancorada por uma especificação executável precisa e validada através de implementações paralelas de N-versões, permite que um único desenvolvedor produza cinco portas de software distintas em aproximadamente 120 horas, revivendo efetivamente a metodologia de programação de N-versões da década de 1980, que era proibitiva em termos de custo.

Autores originais: Jason Hickey

Publicado 2026-06-09

📖 5 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Jason Hickey

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

Imagine que você queira construir cinco versões diferentes de um aplicativo de desenho complexo e de alto nível (como um mini-Adobe Illustrator). Nos velhos tempos, isso seria como contratar cinco arquitetos mestres diferentes, cada um falando uma língua diferente, para projetar a mesma casa. Levaria anos e custaria uma fortuna.

Jason Hickey, um único desenvolvedor, fez algo diferente. Ele construiu cinco versões funcionais deste aplicativo (para Rust, Swift, OCaml, Python e um navegador web) em apenas sete semanas, trabalhando apenas no período da noite. Ele não contratou uma equipe; ele usou a IA como sua parceira.

Aqui está como ele fez isso, explicado de forma simples:

1. O "Projeto Mestre" (A Especificação Executável)

Normalmente, quando você constrói software para diferentes plataformas, tem que escrever as regras do aplicativo do zero cinco vezes. Se você quiser mudar como um seletor de cores funciona, terá que atualizar cinco bases de código diferentes.

Hickey fez o oposto. Ele escreveu um único "Projeto Mestre" (um documento de 23.000 linhas escrito em uma linguagem chamada YAML).

A Analogia: Pense neste projeto não como um PDF estático, mas como uma receita viva. Ele não diz apenas "faça um botão vermelho"; ele diz: "Aqui está exatamente como o botão se parece, como ele reage quando você clica nele e o que acontece em seguida".
A Magia: Este projeto é "executável". O computador lê esta única receita e constrói automaticamente a interface do usuário para todos os cinco aplicativos. Se Hickey quiser mudar uma regra, ele a altera em um só lugar, e ela atualiza instantaneamente os cinco aplicativos.

2. O "Dragão de Cinco Cabeças" (Programação N-Versão)

Nos anos 1980, engenheiros tentaram um método chamado "Programação N-Versão". A ideia era: "Se construirmos cinco versões diferentes de um sistema de forma independente, e todas concordarem, então deve estar correto. Se elas discordarem, saberemos que algo está errado".

O Problema: Era caro demais. Construir cinco versões diferentes de um código usando cinco equipes diferentes era um desperdelo de dinheiro.
A Reviravolta da IA: Hickey reviveu essa ideia usando IA. Como a IA pode fazer o trabalho pesado de escrever o código para as diferentes linguagens, ele pôde se dar ao luxo de construir cinco versões sendo uma única pessoa.
A Rede de Segurança: Essas cinco versões agem como um júri de cinco pessoas. Se a versão em "Rust" do aplicativo faz uma cor ficar vermelha, mas a versão em "Python" faz a cor ficar azul, o sistema imediatamente sinaliza um problema. Eles realizam o "teste diferencial" entre si. Se eles discordarem, significa que o Projeto Mestre estava obscuro ou que uma das versões cometeu um erro.

3. O "Escape Hatch" (Escotilha de Escape)

O Projeto Mestre cobre cerca de 90% do trabalho. Mas, às vezes, uma plataforma de computador específica (como um iPhone ou um navegador web) precisa de um truque especial que o projeto geral não consegue descrever.

A Analogia: Imagine que o projeto é a planta de uma casa padrão. Mas a casa de "Rust" precisa de um porão reforçado especial porque o solo é rochoso. O projeto lida com as paredes e o telhado para todos, mas a equipe de "Rust" tem que construir seu próprio porão especial.
Hickey chama isso de Escape Hatch. É a pequena quantidade de código personalizado necessária para cada plataforma específica, enquanto o restante é compartilhadamente utilizado.

4. Como o Processo Funcionou (O Ciclo)

Hickey não apenas digitou código e esperou que desse certo. Ele usou um ciclo específico:

Design: Ele escreveu um plano em inglês simples.
Revisão de IA: Ele pediu à IA para encontrar falhas no plano ("O que está faltando? O que está confuso?").
Atualização do Projeto: Ele atualizou o Projeto Mestre com base nos conselhos da IA.
Construção e Teste: A IA gerou o código para todos os cinco aplicativos.
O "Olhar Humano": Esta foi a parte mais lenta. Hickey olhou manualmente para todos os cinco aplicativos lado a lado. Se um parecesse estranho, ele sabia que o Projeto precisava de ajustes.

O Resultado

Tempo: ~120 horas de trabalho noturno (cerca de 7 semanas).
Saída: Cinco aplicativos totalmente funcionais compartilhando a mesma lógica central.
Custo: Em vez de "múltiplos anos de desenvolvedor", levou um único desenvolvedor alguns meses.

A Ressalva (Limitações)

O artigo é honesto sobre o que isso não faz:

Não é um produto finalizado: Os aplicativos carecem de algumas funcionalidades avançadas encontradas em ferramentas profissionais (como malhas 3D complexas ou recursos de impressão profissional). É um "subconjunto substancial", não um clone perfeito.
Depende da IA: Se a IA se confundir ou "alucinar" (inventar código falso), o sistema detecta porque as cinco versões irão discordar. Mas se a IA for ruim em uma tarefa específica, todo o processo desacelera.
Precisa de um humano: A IA fez a digitação, mas um humano teve que verificar os resultados, corrigir a lógica e gerenciar a "memória" do projeto para que a IA não esquecesse o que decidiu no dia anterior.

A Grande Lição

Este artigo argumenta que a IA mudou a economia da engenharia de software. Anteriormente, construir múltiplas versões de um software para garantir a qualidade era caro demais. Agora, com a IA lidando com a codificação repetitiva, um único desenvolvedor pode construir um "júri" de cinco aplicativos para checar o trabalho uns dos outros. Isso transforma um método que foi abandonado na década de 1980 devido ao custo em uma ferramenta prática para uma pessoa hoje.

Resumo Técnico: Engenharia Pareada com IA como um Renascimento da Programação N-Versão

Definição do Problema
Aplicações maduras de ilustração vetorial (ex: Adobe Illustrator, Inkscape) representam décadas de desenvolvimento por grandes equipes sustentadas. Historicamente, estender tais aplicações ou portá-las para novas plataformas era considerado inalcançável para desenvolvedores individuais devido ao volume massivo de código, à complexidade dos frameworks de UI e à necessidade de rigorosa correção. O artigo investiga se a engenharia pareada com IA pode alterar essa realidade econômica, permitindo que um único desenvolvedor produza múltiplas implementações de alta fidelidade de uma aplicação desktop complexa em uma fração do tempo tradicionalmente necessário.

Metodologia
O autor, Jason Hickey, empregou uma metodologia centrada em duas salvaguardas específicas para permitir a "engenharia pareada com IA" em escala:

Uma Especificação Precisa e Executável (Fonte Única de Verdade):
- O núcleo do projeto é uma especificação YAML de 23.000 linhas que define declarativamente os painéis, diálogos, ferramentas, menus, modelos de estado e comportamentos reativos da aplicação.
- Esta especificação é executável: um intérprete compartilhado (aprox. 12.500 linhas) lê o YAML na inicialização e constrói a UI diretamente, em vez de tratar o YAML como documentação para ser recodificada em cada linguagem.
- A metodologia utiliza um padrão de "escape hatch" (escotilha de escape): onde a especificação declarativa do YAML não consegue expressar nuances específicas de plataforma (ex: renderização acelerada por hardware, manipulação específica de gestos), o código nativo é escrito. No entanto, a lógica conceitual permanece no YAML, garantindo que as decisões de design sejam tomadas uma única vez e propagadas para todos os ports.
Implementações Paralelas como uma Camada Integrada de Teste Diferencial:
- Em vez de uma única implementação, o desenvolvedor construiu cinco ports funcionais em distintas linguagens e frameworks: Rust (Dioxus), Swift (SwiftUI), OCaml, Python (PySide6) e um esboço baseado em navegador com Flask/HTML.
- Essas implementações paralelas funcionam como uma verificação contínua de correção. Como compartilham a mesma especificação, mas utilizam diferentes renderizadores nativos e idiomas de gerenciamento de estado, divergências no comportamento ou na saída visual sinalizam imediatamente um erro na implementação ou uma subespecificação no YAML.
- Esta abordagem revive a programação N-versão (Avizienis, 1985). Embora a metodologia original da década de 1980 tenha sido abandonada devido ao custo proibitivo de criar $N$ implementações independentes, o autor argumenta que a IA altera fundamentalmente a economia. A IA lida com o trabalho mecânico por port, tornando as $N$ implementações viáveis para um único desenvolvedor, enquanto a diversidade de plataformas fornece a independência necessária para capturar erros que testes automatizados deixariam passar.

Principais Contribuições

Um Estudo de Caso: Um único desenvolvedor produziu cinco implementações multiplataforma de uma aplicação de ilustração vetorial (27 ferramentas, 14 painéis, 22 diálogos) ao longo de aproximadamente 120 horas de trabalho noturno (7 semanas de calendário).
Framework Metodológico: Um fluxo de trabalho específico pareando uma especificação executável com implementações paralelas como uma camada de teste diferencial.
Relato de Campo Prático: Documentação detalhada da engenharia pareada com IA na prática, incluindo:
- Engenharia de Prompt: Ciclos iterativos para converter designs em prosa para YAML e revisões periódicas de codebase.
- Gerenciamento de Estado: O papel crítico da memória persistente baseada em arquivos (57 entradas) para manter o contexto entre sessões.
- Modos de Falha: Relato honesto das limitações da IA, como "alucinações confiantes" de símbolos, deriva de contexto longo e a tendência de escolher uma interpretação de um requisito subespecificado sem sinalizar a ambiguidade.
Artefatos de Código Aberto: O projeto completo, incluindo a especificação de 23.000 linhas, os cinco ports, 4.600 testes automatizados e protocolos de teste manual, está disponível em github.com/jyh/jas.

Resultos

Escala e Escopo: O projeto resultou em aproximadamente 336.000 linhas de código total (incluindo o intérprete compartilhado e os cinco ports). A especificação YAML compartilhada impulsionou a lógica, enquanto o código nativo por port variou de 0 linhas (OCaml, totalmente impulsionado pelo YAML) a ~95.000 linhas (Rust, exigindo renderização customizada significativa).
Correção via Divergência: A estratégia de implementação paralela identificou com sucesso lacunas de especificação que seriam "silenciosamente erradas" em um único port. Exemplos incluem:
- Tratamento de canais de cores degenerados (ex: saturação de HSB caindo para zero).
- O tempo de comportamentos de "snap" (atração) em modos Web Safe RGB.
- Persistência de estado em contextos de diálogo (ex: reversão de campo hexadecimal).
- Lógica para "cores recentes" durante arrastos de slider.
Esforço: O esforço total foi estimado em 120–160 horas de desenvolvedor. O autor observa que um único port de escopo comparável usando ferramentas convencionais exigiria tipicamente 1–2 anos de desenvolvedor; cinco ports exigiriam convencionalmente múltiplos anos de desenvolvedor.

Significância e Alegações
O artigo não alega que a aplicação resultante iguala a completude de recursos de ferramentas comerciais maduras (faltam-lhe modelagem de texto avançada, efeitos raster e fidelidade total de SVG). Em vez disso, sua significância reside em demonstrar uma mudança na fronteira de viabilidade para desenvolvedores individuais.

O autor argumenta que, ao combinar uma especificação executável precisa com implementações paralelas geradas por IA, um único desenvolvedor pode alcançar um escopo de trabalho que convencionalmente exige múltiplos anos de desenvolvedor. Isso é apresentado como um renascimento da programação N-versão, onde a barreira econômica para criar múltiplas implementações independentes foi reduzida pela IA. A metodologia sugere que, para domínios descritíveis declarativamente (como UI e lógica de aplicação), o valor de "teste diferencial" de múltiplos ports pode ser realizado sem a penalidade de custo tradicional, desde que o desenvolvedor mantenha rigorosos protocolos de teste manual e gerenciamento de memória.

O artigo permanece modesto, reconhecendo que os resultados são um recorte das capacidades atuais da IA (Claude Opus 4.6/4.7 em 2026) e que a metodologia depende fortemente da expertise de domínio do desenvolvedor e de sua capacidade de gerenciar modos de falha da IA. A afirmação não é que a IA substitui a necessidade de supervisão humana, mas que ela altera a equação econômica da programação N-versão, tornando-a uma estratégia viável para desenvolvedores individuais garantirem correção e portabilidade.