1. Introdução ao Desenvolvimento com IA e o Papel do Programador [1]

O desenvolvimento com IA está transformando a forma como o software é criado, exigindo que os programadores se adaptem e aprendam a direcionar as ferramentas de IA.

1.1. O Curso e o Instrutor [1]

  1. O curso "Desenvolvimento com IA: Programa com Agentes" é um evento de três dias focado em como o software é desenvolvido atualmente, em 2026 [2].
  2. O instrutor, Brais Moure, é um engenheiro de software com 16 anos de experiência, empreendedor e divulgador, com uma comunidade de mais de 3 milhões de pessoas [13].
    1. Ele recebeu reconhecimentos como Microsoft MVP e GitHub Star, e participou de grupos de desenvolvimento do Google [18].
    2. Atualmente, ele também é diretor do Mestrado em Desenvolvimento com IA, que será apresentado no terceiro dia do curso [24].

1.2. Impacto da IA no Desenvolvimento de Software [28]

  1. A inteligência artificial é amplamente utilizada no desenvolvimento de software, com 84% dos profissionais usando-a [31].
    1. No entanto, apenas 41% do código em produção é gerado por IA, o que significa que a maior parte ainda requer intervenção humana [36].
    2. A confiança nos resultados do software gerado por IA é de apenas 36%, indicando a necessidade de supervisão humana para garantir qualidade e confiabilidade [40].
  2. A IA impactou a educação, tornando o aprendizado de programação mais acessível e rápido, o que faz deste um dos melhores momentos para aprender [52].
  3. No desenvolvimento de software, o valor do programador mudou de apenas escrever código para dirigir e empregar a IA [56].
    1. As exigências do mercado de trabalho agora incluem o conhecimento de IA, além dos fundamentos de desenvolvimento, para evitar a substituição por quem sabe usar a IA melhor [62].
    2. É crucial entender o que se está fazendo e não apenas dar "prompts" à IA esperando um resultado sem esforço [64].

1.3. A Evolução da Capacidade da IA e a Realidade das Previsões [72]

  1. A capacidade da IA para resolver problemas complexos aumentou significativamente, passando de menos de 20% de respostas boas há um ano para 80-90% de confiabilidade nos modelos mais recentes, sempre com a guia humana [76].
  2. Previsões de CEOs de grandes empresas, como Jensen Huang (Nvidia), Dario Amodei (Anthropic), Mark Zuckerberg (Meta) e o CEO da Klarna, sobre a IA substituir programadores e reduzir equipes, não se concretizaram [82].
    1. Essas previsões geraram expectativas para incentivar o uso da IA, mas a realidade mostrou que a IA serve para ajudar e potencializar quem sabe usá-la [90].
  3. O setor de tecnologia continua crescendo, com previsões de até 15% de crescimento, mas há uma dificuldade em encontrar perfis preparados para o cenário atual [97].
    1. Empresas buscam profissionais que entendam tanto a engenharia de software quanto a inteligência artificial, pois programar como antes da IA pode ser perigoso [102].
    2. A adaptação contínua e o estudo da IA são essenciais para os programadores, pois a IA não tirará o trabalho de quem souber utilizá-la [106].

2. Fundamentos Essenciais para o Desenvolvimento com IA [111]

Para usar a IA de forma eficaz, é crucial entender seus fundamentos, pois o desenvolvimento de software com IA vai além de simplesmente gerar código.

2.1. Chaves para o Desenvolvimento com IA [111]

  1. Criar software não é apenas programar: Pedir código à IA, copiar e colar não é o suficiente, e nenhuma empresa pagará por isso [115].
  2. Os fundamentos importam mais do que nunca: Trabalhar com IA sem saber o que se está fazendo não faz sentido; é preciso dirigir a IA [118].
  3. Aprender inteligência artificial não é opcional: O setor mudou para sempre, e a IA não é apenas "conversar" com o ChatGPT e copiar e colar [123].
  4. O mercado paga por orquestrar e dirigir a IA, não apenas por codificar [127].

2.2. Conceitos Básicos da IA [200]

  1. Modelos de Linguagem Grandes (LLMs) são IAs projetadas para entender e escrever texto de forma semelhante aos humanos [204].
    1. Eles funcionam com uma base matemática, não raciocinam como humanos [208].
    2. O processo envolve treinamento com vasto conhecimento humano e inferência de resultados matemáticos baseados na previsão da próxima palavra [210].
    3. Os LLMs não buscam em bancos de dados, mas calculam a probabilidade da próxima palavra ou token [213].

2.3. Métricas e Conceitos Importantes dos Modelos de IA [224]

  1. Número de parâmetros: Representa as conexões neuronais; quanto mais bilhões de parâmetros, mais "inteligente" é a IA [229].
    1. Sites como artificialanalysis.ai/models fornecem informações sobre modelos e suas métricas, incluindo o número de parâmetros [234].
  2. Tokens: São as "peças de Lego" em que um modelo divide o texto para processamento [242].
    1. O número de tokens afeta a velocidade, a janela de contexto e o custo do modelo [250].
    2. Frases em inglês tendem a usar menos tokens do que em português, tornando-as mais eficientes para LLMs [258].
    3. É importante economizar tokens para otimizar custo e latência [264].
  3. Custo: Modelos de IA podem ser gratuitos ou pagos, com o custo variando conforme o modelo e o número de tokens utilizados [267].
    1. É essencial escolher o modelo adequado para cada tarefa, evitando usar modelos muito potentes (e caros) para tarefas simples [271].
  4. Janela de contexto: É o número de tokens que um modelo pode processar antes de "perder a memória" [274].
    1. Quando a janela de contexto se enche, o chat pode esquecer informações anteriores ou começar a "alucinar" [277].
    2. Modelos maiores, como Gemini 3.1 Pro, podem ter janelas de contexto de 1 milhão de tokens, enquanto modelos menores podem ter 256.000 [284].
  5. Outros conceitos importantes incluem:
    1. Multimodalidade: A capacidade de um modelo de trabalhar com diferentes tipos de dados, como texto, imagens, áudios e vídeos [290].
    2. Latência: A velocidade de resposta do modelo, que pode levar à escolha de modelos mais simples, mas mais rápidos, para certas tarefas [293].
    3. Alucinações: Respostas sem sentido, muitas vezes relacionadas à janela de contexto [295].
    4. Modelos raciocinadores: Modelos que realizam uma análise prévia antes de dar respostas [297].
    5. Inteligência: Rankings de modelos (como os de artificialanalysis.ai) ajudam a escolher o modelo mais inteligente para cada necessidade, mas os nomes e versões mudam constantemente [299].
    6. Modelos podem ser na nuvem ou locais, privativos ou de código aberto [307].

2.4. Escolha e Uso de Modelos de IA [309]

  1. Entender os fundamentos permite tomar decisões sobre qual modelo usar [311].
    1. Sites como MLStats oferecem rankings de modelos para escrita, codificação e outras tarefas, com métricas como parâmetros, contexto, raciocínio e geração de imagens [317].
  2. Há um trade-off entre potência, velocidade e custo [327].
    1. Um modelo potente é geralmente mais lento e caro [331].
    2. Um modelo mais barato é geralmente mais rápido, mas menos potente [331].
  3. Recomendações para o uso de modelos:
    1. Modelos potentes: Para tarefas de pensamento profundo e arquitetura de desenvolvimento [333].
    2. Modelos médios: Para o dia a dia, evitando usar modelos excessivamente potentes para tarefas simples [334].
    3. Modelos rápidos e baratos: Para tarefas mecânicas, que servem para a maioria das situações [336].

3. Anatomia de um Prompt e o Perigo do "By Coding" [337]

A qualidade do prompt é crucial para obter resultados eficazes da IA, e o "by coding" (programar por intuição) é uma prática perigosa que deve ser evitada no desenvolvimento profissional.

3.1. Engenharia de Prompts: Como Interagir com a IA [337]

  1. Interagir com a IA não é apenas escrever de qualquer maneira; é preciso saber como perguntar para obter bons resultados [340].
    1. Um mau prompt resultará em um mau resultado, enquanto um bom prompt se ajustará ao que se busca [345].
  2. Um bom prompt deve incluir:
    1. O papel (role): Definir quem a IA deve ser (ex: "desenvolvedor backend sênior especializado em cibersegurança") e seu nível de experiência [349].
    2. O contexto: Explicar o projeto e as tecnologias envolvidas [352].
    3. A tarefa exata: Ser específico sobre o que se precisa [354].
    4. Restrições ou regras: Definir os limites da tarefa [364].
    5. Convenções e padrões: Indicar como o código deve ser formatado [366].
    6. Formato de saída: Especificar o tipo de resultado desejado [367].
  3. A IA funciona de maneira indeterminista, ou seja, o mesmo prompt pode gerar 10 resultados diferentes [357].
    1. Como desenvolvedores, o objetivo é buscar o determinismo, ou seja, respostas que se adaptem exatamente ao que se quer, o que é alcançado com a engenharia de prompts e o uso de "guardarraíles" (proteções) [361].

3.2. Exemplos de Prompts: Mau vs. Bom [369]

  1. Mau prompt: "Faz um código para um login em Python" [381].
    1. Problemas: Não há contexto (web, console, microsserviço), tecnologias específicas, ou regras de segurança [404].
    2. O modelo precisa "adivinhar", resultando em um código genérico e indeterminista [382].
  2. Bom prompt: "Atua como um desenvolvedor backend sênior especializado em cibersegurança. Está construindo uma API para um e-commerce, utilizando Python. Preciso que escrevas um endpoint..." [389].
    1. Benefícios: Define o papel, contexto, tarefa, restrições (bibliotecas, tratamento de erros) e formato (bloco de código bem comentado) [391].
    2. Embora demore mais, o resultado é um código mais organizado, adaptado e profissional [396].
  3. Outras técnicas incluem fine-tuning (treinamento extra para modelos gerais) e RAG (Retrieval Augmented Generation), onde o modelo responde com base em uma fonte de conhecimento específica fornecida [418].

3.3. O Perigo do "By Coding" vs. Engenharia de Software [421]

  1. O "by coding" é programar guiando-se pela intuição, usando a IA para gerar código rápido, sem o conhecimento para avaliar se o código é seguro, escalável ou adequado para produção [425].
    1. É rápido e divertido, mas perigoso, pois pode levar a código que se quebra ou não escala [430].
  2. O "no-code" tem seu lugar, permitindo a criação de software que antes não era possível, e a IA potencializa o desenvolvedor profissional [433].
  3. A engenharia de software foca em projetar e construir software de forma sistemática, com arquitetura, segurança e controle, buscando sempre um responsável que crie software de maneira segura e escalável [438].
    1. Um meme ilustra que, enquanto "by coders" e "no-code" criam, o programador profissional é quem precisa consertar quando algo quebra [441].

4. Editores de Código com IA e o Conceito de Agentes [443]

Os editores de código evoluíram para integrar a IA como um núcleo central, e o conceito de agentes permite que a IA interaja de forma autônoma com o código e o sistema.

4.1. Evolução dos Editores de Código com IA [443]

  1. A chegada do ChatGPT em 2022 marcou o início do boom da IA no desenvolvimento [445].
  2. A evolução dos editores de código com IA:
    1. Clássicos (até 2022): Autocompletavam pequenas coisas [446].
    2. Com chat (final de 2022/2023): Adicionaram um chat para perguntas e copiar/colar código [448].
    3. Copilotos (2024): A IA começou a interagir como uma ajuda no ciclo de desenvolvimento [451].
    4. Agentes (2025): A IA passou a interagir com o código e fazer coisas de forma autônoma [453].
    5. Ambientes de Desenvolvimento com IA (2026): Editores de código são projetados com a IA como centro [457].

4.2. Tipos de Editores de Código com IA [459]

  1. IDEs (Integrated Development Environments) focados em código:
    1. Exemplos: Visual Studio Code, Cursor, Antigravity, Trade, Ced, Kiro [460].
    2. Muitos são construídos sobre a mesma base (como Visual Studio Code) e oferecem funcionalidades semelhantes [466].
    3. A escolha da ferramenta é pessoal, pois todas funcionam de maneira parecida, e o profissional é quem faz a diferença, não a ferramenta [466].
  2. Editores focados em Terminal:
    1. Exemplos: Cloud Code, NeoVim, Warp, Codex [477].
    2. São ferramentas que se instalam no terminal e permitem interação via chat ou comandos [477].
    3. Codex é um exemplo de IDE (Integrated Development Environment) já pensado para IA, onde o código é secundário e o principal são os agentes [485].
  3. A maioria das ferramentas é gratuita para testar, e o importante é entender os fundamentos, não se perder na busca pela ferramenta perfeita [490].

4.3. Configuração e Fundamentos nos Editores de Código [494]

  1. Ao usar editores de código com IA (como Visual Studio Code, Cursor, Antigravity), é possível configurar o modelo de IA a ser utilizado [498].
    1. As opções incluem modelos mais potentes (ex: Cloud Opus) ou mais rápidos, dependendo da tarefa [516].
    2. A janela de contexto (ex: 200K tokens) também pode ser configurada, dependendo da necessidade de memória do modelo [519].
    3. O esforço ou capacidade de raciocínio do modelo pode ser ajustado, impactando o gasto e o tempo, mas resultando em melhor qualidade [524].
  2. Entender os fundamentos e testar as ferramentas são as melhores maneiras de configurar e usar esses editores [527].
  3. Embora cada editor possa ter modelos padrão e configurações ligeiramente diferentes, a base é a mesma, e todos se imitam e evoluem de forma semelhante [539].

4.4. O Conceito de Agentes de IA [551]

  1. Antes dos agentes, os chatbots nos editores apenas respondiam a perguntas, e o usuário copiava e colava o código [553].
    1. Um exemplo mostra a IA gerando um código HTML para uma página de apresentação, mas sem interação direta com o sistema de arquivos [563].
  2. Os agentes representam a próxima evolução, com um bucle autônomo [575].
    1. O agente pode iterar sobre si mesmo, fazendo perguntas e ajustando suas respostas até encontrar a solução ideal [577].
    2. Além disso, o agente é capaz de interagir com o sistema: criar, ler e modificar arquivos, executar comandos e verificar resultados [579].
  3. O bucle do agente funciona em etapas: entender a pergunta, planejar, agir, avaliar e ajustar, repetindo o processo até atingir o resultado desejado [583].

5. Demonstração e Controle de Agentes de IA [586]

A demonstração prática de agentes de IA em editores de código revela seu potencial e a importância de manter o controle sobre suas ações para garantir segurança e resultados precisos.

5.1. Agentes em Ação: Criando uma Página Web [586]

  1. Ao ativar o modo agente em um editor (como Cursor), o agente inicia um bucle autônomo [610].
    1. O agente pode realizar ações como buscar informações na internet (ex: declarações de CEOs) [632].
    2. Ele pode interagir com arquivos, modificando o conteúdo existente ou criando novos arquivos [638].
    3. Na demonstração, o agente modificou um arquivo index.html, removendo 75 linhas e adicionando 859 linhas de código para criar uma linha do tempo interativa [643].
  2. O agente também pode executar comandos, como iniciar um servidor local para visualizar a página web [658].
    1. A página gerada mostra previsões de CEOs sobre o desaparecimento de programadores e a realidade de que isso não aconteceu [663].
  3. Embora o agente crie uma página funcional rapidamente, o resultado é indeterminado se não houver definições passo a passo [668].

5.2. Controle e Segurança no Uso de Agentes [672]

  1. O agente mostra as ações que está realizando (ex: modificações de linhas, comandos no terminal), permitindo que o usuário revise e entenda o processo [672].
    1. É crucial revisar o que o agente faz para manter o controle e garantir que o código gerado esteja alinhado com as expectativas [686].
    2. O usuário pode desfazer as mudanças feitas pelo agente se não estiverem corretas [692].
  2. Em alguns casos, o agente pode pedir permissão para criar ou modificar arquivos, o que é uma proteção importante [712].
    1. É aconselhável ir passo a passo e aceitar as ações do agente gradualmente, especialmente no início, para não perder o controle [715].
    2. Um exemplo mostra o agente criando um Web.html e copiando o conteúdo do index.html para ele, o que pode não ser o desejado se não houver instruções claras [719].
  3. Checklist para código seguro com IA:
    1. Dar contexto e segurança antecipadamente: Definir claramente o que se quer e as validações necessárias [729].
    2. Ler e entender o código: Analisar se o código gerado pela IA atende aos requisitos [732].
    3. Cuidar do que se compartilha: Evitar expor chaves de segurança ou informações sensíveis, pois o código pode ser filtrado [737].
    4. É fundamental usar a IA com guardarraíles (proteções) para garantir que o código seja seguro e acotado [742].

5.3. Próximos Passos: Agentes com Regras e Habilidades [744]

  1. A próxima aula focará em usar agentes de forma mais controlada, com ferramentas como OpenCode (ou CloudCode) [744].
  2. Serão abordados:
    1. Como marcar regras desde o início para que o agente construa o software como desejado [747].
    2. O uso de skills (habilidades) para tornar o agente mais inteligente [748].
    3. A integração de comandos, MCPs e sistemas de terceiros [750].
    4. A importância da memória para economizar tokens e gerenciar a janela de contexto [751].
  3. A segunda aula será totalmente prática, focada em fechar o bucle algorítmico e considerar os requisitos do projeto [756].