Transcrição: Por que os grandes modelos de linguagem não conseguem realmente construir software Autor: Conrad Irwin Uma das coisas em que passei muito tempo é entrevistar engenheiros de software. Isso é, evidentemente, uma tarefa árdua, e não me atrevo a dizer que tenho algum truque especial; mas essa experiência realmente me deu tempo para refletir sobre o que um engenheiro de software eficiente realmente faz. O ciclo central da engenharia de software Quando você observa um verdadeiro especialista, percebe que eles estão sempre executando repetidamente os seguintes passos: * Construir um modelo mental sobre os requisitos. * Escrever (esperamos que sim?!) código que atenda aos requisitos. * Construir um modelo mental sobre o comportamento real do código. * Identificar as diferenças entre os dois e, em seguida, atualizar o código (ou os requisitos). Existem muitas maneiras de completar esses passos, mas a grande habilidade dos engenheiros eficientes está em sua capacidade de construir e manter modelos mentais claros. Como os grandes modelos de linguagem se saem? Para ser justo, os grandes modelos de linguagem são bastante bons em escrever código. Quando você aponta onde está o problema, eles também se saem bem em atualizar o código. Eles podem fazer tudo o que engenheiros humanos fariam: ler código, escrever e executar testes, adicionar logs e (provavelmente) usar um depurador. Mas o que eles não conseguem fazer é manter um modelo mental claro. Os grandes modelos de linguagem ficam presos em uma confusão sem fim: eles assumem que o código que escrevem realmente funciona; quando os testes falham, eles só podem adivinhar se devem corrigir o código ou corrigir os testes; quando se sentem frustrados, simplesmente apagam tudo e começam de novo. Isso é exatamente o oposto das características que espero de um engenheiro. Os engenheiros de software testam enquanto trabalham. Quando os testes falham, eles podem consultar seu modelo mental para decidir se devem corrigir o código ou os testes, ou coletar mais informações antes de tomar uma decisão. Quando se sentem frustrados, podem buscar ajuda conversando com outras pessoas. Embora às vezes também apaguem tudo e comecem de novo, isso é uma escolha que fazem após ter uma compreensão mais clara do problema. Mas isso logo vai mudar, certo? À medida que a capacidade dos modelos aumenta, isso mudará? Talvez?? Mas eu acho que isso exigirá uma mudança fundamental na maneira como os modelos são construídos e otimizados. O modelo que a engenharia de software precisa não é apenas aquele que pode gerar código. Quando uma pessoa encontra um problema, ela pode temporariamente deixar de lado todo o contexto, concentrar-se na resolução do problema imediato e, em seguida, retomar seus pensamentos anteriores, voltando ao grande problema em questão. Eles também podem alternar livremente entre a visão macro e os detalhes micro, ignorando temporariamente os detalhes para se concentrar no todo, e aprofundando-se em partes específicas quando necessário. Não nos tornamos mais eficientes apenas porque colocamos mais palavras em nossa "janela de contexto"; isso só nos deixaria loucos. Mesmo que possamos lidar com uma quantidade massiva de contexto, sabemos que esses modelos geradores atuais têm vários problemas sérios que afetam diretamente sua capacidade de manter um modelo mental claro: * Omissão de contexto: os modelos não são bons em identificar informações de contexto que foram ignoradas. * Viés de novidade: eles são severamente afetados por um viés de novidade ao lidar com a janela de contexto. * Alucinações: eles frequentemente "fantasiam" detalhes que não deveriam existir. Esses problemas podem não ser insuperáveis, e os pesquisadores estão trabalhando para adicionar memória aos modelos, permitindo que eles usem técnicas de pensamento semelhantes às nossas. Mas, infelizmente, no momento, eles (após um certo nível de complexidade) realmente não conseguem entender o que está acontecendo. Eles não conseguem construir software porque não conseguem manter simultaneamente dois "modelos mentais" semelhantes, identificar as diferenças entre eles e decidir se devem atualizar o código ou os requisitos. Então, o que fazer agora? É evidente que os grandes modelos de linguagem são úteis para engenheiros de software. Eles podem gerar código rapidamente e se saem bem na integração de requisitos e documentação. Para algumas tarefas, isso já é suficiente: os requisitos são claros o suficiente, o problema é simples o suficiente, e eles podem resolver tudo de uma vez. Dito isso, para qualquer tarefa que tenha um pouco de complexidade, eles não conseguem manter contexto suficiente com precisão para, por meio de iterações, produzir uma solução viável. Você, como engenheiro de software, ainda precisa garantir que os requisitos sejam claros e que o código realmente implemente as funcionalidades que afirma ter. Na Zed, acreditamos que no futuro humanos e inteligências artificiais podem colaborar na construção de software. No entanto, acreditamos firmemente (pelo menos por enquanto) que você é o motorista que controla o volante, enquanto os grandes modelos de linguagem são apenas mais uma ferramenta ao seu alcance.