Curso de Desenvolvimento com IA: o Novo Programador – Dia 1 – Da ideia à instrução perfeita

1. O Novo Paradigma do Desenvolvimento de Software [0]

O setor de desenvolvimento de software está passando por uma transformação significativa devido à inteligência artificial, exigindo que os programadores evoluam para dirigir agentes de IA em vez de apenas escrever código.

1.1. O Impacto da Inteligência Artificial no Desenvolvimento de Software [21]

1. A inteligência artificial (IA) transformou o setor de desenvolvimento de software, tornando a educação mais acessível e permitindo que a IA gere uma parte crescente do código [23].
   1. Os desenvolvedores agora precisam atuar como "novos elos", dirigindo "exércitos de agentes de inteligência artificial" [26].
2. O mercado de trabalho e as empresas estão buscando um novo perfil profissional, adaptado às mudanças na educação e no setor [27].
3. A IA já mudou tudo no presente, e os desenvolvedores devem abraçar essa evolução, pois a IA não os substitui, mas os leva a um "próximo nível" [31].
4. A adoção da IA no desenvolvimento é generalizada, com 90% dos desenvolvedores já utilizando IA, e 46% do código novo sendo gerado por IA [36].
   1. No entanto, a confiança na IA diminuiu, indicando que o setor está amadurecendo e reconhecendo a necessidade de supervisão humana, pois nem todo código gerado por IA é adequado para produção [40].
5. O mercado de trabalho para desenvolvedores de software, embora tenha sofrido uma adaptação inicial, está agora crescendo a um ritmo mais rápido do que outras ofertas de emprego, e essa tendência se estende ao mercado hispânico [53].

1.2. As Chaves para o Novo Programador [60]

1. O desenvolvimento de software mudou para sempre, e os programadores devem manter o controle, conhecer os fundamentos e integrar a IA em seu trabalho [60].
2. Criar software não é apenas programar; copiar e colar código gerado por um chat de IA sem entender o que está fazendo não é comparável ao desenvolvimento profissional [64].
3. Os fundamentos da programação são mais importantes do que nunca, pois uma base sólida é essencial para a evolução do setor [67].
4. Os desenvolvedores devem dirigir a IA, que executa o "trabalho bruto" e gera a maior parte do código, mas a direção humana é crucial para construir projetos de software profissionais, escaláveis e seguros [70].
5. Utilizar a inteligência artificial não é opcional, pois o mercado não paga mais por "digitar" código, mas sim por dirigir a IA e revisá-la [72].
6. A IA torna o aprendizado e o desenvolvimento mais fáceis e rápidos, atuando como uma "alavanca" que potencializa as habilidades de todos, desde juniores até seniores, permitindo que os juniores até mesmo superem os seniores que não levam a revolução da IA a sério [82].
7. As empresas que levam a sério a revolução da IA estão implementando-a em seus processos e contratando profissionais que sabem trabalhar com IA de forma profissional, não apenas por intuição [91].
8. O curso visa ensinar o "stack" e o padrão do setor, começando pelos fundamentos da IA e avançando para a delegação em agentes e o uso de conceitos e tecnologias que se encaixam no fluxo de desenvolvimento real [96].
9. O objetivo final é criar agentes que interajam entre si para desenvolver como profissionais em 2026, combinando os fundamentos da programação com a IA para formar um programador profissional com "critério" [99].

2. Fundamentos da Inteligência Artificial [101]

A compreensão dos fundamentos da IA, como modelos de linguagem, parâmetros, tokens e janela de contexto, é crucial para utilizar a IA de forma eficaz e controlada.

2.1. Modelos de Linguagem e Seus Componentes [129]

1. Um modelo de inteligência artificial ou grande modelo de linguagem é treinado com grandes quantidades de informação e funciona de maneira probabilística, prevendo o próximo "token" (fragmento de texto) com base na entrada [131].
2. Os parâmetros são valores internos aprendidos que o modelo usa para inferir resultados de forma mais inteligente [143].
3. Os tokens são as partes em que o modelo divide a informação (texto, áudio, imagens em modelos multimodais) para processá-la e gerar resultados [145].
4. A janela de contexto é a memória finita do modelo; quando ela se enche, o modelo pode começar a "alucinar" (gerar informações incorretas ou sem sentido) [147].
   1. Profissionais podem maximizar o uso da janela de contexto, diferenciando-se daqueles que usam a IA sem entender seus fundamentos [149].

2.2. Tipos de Modelos e Sua Utilização [151]

1. Existem modelos de pesos abertos (código-fonte e configuração disponíveis para instalação local) e modelos de pesos fechados (utilizados via APIs, sem acesso ao código-fonte) [151].
2. A execução de modelos pode ser na nuvem ou localmente, o que também é um fator importante [154].
3. Para usar modelos de forma sensata, é preciso entender seu poder, custo e velocidade; modelos mais inteligentes geralmente são mais caros e lentos, mas nem sempre são os melhores para todas as necessidades [156].
4. Existem rankings de IA (como em artificialanalysis.com e mstats.com) que ajudam a escolher o modelo certo com base em suas necessidades, considerando a janela de contexto e os parâmetros de treinamento [161].

3. Ferramentas e Engenharia de Prompts [168]

A escolha da ferramenta é flexível, mas a compreensão dos fundamentos da IA e a aplicação da engenharia de software são essenciais para o desenvolvimento profissional, superando a simples "bycoding" ou a engenharia de prompts clássica.

3.1. Ferramentas de Desenvolvimento com IA [168]

1. O curso é agnóstico em relação à ferramenta, o que significa que os alunos podem usar sua ferramenta favorita (como Cloud Code, Open Code, Codex, Copilot, Cursor) para programar [169].
2. Ferramentas como Codex, Copilot e Cloud Code oferecem interfaces semelhantes, geralmente com um chat e histórico, mas o mais importante são os fundamentos [175].
3. Um desenvolvedor com bons fundamentos de IA e engenharia de software não terá problemas em se adaptar a diferentes ferramentas [184].

3.2. A Evolução da Engenharia de Prompts [188]

1. A engenharia de prompts clássica (até cerca de um ano atrás) exigia definir o papel, contexto e estruturar as palavras para a IA [188].
2. Uma nova tendência, destacada por Carpacy, sugere que os modelos de IA atuais são capazes de estruturar ideias não organizadas, tornando a interação mais fluida [191].
3. No entanto, isso não significa que se pode "lançar texto a esmo" para a IA; é crucial diferenciar entre bycoding (programar por intuição para projetos pontuais e não escaláveis) e engenharia de software (projetar e construir software de forma sistemática para projetos profissionais) [194].
4. O curso se concentra em ensinar a engenharia de software atual, capacitando os alunos a se tornarem engenheiros de software que utilizam a IA de forma profissional [200].

4. Engenharia de Arneses: Agentes e Guardarraios [204]

A engenharia de arneses é fundamental para dirigir agentes de IA de forma controlada, permitindo que eles interajam com o sistema e executem tarefas reais, indo além da simples interação por chat.

4.1. O Conceito de Agente [206]

1. Um agente é um sistema que usa um modelo de IA para realizar tarefas, diferenciando-se de um chatbot que apenas responde texto com texto [207].
2. A principal diferença é que um agente pode interagir com todo o sistema, planejando, consultando informações, tomando ações, avaliando e ajustando [211].
3. Isso significa que um agente pode realizar tarefas reais, como criar, ler e buscar arquivos no sistema de arquivos ou na web, atuando como um "empregado" ao qual se delega trabalho [216].
4. Para que um agente alcance o desenvolvimento profissional, é necessário aplicar "arneses" (guardarraios) que o guiem [219].

4.2. Escolha e Uso de Ferramentas para Agentes [220]

1. A forma de desenvolver com agentes é semelhante à das ferramentas atuais, e o curso utilizará o Open Code para a maioria das demonstrações [221].
2. O Open Code foi escolhido pela comunidade e é uma alternativa de código aberto ao Google Cloud Code, oferecendo uma interface e funcionalidade semelhantes, mas permitindo o uso de diversos modelos (incluindo gratuitos) além dos modelos pagos da Anthropic [226].
3. Os alunos podem usar outras ferramentas como Codex, Cloud Code ou Cursor, pois os fundamentos são transferíveis [236].
4. O Open Code é um projeto de código aberto altamente valorizado, com mais de 200.000 estrelas no GitHub, e pode ser instalado facilmente via terminal em diferentes sistemas operacionais [241].
5. A interface do Open Code e de outras ferramentas é um chat onde se interage com o agente, e a configuração inicial pode envolver a escolha de um modelo ou a conexão com provedores existentes (como GitHub Copilot ou OpenAI) [267].
6. O curso utilizará tanto o Open Code (para desenvolvimento com IA) quanto o Visual Studio Code (para visualizar arquivos e código gerado), mostrando como as ações em uma ferramenta se refletem na outra [278].

5. Primeiros Passos Desenvolvendo com Open Code [280]

A interação com o Open Code envolve comandos para gerenciar modelos, conectar provedores e configurar o nível de esforço, permitindo que o agente comece a construir aplicações com base em prompts estruturados.

5.1. Comandos Essenciais do Open Code [280]

1. O Open Code possui comandos semelhantes aos encontrados em outras ferramentas de agente, facilitando a interação [280].
2. O comando /models permite escolher o modelo de IA a ser utilizado, e o comando /connect permite vincular provedores de IA (como OpenAI ou GitHub Copilot) para acessar seus modelos [291].
3. O Open Code oferece modelos gratuitos e planos pagos acessíveis (como o plano GO por 10 dólares), além da possibilidade de usar modelos locais em máquinas com boa capacidade [318].
4. Após escolher um modelo, pode-se definir a variante (nível de esforço) com o comando /variants, que afeta o consumo de tokens e o tempo de resposta [328].
5. O curso demonstrará a criação de um "Diário de Estudo", uma aplicação simples para registrar sessões de estudo e rachas, que será desenvolvida e evoluída ao longo das aulas [285].
6. Um prompt estruturado, definindo o papel, contexto e tarefa, é passado ao agente para iniciar a construção da aplicação, que gera arquivos HTML, CSS e JavaScript [340].
7. O agente é capaz de executar a aplicação e abri-la no navegador, demonstrando sua capacidade de realizar ações reais no sistema [360].

6. Engenharia de Contexto: AGENTS.md, Regras e Memória [375]

A engenharia de contexto é crucial para guiar os agentes de IA, fornecendo-lhes informações relevantes e persistentes através de arquivos como agents.md e memory.md, garantindo um desenvolvimento controlado e profissional.

6.1. A Importância da Engenharia de Contexto [375]

1. A engenharia de contexto é a prática de selecionar, organizar e atualizar informações para que o agente receba o que é mais relevante em cada momento, garantindo que ele se comporte como um programador profissional [425].
2. Isso vai além da engenharia de prompts, pois envolve a definição de "guardarraios" e contexto relacionados ao projeto [427].
3. O formato Markdown é uma forma eficaz de interagir com agentes, pois permite formatar o texto para que o agente entenda a estrutura e as seções (como papel, contexto, lista enumerada) [430].

6.2. O Arquivo agents.md como Padrão [442]

1. O arquivo agents.md é a primeira camada de instruções que orienta os agentes sobre como trabalhar, sendo um padrão estabelecido por grandes empresas como Gemini, Uni, OpenAI e DeepMind [442].
2. Este arquivo contém informações que o agente deve ter sempre presente, evitando a necessidade de repeti-las continuamente [450].
3. Um agents.md bem estruturado inclui o propósito do projeto, stack, estrutura, comandos, convenções, regras, forma de trabalhar e limites [454].
4. O comando /init no Open Code pode gerar um agents.md inicial com base no contexto atual do projeto, que pode ser então modificado para incluir restrições e regras específicas [457].
5. É crucial incluir proibições no agents.md, informando ao agente o que ele não deve fazer, além do que deve fazer [478].
6. O agente lê o arquivo agents.md antes de cada execução, tornando-o um documento fundamental para definir os princípios básicos e inamovíveis do projeto [484].

6.3. O Arquivo memory.md para Persistência [490]

1. A memória dos agentes é finita, e o arquivo memory.md serve para guardar informações persistentes que não são tão importantes para o agents.md, mas que o agente não deve esquecer [497].
2. O memory.md pode ser um arquivo Markdown criado no projeto, onde se reflete o estado atual do projeto, aprendizados e próximos passos [500].
3. Um exemplo de memory.md para o "Diário de Estudo" incluiria o estado atual da aplicação (V1, registro de sessões, sem backend), aprendizados e próximos passos [517].
4. Para que o agente utilize a memória, o agents.md deve ser modificado para instruir o agente a ler a memória no início e a atualizá-la ao final de cada tarefa, garantindo que a memória temporal esteja sempre atualizada [530].

7. O Poder do Modo Plano [540]

O modo plano permite que o agente de IA planeje e revise as ações antes de executá-las, o que é essencial para tarefas complexas e para manter o controle sobre o desenvolvimento.

7.1. O Agente de Plano e Suas Aplicações [540]

1. O Open Code possui dois agentes principais: o agente build (que constrói e executa tarefas) e o agente plan (que planeja e revisa) [540].
2. O modo plano permite que o agente "pare para pensar" e planeje antes de fazer qualquer coisa, permitindo que o desenvolvedor revise o plano [547].
3. Este modo é útil para esclarecer requisitos, detectar riscos e tomar decisões antes de implementar o código [550].
4. No Open Code, pode-se alternar para o modo plano usando Shift + Tab ou o comando /agents [552].
5. O modo plano deve ser usado para tarefas grandes, refatorações e supervisão, mas não para tarefas pequenas, correções óbvias ou prototipagem rápida [556].

7.2. Exemplo de Uso do Modo Plano [559]

1. Ao solicitar uma nova funcionalidade (como adicionar a "melhor racha" ao Diário de Estudo) no modo plano, o agente não modifica o código imediatamente [559].
2. Em vez disso, o agente apresenta um plano, explicando como calculará a racha, quais arquivos modificará e quais são os casos limite, além de levantar dúvidas para o desenvolvedor [576].
3. O desenvolvedor pode interagir com o agente para refinar o plano e tomar decisões antes da implementação [580].
4. Após aprovar o plano, o desenvolvedor alterna para o modo build (Shift + Tab) e instrui o agente a implementar, que então modifica os arquivos e atualiza a memória e os agentes conforme planejado [585].
5. A funcionalidade planejada é então refletida na aplicação, demonstrando a importância de planejar e analisar antes de construir [599].

8. Próximos Passos e Metodologia [606]

O curso avança em camadas, desde os fundamentos da IA até a delegação de tarefas com confiança e a integração da IA no fluxo de trabalho, culminando no desenvolvimento orientado por especificações.

8.1. Evolução do Desenvolvimento com IA [606]

1. O processo de desenvolvimento com IA é incremental, adicionando camadas ao agente, desde o prompt inicial até a definição de agentes, memória e planejamento [606].
2. A prática é essencial para solidificar o aprendizado, aplicando a metodologia ensinada para adicionar novas funcionalidades à aplicação [611].
3. O curso visa levar os programadores da fase inicial à compreensão dos fundamentos da IA e à direção da IA com "harness" (arneses) [612].

8.2. Próximas Etapas do Curso [616]

1. As próximas aulas abordarão como delegar tarefas com mais confiança aos agentes, extraindo mais benefícios deles [617].
2. Isso incluirá a criação de tarefas de forma mais rápida, mantendo a segurança e integrando a IA no fluxo de trabalho [618].
3. A metodologia da "camada 4" será o Spec Drive and Development, que ensina a desenvolver a partir de uma especificação, como as empresas profissionais já fazem [619].
4. O objetivo final é capacitar os programadores a usar a IA com controle, consciência e profissionalismo [621].