Engenharia de software na era da IA: context engineering, workflows e controle de custo

Entendendo o contexto - Apresentação

Introduzindo o curso e o instrutor

¿Está preocupado com o mundo em constante mudança, com todos pedindo para usarmos IA no dia a dia, utilizar Cursors, Code, Codex para criar código e mais código, sem entender o que está acontecendo, e durante todo esse processo apenas gastando dinheiro, fazendo-nos correr sem fim? Neste curso, vamos entender um pouco como funcionamos, como a janela de contexto do agente funciona e carrega, para que possamos gastar menos tokens e resolver mais problemas.

Meu nome é Hugo Fusinato, sou engenheiro de software na "Enter", que está colocando o Brasil no mapa da IA mundial. Trabalho há vários anos com engenharia de software e com IA desde o autocompletamento. Utilizava Tabnine ou Cursor para autocompletar minhas frases, depois comecei a pedir ao Cursor que executasse código, usei Codex, code, iterei com IA, aprendi a criar produtos, aprendi o que não fazer, e estou aqui para ensinar como podemos ser mais eficazes na criação de nossos produtos, gastando menos dinheiro.

Explorando o uso eficiente de tokens e agentes

O que vamos ver durante este curso? Vamos entender para onde vão nossos tokens e, consequentemente, para onde vai nosso dinheiro, como os gastamos, como entendemos quanto dinheiro gastamos por sessão, e como o agente está gastando tokens, e como isso pode impactar nossa equipe, nosso repositório e a carteira da nossa empresa a longo prazo.

Veremos como o agente vê o repositório e como se organiza nele, o que carrega, como funciona. Entenderemos bem a janela de contexto, o que entra nela, e como iteramos com o mundo, como pode ver ferramentas, identificá-las, executá-las, e como isso pode contaminar ou atrapalhar nosso contexto. Veremos exemplos bons e ruins de como guiar nosso agente, e o que é um bom exemplo de prompt e o que não é.

Compreendendo a janela de contexto e sub-agents

Entenderemos que um agente é apenas uma janela de contexto com informações circulando. Aprenderemos a identificar quando essa janela está se degradando, quando deixamos de atender às suas necessidades devido à contaminação excessiva, como limpá-la, quando iniciar uma nova sessão e quando utilizar sub-agents para limpar nosso contexto e começar do zero. Isso garantirá que gastemos menos, trabalhando em paralelo de forma mais eficiente, separando as tarefas conforme necessário.

Também aprenderemos a planejar adequadamente antes de executar as tarefas, pois quanto mais planejamos, menos seguimos pelo caminho errado e menos gastamos tokens. Compreenderemos a diferença entre MPCP e Skills (habilidades), e por que as habilidades são tão poderosas. Aprenderemos a criá-las, entender seu funcionamento e desenvolver habilidades muito eficazes para o que precisamos no dia a dia.

Orquestrando sub-agents e fluxos de trabalho complexos

Além disso, entenderemos fluxos de trabalho complexos com sub-agents e equipes que orquestram todos esses agentes para realizar várias tarefas em paralelo. Isso evitará a necessidade de criar vários agentes e trabalhar com várias janelas. Aprenderemos quando criar sub-agents, como criá-los e como, com equipes, orquestrar esses sub-agents para trabalhar em paralelo e em conjunto. Isso permitirá orquestrar informações, comunicar-se e executar tarefas mais rapidamente e de forma mais eficiente, pois cada sub-agent terá a informação e o contexto necessários.

Com todas essas informações, seremos capazes de criar fluxos de trabalho complexos, não apenas no Cloud Code, que estamos explorando mais neste curso, mas também no Codex ou no Cursor, pois todos compartilham as mesmas funcionalidades e seguem os mesmos caminhos, com Skills, com agentes e com janela de contexto. A base agêntica é sempre a mesma.

Preparando-se para o curso

Para aproveitar melhor este curso, é importante que sejamos desenvolvedores, que já tenhamos desenvolvido alguma funcionalidade, trabalhado com IA, independentemente da ferramenta, e que já tenhamos concluído os cursos anteriores desta trilha. Isso é tudo. Convidamos você a aprender mais sobre como funcionam os agentes e esperamos você na próxima aula.

Entendendo o contexto - O perigo do custo com IA

Introduzindo o curso e o impacto da IA no desenvolvimento

Perfeito, pessoal! O que queremos trazer com este curso é transmitir para onde estamos nos direcionando. Estamos em um cenário de muitas mudanças no mundo do desenvolvimento. Inicialmente, começamos com as IAs completando automaticamente o código. Nós escrevíamos e ela completava o que estávamos pensando em escrever, finalizando a função, colocando o nome, e pensávamos: "Uau, ela vai completar tudo, já estou feito, não preciso escrever toda a linha, sou muito mais produtivo."

Com o tempo, a IA foi evoluindo, analisando nossos dados, observando nossos padrões de código, e agora já não precisamos programar. Basta escrever alguma informação, colocar nossa intenção, e a IA transforma tudo. Isso leva muitos executivos de alto nível e empreendedores a pensar que o papel da pessoa desenvolvedora acabou, que temos um gasto muito grande com desenvolvedores e que agora a IA resolverá todos os problemas. Acreditam que teremos poucas pessoas desenvolvedoras que colocarão sua intenção no código e o sistema sairá perfeito, o que não é a realidade.

Comparando o cenário atual com a bolha de 2000

O cenário muda, temos ferramentas muito melhores, mas estamos vivendo um cenário semelhante ao da bolha de 2000. Naquela época, pensávamos que a web e a internet resolveriam tudo; agora estamos em um cenário parecido com a IA. Provavelmente, ela não resolverá tudo, mas ajuda muito no dia a dia, tornando as coisas realmente mais produtivas e rápidas.

No entanto, há um problema em tudo isso: a IA não é mais do que processamento de dados. É um Large Language Model (modelo de linguagem grande) que recebe input e dados em padrões, fornecendo um output de código dependendo do problema que estamos resolvendo. Isso é muito bom, mas conforme a utilizamos, gastamos mais. Há muitas declarações, como a do CEO da NVIDIA, Jensen Huang, que disse querer que, no futuro, as pessoas desenvolvedoras gastem 250 mil dólares por ano em IA para serem mais produtivas. Imaginar uma pessoa desenvolvedora gastando um milhão de reais nisso é um pouco fora do comum, é muito dinheiro, mas essa já é uma realidade para empresas que têm recursos para gastar.

Explorando os custos e a eficiência dos modelos de IA

Na Anthropic, por exemplo, que visitamos com a empresa no início deste ano, nos informaram que a média de gasto da empresa é de 2 mil dólares em tokens, o que equivale a aproximadamente 10 mil reais. Então, não estão apenas pagando os salários dos funcionários, mas também os tokens que usam para serem mais produtivos. E como sabemos que esses tokens que estamos gastando os tornarão mais produtivos? É muito fácil lançar um problema para a IA e esperar que ela o resolva, mas é preciso pensar muito bem no que estamos fornecendo, pois se fornecermos dados ruins, o resultado será ruim.

Neste curso, vamos revisar um pouco como a IA gasta, como processa e como esses custos podem ser reduzidos a longo prazo. De onde vem esse custo no dia a dia? Como mencionado anteriormente, a IA é processamento de dados. Temos o input, o output e um padrão estatístico, uma matriz desses tokens que cruza cada token, cada palavra com cada palavra, e fornece um resultado final. Mas, conforme vamos iterando, seja no Shared GPT, no Cloud Code, no Codex, no Cursor, ou em qualquer uma dessas ferramentas, temos mais tokens e mais palavras, mais código, mais input e output sendo adicionados.

Analisando o impacto do contexto e dos modelos no custo

Adicionamos contexto em cada conversa e, em cada conversa, repetimos esse mesmo input de tokens para obter um resultado de código, esse mesmo input para obter um resultado. Tudo isso é armazenado, e temos uma janela de contexto que se torna muito grande, lenta, e aumenta o que precisa ser processado para devolver a resposta. Quanto maior é esse processamento, essa quantidade de informação que precisa ser analisada, maior é o custo.

Qual é o cenário atual dos modelos? Aqui temos uma tabela que explica mais ou menos quais são os modelos mais usados hoje em dia, que tendem a mudar. O que estava aqui já não era o mesmo que há duas semanas. Os laboratórios lançam novos modelos a cada dois ou três meses. Há modelos dos Estados Unidos, modelos chineses chegando para competir. O panorama sempre muda, não apenas pelos modelos que surgem, mas pela arquitetura e eficiência dos modelos. Tudo é muito novo, mas esse processo de processar o LLM e avaliar tokens tenderá a mudar a forma como se processa e a melhorar a eficiência a longo prazo.

Comparando modelos e seus custos

Tudo isso reflete o panorama atual. O que temos hoje? Hoje, temos modelos diferentes para situações distintas que vamos usar. Há modelos que gastam muito mais processamento, mas são muito mais eficazes e costumam iterar melhor no problema e resolvê-lo, mas custam muito mais.

Por exemplo, o Opus, que é o melhor da Anthropic atualmente, pode processar um milhão de tokens (unidades de texto), o que equivale a aproximadamente 2.725 páginas, mas tem um custo de R$90,00 por cada milhão de tokens. Portanto, cada vez que nossa janela de contexto está cheia, estamos gastando R$90,00 por chamada. E sua saída, o que retorna quando itera, se devolver toda a janela de contexto, consome R$450,00, o que não é trivial, é uma quantia significativa de dinheiro.

Por isso, existem modelos mais eficientes, como o SONET, que custa R$20,00 para entrada e R$90,00 para saída. Cada provedor, cada laboratório de modelos diferente, traz o seu com diferentes características, tamanho de contexto e arquiteturas para que possamos comparar e usar em problemas distintos. Por exemplo, temos o Composer e o Gemini, onde o Gemini tem um contexto muito maior e um custo muito menor. Não é tão inteligente, nem tão eficaz, mas resolve grande parte dos problemas. Assim como temos o Composer, que tem um contexto menor, resolve muito bem várias tarefas, inclusive de planejamento e estruturação, mas também tem um custo menor por isso.

Avaliando o uso de modelos em diferentes contextos

Para cada problema distinto, usamos um modelo diferente e esse panorama tende a mudar, a evoluir, e precisamos estar sempre avaliando os modelos que surgem, seja na ferramenta que estamos usando, porque cada ferramenta tem modelos distintos. O Cloud Code usa mais os modelos da Anthropic, o Codex usa mais os modelos da OpenAI, e o Cursor tenta trazer todos os modelos para nós, mas para cada problema tentaremos usar um modelo diferente desse sistema e para esse contexto.

Como vamos identificar esse custo e avaliar se nosso repositório está bem organizado e está interagindo bem conosco? Temos um repositório chamado AgentLens, que foi criado para nos ajudar a escanear nosso repositório e informar o que o agente está vendo, qual é o tamanho do contexto que estamos adicionando e quanto estamos gastando. Como exemplo, digamos que somos uma pessoa desenvolvedora da Microsoft trabalhando no VS Code. Poderemos analisar nosso repositório e, ao analisá-lo, ele tomará todos os arquivos e veremos que mais ou menos o contexto que usamos está em torno de 8 mil tokens. E aí podemos ver como está configurado para os Agents, como está configurado para o Copilot, porque cada ferramenta tem uma configuração diferente, um ponto de entrada, uma forma como a IA vê nosso código de maneira distinta. E isso, a longo prazo, vai escalando. O VS Code tem um contexto ajustado, mas isso escala com o tempo.

Estimando custos e impactos em equipes de desenvolvimento

Se fizermos uma análise, usando por exemplo o SONET, que é um modelo que usamos bastante no dia a dia, é o que o Cloud Code costuma rodar por padrão, emitindo poucos tokens em média. Para uma pessoa desenvolvedora, digamos que trabalhamos sozinhos e fazemos cerca de 60 conversas por dia, vamos gastar por solicitação mais ou menos 40 centavos, 23 reais por dia, 500 reais por mês e 6 mil ao ano. Isso estamos considerando para uma pessoa desenvolvedora trabalhando em um projeto. Agora imagine se trabalhamos em uma equipe de, digamos, uma empresa média de 40 pessoas. Aqui veremos gastos de 250 mil ao ano. É um gasto que não pensamos no dia a dia, o empreendedor quando está adotando IA, vai percebendo que estamos gastando e iterando. Isso não é um gasto total, é apenas o gasto com os tokens iniciais que vamos ver do nosso repositório. E além disso, isso é com o modelo mais simples. Se trabalharmos com o modelo mais pesado, por exemplo, o OPUS, veremos que o custo já se aproxima de meio milhão. E aqui podemos aumentar a geração de tokens. É uma ideia para que possamos analisar, para ver que, digamos, a IA gera muitos tokens e está iterando sem parar e sua saída é muito longa. Já vemos um gasto de um milhão e meio.

Isso é para que possamos colocar nosso repositório e analisar mais ou menos a composição de seu custo e compará-lo com outros repositórios. Aqui poderíamos comparar repositórios, adicionar VS Code, Codex e o React do Facebook. Se compararmos todos, veremos mais ou menos que o Codex tem um contexto muito maior. O React aparentemente quase não colocou nada lá, apenas deixou uma introdução para nós, nada muito específico. Mas novamente, se estamos em uma equipe com 40 desenvolvedores fazendo uma média de 50 conversas por dia, o custo já começa a escalar. Então o Codex tem um contexto muito grande, não gastam muito dinheiro, são da OpenAI, estão gastando cerca de um milhão e meio ao ano apenas para 40 desenvolvedores. Provavelmente têm mais de 300, 500.

Concluindo sobre os desafios e custos da IA

Entendemos um pouco de como a IA pode ser um problema a longo prazo, por seu custo escalável e como pode afetar nosso orçamento. A seguir, entenderemos um pouco como funciona o contexto da IA e como ela vê nosso código, nosso sistema quando estamos trabalhando.

Entendendo o contexto - O que é contexto?

Explicando o conceito de contexto

O contexto é tudo o que entra como input (entrada) da LLM (Large Language Model, ou Modelo de Linguagem de Grande Escala). É tudo o que a LLM vê, tudo o que está no contexto do código, todo o problema que descrevemos, todas as ferramentas disponíveis e tudo o que pode ser usado no ambiente em que o agente está inserido para reagir. O contexto de uma LLM de chat é um pouco diferente do contexto de um agente.

Se observarmos a imagem do artigo da Anthropic, percebemos que não fazemos mais prompt engineering (engenharia de prompt), mas sim context engineering (engenharia de contexto). Não administramos apenas o prompt que estamos criando, mas também o contexto do que a IA está vendo. Assim, a IA deixa de ser apenas "entra texto, sai texto". Ela passa a receber o problema, o sistema, o ambiente em que está inserida e o que está acontecendo ao redor, e devolve uma resposta baseada nisso.

Comparando engenharia de prompt e engenharia de contexto

Na engenharia de prompt, temos o prompt e a mensagem do assistente. Entra o prompt, entra a mensagem, entra o chat e sai uma resposta, que era como começamos a usar o ChatGPT e similares. Agora, temos uma engenharia de contexto para agentes. Fornecemos ao modelo vários documentos, ferramentas, arquivos que indicam o que foi feito antes, qual é a memória, o que foi visto, o que foi feito anteriormente, as instruções dadas, que podem ser diversas: um arquivo de erro, um prompt extenso, um planejamento do que está sendo executado, conhecimento do domínio, arquivo de memória, entre outros. Quando abrimos o computador, o agente precisa administrar o que será colocado no contexto.

Como mencionado, o contexto e a iteração sobre ele têm um custo. Portanto, grande parte do problema da engenharia de contexto é fazer uma curadoria e avaliar o que entra e o que não entra quando enviamos para a LLM, calcular todos os tokens, as respostas e medir como resolver um problema. Podemos ter vários documentos, mas selecionamos apenas os necessários para resolver o problema. Tentamos organizar o agente para guiá-lo a uma solução mais eficiente sem gastar muitos tokens.

Discutindo a mudança de engenharia de prompt para engenharia de contexto

Este é um artigo muito bom que a Anthropic publicou, e vamos deixá-lo linkado para consulta, caso queiram ler sobre essa mudança de engenharia de prompt para engenharia de contexto.

Utilizando a ferramenta para visualizar o contexto

Agora, vamos usar a ferramenta e mostrar como ela vê o contexto. Tudo o que ensinamos aqui funciona para Cursor, funciona para Codex, mas, seguindo a didática da aula, vamos usar o Cloud, que acreditamos ser o que lança mais funcionalidades novas e que os concorrentes tentam acompanhar. Sempre que eles lançam habilidades, os demais também as lançam, e várias outras funcionalidades são mantidas em paridade para que quem está usando um sistema possa usá-lo em outro. Tudo o que mostramos aqui pode ser usado por outras ferramentas.

Inicialmente, vamos começar uma sessão de Cloud. No AgentLens, que é o repositório mostrado anteriormente, é solicitado um prompt. O Cloud possui vários comandos que podem ser usados, dependendo do que estamos fazendo, e várias funcionalidades são lançadas. Se pressionarmos a barra, podemos ver a lista delas. Queremos mostrar como o Cloud vê o contexto, dependendo da configuração que temos.

Analisando o uso de tokens e contexto

Se digitarmos "context" e pressionarmos "Enter", podemos visualizar o contexto como uma grade, uma tabela que formata tudo o que está sendo visto. Temos um contexto bastante extenso, e isso com o contexto em zero, sem inserir nada ou pedir que faça algo. Começamos um novo chat e já estamos usando 18 mil tokens, o que, como vimos na aula passada, a longo prazo pode ser bastante caro para um agente que está começando, já utilizando 9% do SONET.

O que temos aqui? O System Prompt (prompt do sistema), que geralmente é o prompt que nos foi dado, configurado pela Anthropic, define como o sistema deve funcionar em diferentes situações. Esse prompt, por si só, já ocupa aproximadamente 3% da janela de contexto.

Depois, temos todas as ferramentas disponíveis para uso. Elas são enumeradas, junto com instruções de uso, e isso consome cerca de 4% da memória. Podemos ver aqui as caixas de banco e os Custom Agents (agentes personalizados).

Explorando a importância do gerenciamento de contexto

Em seguida, há uma seção dedicada apenas à memória, que armazena arquivos para entender o que foi feito anteriormente e o contexto em que está inserido. Outra seção é dedicada às Skills (habilidades) e outra às mensagens. A seção de mensagens é a menor; mesmo sem enviar nada, ainda temos 74,4% do tempo disponível.

Por que é importante saber o que está sendo usado? Porque podemos identificar o que está sendo utilizado desnecessariamente e o que não será usado ao longo do tempo. Existem várias ferramentas disponíveis pelo MCP, configuradas para uso diário, mas nem todas serão úteis para o contexto específico que estamos utilizando. Portanto, nem sempre é necessário incluir esses 4% de ferramentas no caso em questão. Da mesma forma, não precisamos trazer todos os plugins, agentes ou tokens específicos da memória para validar nosso repositório.

Avaliando o impacto do contexto no uso de tokens

Esse contexto que acabamos de ver é um contexto limpo, sem nada, e já estamos gastando 20 mil tokens. Se olharmos a tabela, a longo prazo, se continuarmos gastando, o custo só aumentará, mesmo sem nada. Também podemos analisar um contexto já utilizado. Vou resumir aqui para retornar a uma conversa passada e usarei uma conversa que estava iterando no AgentLens, que é o repositório visto na aula passada, para comparar os tokens.

Nesse contexto, estava fazendo algumas melhorias de UI e UX. Se analisarmos, já temos 132 mil tokens sendo usados, ocupando 66% da janela. Isso significa que cada mensagem enviada está consumindo muito mais, e podemos ver as mensagens ocupando uma boa parte do contexto. Além disso, ao analisar, todas as ferramentas usadas, os MCPs, as skills, tudo ainda está disponível, mas com muito mais mensagens. Vamos entender e continuar nas próximas aulas, compreendendo como reduzir isso e tornar o contexto mais eficaz para resolver nossos problemas.

Controlando e otimizando o uso do contexto

É importante notar neste contexto específico como o Cloud está mostrando o contexto. Primeiro, há partes que controlamos e partes que não controlamos. Como pessoas desenvolvedoras, não podemos mudar o System Prompt; podemos fazer pequenas alterações com algumas ferramentas do Cloud, mas não economizaremos muitos tokens, pois eles sempre querem que funcione de uma forma específica para ser mais eficaz com o que já foi testado.

O que controlamos aqui? Controlamos a quais ferramentas o sistema tem acesso, quais agentes estão sendo executados e quais são os Custom Agents que podem ser executados para resolver problemas. Podemos controlar a memória, que é como o sistema vê nosso repositório e o que foi visto anteriormente. Controlamos as skills, as mensagens, o prompt que enviamos, e assim por diante.

Vamos separar bem o que podemos mudar aqui para reduzir de 132 mil tokens ou 20 mil tokens, quando começamos, para algo muito mais compacto, reduzido e específico para resolver nosso problema. Lembrando que o Cloud tem essa visualização, mas o Codex e o Cursor não têm isso bem implementado. Podemos ver o percentual do contexto, mas não temos essa divisão específica. É importante entender cada ferramenta; todas funcionam de maneira semelhante, mas as visualizações e comandos serão um pouco diferentes entre elas.

Entendemos um pouco como funciona o conceito. Na próxima aula, entenderemos como medir esse custo a longo prazo e avaliar o que estamos fazendo.

Sobre o curso Engenharia de software na era da IA: context engineering, workflows e controle de custo

O curso Engenharia de software na era da IA: context engineering, workflows e controle de custo possui 197 minutos de vídeos, em um total de 60 atividades. Gostou? Conheça nossos outros cursos de IA para Programação em Inteligência Artificial, ou leia nossos artigos de Inteligência Artificial.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Entendendo o contexto
• Guiando o entrypoint do agente
• Sessão, compactação e subagents
• Destilando conhecimento em skills
• Criando um time e executando vários agentes
• Explorando mais ferramentas úteis