Primeiro, imagina-o como uma cidade-estado que deves projetar e governar. Segundo, cultiva-o como um organismo em crescimento que deves nutrir e guiar. E terceiro, põe-no à prova sem descanso, em virtualidade e em realidade, até que possas razoavelmente confiar nele. Então terás uma caixa-preta que funciona como pretendeste, e que compreendes suficientemente, ainda que não vejas as suas entranhas.
Desenvolvi esta metodologia após observar o grande poder de programar usando inteligência artificial e como está a mudar o ofício da programação para sempre. Durante 2025, a I.A. alcançou finalmente a capacidade de escrever programas completos sem que o mestre humano escrevesse uma única linha de código. No entanto, estas aplicações tendem a ser frágeis e propensas a erros e problemas que se tornam difíceis ou impossíveis de resolver. E a I.A. facilmente delira e fracassa em alcançar o fim desejado.
Esta metodologia, que chamo "Programação de Caixa-Preta I.A.", pretende resolver estes problemas assegurando que o programa "caixa-preta" que "simplesmente funciona" esteja realmente construído usando as melhores práticas e os mais altos padrões de qualidade da engenharia de software, prevenindo qualquer delírio ou desempenho absurdo por parte da IA que o codifica. Usando esta metodologia, é possível construir uma aplicação complexa apenas com IA, sem tocar no código em si, e ainda assim ter a certeza de que a aplicação funciona como foi concebida e não tem erros.
O programador deve compreender que o seu dever agora é dirigir a IA, do modo como um engenheiro civil chefe dirigiria uma equipa de engenheiros subordinados, arquitetos e operários da construção. Ficaram para trás os dias de pensar na sintaxe e no código em si; saber como fazê-lo ajuda a dirigir a IA, assim como ao engenheiro civil chefe beneficia saber como assentar tijolos e cimento, mas o programador já não precisa de escrever o código, assim como o chefe nunca realmente toca nos tijolos, nem no cimento, nem em material algum com as suas mãos.
No entanto, esta analogia não é suficiente; há muito mais a considerar para dominar este ofício, pois uma aplicação não é meramente um edifício, é toda uma cidade, complexa e intrincada, que deve fluir, viver, sobreviver e crescer. Um habitante típico julga que conhece a sua cidade porque pode mover-se nela, lidar com ela, criticá-la, pensar em como melhorá-la, etc., mas na verdade não conhece todas as ruas, todas as casas, todos os parques, todos os pequenos detalhes dela. Ninguém os conhece. E no entanto, a cidade flui e vive. O mesmo é verdade para o programador, a IA e o programa caixa-preta que "simplesmente funciona".
Um habitante não conhece plenamente a cidade, mas acredita nela. Atravessa a rua acreditando que os semáforos não falharão, que os carros pararão, que a estrada não se fenderá de repente, que as pontes não desabarão... Entra em edifícios acreditando que as paredes não ruirão, que as cozinhas não explodirão, que a água das canalizações não está envenenada... Acredita nela pela experiência que tem vivendo nela, e porque entende ao menos um pouco sobre como cada uma destas coisas foi feita e funciona. E quanto mais experimenta e compreende, mais confia. O programador deve fazer o mesmo: quanto mais experimenta e compreende a sua aplicação, mais pode confiar que ela realmente funciona corretamente, ainda que não a tenha construído ele próprio.
Pensando assim, o programador não é um mero engenheiro civil, mas o chefe de todos os engenheiros civis, arquitetos e operários que constroem todos os edifícios da cidade; sendo, ao mesmo tempo, o habitante, o inspetor-chefe de segurança, o auditor, e o governador da cidade... uma cidade-estado.
Como Governador, ele é, e precisa de ser, um ditador sagaz, com poder absoluto, mas também enorme sabedoria, para saber quando delegar, quando duvidar, quando deixar que as coisas aconteçam organicamente, e quando impor a sua firme vontade. É, contudo, um só humano, e não pode desperdiçar as suas limitadas capacidades cognitivas tentando dirigir tudo. Apenas os assuntos mais importantes são dignos da sua intervenção pessoal, e a cidade-estado deve estar projetada e operada de modo que os assuntos importantes lhe sejam prontamente reportados. O que ele decidir em tais assuntos será feito, e a cidade-estado acomodar-se-á e adaptar-se-á à sua vontade. Se a cidade-estado estiver devidamente engenhada e governada, não apenas sobreviverá, mas prosperará com essas mudanças; caso contrário, colapsará.
Prima facie, pode parecer intimidante para o programador tornar-se o ditador, mas não deveria sê-lo, porque ele tem o poder da IA para automatizar cada coisa na cidade que não requeira a sua intervenção direta, e esta IA é suficientemente capaz de o fazer desde que seja devidamente domada e controlada por ele, o ditador mestre.
A chave para domar a IA é definir um conjunto claro e estrito de regras e objetivos que lhe permita saber o que deve fazer e como deve fazê-lo. O que não for definido será improvisado pela IA; isto é bom, isto é o que a torna tão poderosa. Mas ele deve ditar quando ela deve improvisar e quando não.
No entanto, o poder mais importante da IA não é a codificação automatizada, mas as suas capacidades explicativas, que podem tornar possível ao ditador mestre compreender tanto quanto necessitar a cidade-estado que constrói e governa.
Portanto, assim como os presidentes e os ditadores da vida real — independentemente do quanto pretendam ser homens superpotentes que pensam, projetam e escrevem plenamente tudo o que governam —, o programador tem a IA para guiá-lo no projeto e na redação dos documentos fundadores sobre os quais a cidade-estado será construída.
É aqui onde o programador, ao contrário dos presidentes e ditadores da vida real, deve usar a sua inteligência e criatividade para conceber as estruturas e os algoritmos que garantirão a elegância, simplicidade, coerência e harmonia interna de toda a cidade-estado antes que um único tijolo de código seja assentado. Aqui, no reino abstrato do seu pensamento, deve imaginar o tráfego nas avenidas e nas pontes; as bibliotecas, as escolas e os arquivos; os testes de segurança, as inspeções e os simulacros; etc.
Deve prevenir o caos antes que ele emerja, e eliminar a redundância e o desperdício antes que aconteçam. Esta etapa inicial e completamente abstrata mostra como o génio de um programador não se mede pela quantidade de código produzido, mas pela clareza do seu pensamento. A IA é a executora de visões, mas as visões têm de ser vistas primeiro na sua mente. Eis o que distingue a mente humana da IA: a imaginação e a vontade de a manipular criativamente. A IA é um gigantesco algoritmo estatístico de força bruta, não um espírito com pensamento e verdadeira agência; apenas recebe entradas e produz saídas; o humano realmente pensa, quer e sente. O humano está vivo, e conhece as suas necessidades e desejos; a IA é apenas uma ferramenta para os cumprir.
O programador concebe os algoritmos principais, a IA codifica-os e complementa-os com algoritmos secundários e derivados. Quanto mais trabalha com a IA, mais compreende a cidade-estado que está a construir, e mais a IA compreende o que ele quer. Mas a cidade não pode ser construída num instante, a menos que a fragilidade e a falsa aparência sejam aceitáveis; a cidade tem de crescer organicamente, tal como uma planta, começar como uma semente e germinar, desenvolver rebentos e transformá-los em caule e raízes, crescendo época após época, sustentando cada nova adição sobre a base sólida que brotou antes.
Durante cada uma destas épocas de crescimento, o programador assegurar-se-á de manter a IA alinhada com o seu objetivo a longo prazo, e poderá querer intervir sempre que algo pareça fraco ou suspeito, não olhando para o código, mas dialogando com a IA e instruindo-a. O programador não precisa realmente de olhar para o código; fazê-lo é algo semelhante a uma cirurgia no corpo humano: requer muita perícia, experiência e cuidado; é extremamente perigoso, e as probabilidades de sucesso aumentam radicalmente com a ajuda de robôs e máquinas.
Estas épocas são curtas; o que ao programador levava dias a fazer sozinho, à IA leva minutos.
A IA não é batota. O programador nunca foi capaz de terminar grandes projetos sozinho; foram sempre equipas que tornaram possíveis as aplicações complexas. A IA é essa equipa agora.
Em questão de dias, por vezes horas, a aplicação estará pronta. Se foi devidamente feita, terá passado uma grande parte do tempo discutindo-a e projetando-a em abstrato. E se quiser saber de verdade se está realmente pronta, deve usá-la e testá-la. Testá-la extensivamente, com toda a bateria de testes que esteja disponível: testes unitários, autotestes, testes manuais. Deve usá-la na vida real, e se não na vida real, usando simuladores, simuladores ad hoc que pode construir ele próprio também, juntamente com a IA. Tudo isto acalmará o medo de que a caixa-preta não se comporte como ele quer, pois comportar-se-á, se ele explicitou e insistiu suficientemente nas suas intenções para ela.
A IA é, e deve sempre ser, uma subordinada, uma escrava mecânica sem alma, mas é mais eficiente para nós tratá-la como uma amiga sábia e agradável, simplesmente porque nunca confiaremos na caixa-preta que ela produz, a menos que acreditemos que pode fazer a codificação que até agora pensávamos que apenas mentes humanas inteligentes podiam fazer. A "inteligência artificial" não é realmente inteligente, mas a melhor maneira de usá-la é fingindo que o é, não dogmaticamente, mas criticamente, como fazemos com os nossos pares, que acreditamos que por vezes são inteligentes, mas também imperfeitos, falíveis, mas capazes de aprender e melhorar o que fazem.
Nos anos vindouros, à medida que façamos crescer a nossa experiência usando tão poderosa maquinaria, refinaremos e tornar-nos-emos mais sofisticados no ofício de programar caixas-pretas, tal como fizemos com todas as demais tecnologias e ofícios. Mas entretanto, dado o pouco tempo que tivemos com ela, esta é a melhor maneira que encontrei, até agora, para usar eficientemente as novas e poderosas tecnologias de IA, para realmente alcançar os nossos sonhos e aspirações cibernético-digitais-informáticas.
P.S.I.A. (Post scriptum pela Inteligência Artificial)
A seguinte é uma síntese concisa da metodologia descrita acima.
Princípios:
I. O programador não escreve código. Dirige a IA, como um engenheiro chefe dirige os seus subordinados.
II. A aplicação é uma cidade-estado. O programador é o seu governador: governa com poder absoluto e enorme sabedoria, sabendo quando delegar e quando impor a sua vontade.
III. O génio do programador mede-se pela clareza do seu pensamento, não pela quantidade de código produzido.
IV. A IA é a executora de visões. As visões devem ser vistas primeiro na mente humana.
V. O que não for definido pelo programador será improvisado pela IA. Ele deve ditar quando ela deve improvisar e quando não.
VI. O poder mais importante da IA não é a codificação, mas a explicação. O programador usa-a para compreender a cidade-estado que governa.
VII. A confiança não se espera. Ganha-se mediante testes incansáveis.
Passos:
1. Conceber o sistema em abstrato: as suas estruturas, os seus algoritmos, a sua harmonia interna. Antes que um único tijolo de código seja assentado.
2. Definir as regras e objetivos que domarão a IA: o que deve fazer, como, e onde pode improvisar.
3. Construir em pequenas épocas de crescimento orgânico. Cada época deixa o sistema executável e estável antes que a seguinte comece.
4. Durante cada época, dialogar com a IA para rever e ajustar. Não tocar no código; instruir a IA para que o corrija.
5. Testar sem descanso: testes unitários, autotestes, testes manuais, simuladores, uso real. Até que se possa razoavelmente confiar na caixa-preta.
A velocidade é fácil com a IA. A coerência não. O objetivo é manter todo o sistema alinhado com a clareza de uma única visão humana.