Na era moderna da computação, um novo tipo de parceiro entrou na oficina: o modelo de linguagem. Estes são sistemas vastos e flexíveis, treinados em enormes bibliotecas de texto humano, capazes de ler instruções e escrever código com uma fluência surpreendente. Para muitos, essa mudança parece uma expansão súbita de capacidade, permitindo que novatos construam scripts e especialistas enfrentem sistemas massivos. No entanto, uma tensão fundamental permanece. Embora essas máquinas possam processar linguagem, elas não "aprendem" verdadeiramente ou lembram o que acontece em uma conversa uma vez que a sessão termina. Elas dependem inteiramente do texto atualmente visível para elas, uma janela limitada de contexto que deve ser constantemente reabastecida com detalhes relevantes. Se um programador deseja que a máquina entenda a lógica por trás de um trecho de código, essa lógica deve estar presente no texto logo ao lado do próprio código. Isso cria um desafio para a forma como escrevemos software. Tradicionalmente, o código e as explicações humanas desse código têm sido mantidos em lugares separados, ou enterrados em comentários que as máquinas frequentemente ignoram. Mas se a máquina deve ser uma verdadeira colaboradora, a história do programa e o próprio programa devem viver juntos, lado a lado, em um formato que tanto humanos quanto máquinas possam ler com igual facilidade.

Este é o problema central abordado por um novo ambiente chamado notlob, criado pelo pesquisador Adam T. Burke. O trabalho propõe um retorno a uma ideia antiga conhecida como programação literária, mas atualizada para uma era onde tanto humanos quanto agentes artificiais estão lendo os mesmos documentos. Neste sistema, um projeto de software não é uma coleção de arquivos separados para código, documentação e testes. Em vez disso, é um documento único e fluido que se assemelha a um ensaio. O texto explica as ideias, a motivação e o design, enquanto as instruções executáveis estão incorporadas diretamente na prosa. Os pesquisadores construíram um sistema funcional que trata este documento combinado como a fonte primária da verdade. Quando o sistema lê o arquivo, ele não vê apenas palavras; ele constrói um mapa detalhado de como cada nome, conceito e pedaço de código se relaciona com os outros. Este mapa, que o autor chama de grafo de nomes (name-graph), permite que um agente de máquina navegue pelo projeto não por meio de busca de palavras-chave, mas seguindo as conexões lógicas entre as ideias, de forma muito semelhante a como um leitor humano segue um fio de pensamento através de um livro.

O design do notlob é impulsionado por três observações simples sobre como a programação está mudando. Primeiro, a linguagem natural tornou-se a forma dominante de especificar e organizar software ao trabalhar com inteligência artificial. Segundo, as verificações geradas por computador que validam se o código ainda funciona são mais valiosas do que nunca, servindo como um ciclo de feedback confiável para os agentes. Terceiro, a geração atual desses modelos de linguagem é fortemente dependente da quantidade de texto que podem ver de uma só vez. Para abordar isso, os pesquisadores criaram uma linguagem onde a explicação, a execução e a verificação residem no mesmo arquivo. Um documento típico começa com um título e uma introdução, seguido pela lógica central do programa. Isso é seguido por uma seção para testes e referências, separados por uma linha simples. O sistema utiliza marcadores específicos para distinguir entre um trecho de prosa, um bloco de código, uma propriedade que deve ser sempre verdadeira e um caso de teste específico. Por exemplo, uma seção pode descrever uma sequência matemática, seguida imediatamente pelo código que a gera, e então um bloco de texto afirmando que o código deve satisfazer certas regras. O sistema então executa essas regras para garantir que o código se comporte como o texto afirma que deveria.

Para fazer isso funcionar, os pesquisadores desenvolveram um parser que trata nomes como os objetos mais importantes do sistema. Na programação tradicional, um nome é apenas um rótulo para uma variável ou função. No notlob, um nome é um cidadão de primeira classe que vincula a explicação escrita ao código executável. Quando o sistema processa um arquivo, ele constrói um grafo que conecta o texto que descreve um conceito ao código que o implementa, e aos testes que o verificam. Essa estrutura permite que um agente de máquina salte de uma ideia de alto nível para as linhas específicas de código que a realizam, ou encontre todos os lugares onde um conceito específico é usado, sem se perder em um mar de arquivos. O sistema inclui ferramentas que podem exportar este mapa em formatos padrão, permitendo que outro software consulte as relações entre diferentes partes do projeto. Isso mimetiza a maneira como um programador humano usa um ambiente de desenvolvimento integrado para encontrar onde uma função é definida ou quem a chama, mas faz isso compreendendo o significado semântico do texto, não apenas a estrutura do arquivo.

Os pesquisadores testaram este ambiente construindo vários programas funcionais, incluindo uma ferramenta para converter números em algarismos romanos e um jogo baseado na web baseado em redes de Petri, que são diagramas usados para modelar sistemas com partes que interagem. Em um experimento, eles usaram um agente artificial para ajudar a escrever um projeto do zero. O agente recebeu uma descrição de alto nível do objetivo e algumas assinaturas de funções vazias. O agente então preencheu o código, escreveu os testes e organizou a prosa, tudo enquanto aderia à estrutura do documento notlob. O agente foi capaz de detectar inconsistências entre o texto e o código, como uma incompatibilidade na definição de uma função, e pediu esclarecimentos. Em outro caso, o sistema ajudou um agente a encontrar um erro sutil em um projeto de processamento de sinais digitais que havia sido perdido por outros métodos de teste. O erro estava relacionado a um cálculo que se tornava instável sob certas condições, e os testes de propriedade do agente, que foram escritos como parte do ensaio, expuseram o erro com sucesso.

No entanto, os pesquisadores também observaram que os agentes não eram perfeitos. Em várias instâncias, os agentes tendiam a negligenciar as partes declarativas do documento, como as propriedades formais e as regras estruturais, focando em vez disso na tarefa imediata de escrever código. Eles às vezes tratavam o texto como uma sugestão em vez de uma restrição, levando a inconsistências que exigiam intervenção humana para serem corrigidas. Os pesquisadores notaram que essa dinâmica é familiar às equipes de software humanas, onde desenvolvedores seniores devem frequentemente intervir para garantir que a documentação e o código permaneçam alinhados. O estudo sugere que, embora esses modelos de linguagem sejam poderosos, eles ainda se beneficiam de uma estrutura que força o código e a explicação a permanecerem em contato próximo. O ambiente notlob fornece essa estrutura, oferecendo uma maneira de manter a teoria do programa e a prática do código no mesmo lugar.

O trabalho também se distingue de outras abordagens para o uso de modelos de linguagem na programação. Alguns métodos tratam a descrição em linguagem natural como uma especificação separada que precede a escrita do código, um processo que pode levar a um descompasso entre o plano e o resultado. Outros dependem do modelo para resumir ou regenerar o código após ele ter sido escrito. O notlob segue um caminho diferente ao co-localizar a especificação, o código e os testes em um único espaço de trabalho iterativo. Isso permite que humanos e máquinas trabalhem nos três elementos simultaneamente, refinando a lógica e a explicação em conjunto. Os pesquisadores argumentam que esta abordagem é mais eficaz do que tratar a linguagem natural como um mero prompt ou um documento separado. Ao tornar a prosa e o código partes inseparáveis do mesmo artefato, o sistema garante que a janela de contexto do modelo de linguagem seja preenchida com a informação mais relevante possível.

A implementação do notlob é um projeto de código aberto que atualmente suporta três linguagens de programação estabelecidas: Haskell, Python e TypeScript. O sistema inclui um conjunto de ferramentas de linha de comando que permitem aos usuários construir, testar e visualizar o projeto. Uma ferramenta pode renderizar o documento como uma página web padrão, enquanto outra pode gerar um mapa visual do grafo de nomes, mostrando como as diferentes partes do projeto estão conectadas. Os pesquisadores também experimentaram usar o sistema para criar um agente "crítico", uma inteligência artificial incumbida de revisar os projetos quanto à consistência lógica e estilo. Este agente foi capaz de identificar erros e sugerir melhorias, às vezes adotando diferentes personas para fornecer perspectivas diversas sobre o trabalho. Esses experimentos sugerem que o ambiente pode suportar não apenas a criação de código, mas também a revisão crítica e o refinamento de todo o projeto.

Em última análise, o artigo apresenta uma visão para um futuro onde o desenvolvimento de software é um ato colaborativo entre humanos e máquinas, fundamentado em uma linguagem compartilhada de texto e código. O ambiente notlob não pretende resolver todos os problemas da inteligência artificial na programação, nem promete que as máquinas escreverão software perfeito por conta própria em breve. Em vez disso, oferece uma ferramenta prática que torna a relação entre a ideia e a implementação mais transparente e robusta. Ao tratar o ensaio e o código executável como uma entidade única e interconectada, o sistema ajuda a diminuir a lacuna entre a intenção humana e a execução da máquina. O trabalho sugere que o futuro da programação pode não ser sobre escrever mais código, mas sobre escrever melhores histórias que o código possa seguir, garantindo que a lógica do sistema seja tão clara para a máquina quanto é para o humano.