Engenharia de software na era da IA: como usar IA no fluxo real de desenvolvimento

Entendendo o que mudou - Apresentação

Apresentando o curso e o instrutor

Olá! Bem-vindos a este curso. Meu nome é Vinicios Neves, sou calvo e barbudo, e estou aqui para falar sobre atualidades, não sobre futurologia. Vamos discutir como a profissão mudou. A vida da pessoa desenvolvedora agora é diferente. As ferramentas de IA chegaram para ficar, estão estabelecidas, e neste curso, veremos como podemos maximizar e potencializar essas ferramentas, minimizando seus aspectos negativos. Nem tudo é perfeito, a vida não é um mar de rosas.

Explorando conceitos e ferramentas

Vamos entender os conceitos principais: o que é, como funciona, os aspectos de um modelo que precisamos compreender e considerar, além de estratégias de execução. Vamos nos conectar ao MCP do Figma e vê-lo funcionar na prática. Então, se já sabemos front-end, veremos como podemos acelerar o processo, e se não sabemos front-end, veremos como isso facilita, e mesmo sem muita experiência, podemos realizar algo. O mesmo se aplica ao back-end. Vamos desenvolver funcionalidades de login, haverá Docker e tudo isso. Da mesma forma que no front-end, se já sabemos, veremos e sentiremos na prática o potencial que essa ferramenta gera. E se não sabemos, veremos também que, mesmo com os conhecimentos necessários para consumir um back-end, podemos realizar algo.

Focando no uso da ferramenta

O ponto principal é: a ideia é focar no uso da ferramenta e não na stack. Por exemplo, neste curso, usarei Node, PNPM, React e NestJS. Isso é o que usarei, e vamos desenvolver uma aplicação do zero, de ponta a ponta, com login, autenticação, feed e tudo mais. Mas qual é o atrativo deste curso? Não é necessário usar a mesma stack que eu. Se não somos de React, se somos de Angular, perfeito, funcionará. Se não usamos Node, se usamos .NET, Python, Go, Java, funcionará igualmente.

Compreendendo a aplicação prática

Por que a ideia é que entendamos como funcionam esses mecanismos e como se conectam com nossa atividade do dia a dia. Portanto, não se trata de nos perdermos em detalhes sobre semântica ou sintaxe. Vamos nos concentrar em funcionalidades reais. O que fazem os agentes? Neste curso específico, utilizaremos o Claude Code; é uma das ferramentas que se consolidou e já é uma das favoritas da comunidade de desenvolvimento. No entanto, veremos que, em alguns momentos, podemos aplicar o mesmo conceito usando outras ferramentas, outras funcionalidades e até mesmo outros modelos, como, por exemplo, o Anti-Gravity da Google, Cursor, ou até mesmo Augment, Windsurf. Existem algumas soluções com as quais podemos executar um modelo local, colocar um plugin no VS Code e também realizar algo, obviamente, com as devidas limitações de cada ferramenta e de cada modelo.

Preparando-se para o aprendizado

Portanto, se já sabemos escrever nossos ifs e elses e fazer um for, isso é o que precisamos para nos acompanhar. Não é necessário ser especialista nem em back-end nem em front-end; vamos nos concentrar na ferramenta. E uma coisa boa deste curso é que ele potencializará nosso conhecimento. Veremos que, quando pedirmos à IA que faça algo que já conhecemos, acharemos incrível. Quando pedirmos que faça algo que não dominamos tanto, perceberemos que nossa capacidade de criticar o que foi feito será diferente.

Concluindo a introdução

Então, é isso. Vamos começar. Iniciaremos entendendo um pouco os modelos e o cenário atual e, em seguida, partiremos dessa premissa de sempre: um Figma e um sonho. E faremos com que esta aplicação funcione. Prontos? Esperamos que estejam tão animados quanto nós. Nos vemos no próximo vídeo a seguir. Faremos uma promessa: não sairemos daqui, ficaremos esperando por vocês, prometemos. Até então!

Entendendo o que mudou - A execução ficou barata: o que isso significa pro dev

Discutindo a mudança na vida do desenvolvedor

Então, precisamos discutir isso. O que está acontecendo? A realidade, a vida da pessoa desenvolvedora não vai mudar, já mudou, já é diferente, e estamos aqui para compartilhar alguns insights aos quais temos estado muito atentos nos últimos tempos.

Vamos começar falando sobre por que essa execução se tornou barata. O que isso significa, afinal? Se pararmos para pensar, e explorarmos esse pensamento, a execução se tornou barata. Antes, quando tínhamos um fluxo normal de trabalho, o que acontecia? Planejávamos o que íamos fazer, pegávamos nossa tarefa, entendíamos o que precisava ser feito e começávamos a digitar, usando um autocompletador aqui ou ali, mas, em geral, escrevíamos linha por linha. Isso já não acontece mais; não escrevemos código do zero.

Explorando a execução barata e suas implicações

Agora, se quisermos gerar uma aplicação do zero, sem nada, podemos montar todo o boilerplate. Java nos ajudará a fazer isso. Se identificarmos um problema e precisarmos refatorar, como aconteceu hoje no trabalho, tínhamos um script em Python muito grande, que era um ponto de entrada de uma aplicação. Fomos lá, dividimos em scripts menores, usamos o padrão Strategy e, basicamente, explicamos o que queríamos, e o Cloud Code resolveu tudo por nós. Refatorar também se tornou barato.

Quando falamos de documentação, o mesmo acontece. Podemos pedir para que o projeto seja documentado nas partes mais importantes, com foco em x, y e z. A execução se tornou mais barata. Ainda escolhemos o que fazer e como fazer, mas a execução, quando dizemos barata, não nos referimos a dinheiro, tokens ou algo assim, mas sim ao tempo. É muito mais rápido fazer isso usando as ferramentas que temos hoje.

Mudanças no dia a dia do desenvolvedor

Quando falamos de testar, não nos referimos a implantar a execução, subir a aplicação e testar manualmente. Referimo-nos a escrever testes unitários, testes de integração, testes end-to-end. Toda a escrita de código, toda a implementação é muito mais rápida agora com essas ferramentas disponíveis no mercado. Esse é o pensamento por trás da execução ter se tornado barata.

Então, o que mudou de fato no dia a dia? O que está diferente? Agora pensamos no que queremos fazer, explicamos como será feito, onde será feito, o que precisa ser feito, de que forma, usando qual padrão, qual estrutura, qual arquitetura. Uma vez que definimos isso, tudo está planejado, executamos. Todo o código precisa ser executado, e enquanto isso, podemos nos dedicar a outra atividade que requer nossa atenção ativa. Quando termina, somos avisados, revisamos o código, testamos. Funcionou? Ótimo, podemos prosseguir, abrir um pull request e fazer o deploy. Se não funcionou, voltamos ao ciclo: por que não funcionou? Pensamos e decidimos o próximo passo. Limpamos o contexto? Resetamos o que estava acontecendo? Existem estratégias para essa interação, mas basicamente interagimos com o agente até chegar ao resultado final que precisamos que funcione.

Considerando o viés do desenvolvedor

Note que aqui temos um viés de pessoa desenvolvedora. O que queremos dizer com isso? Nós, da engenharia de software, quando usamos uma ferramenta assim, a aplicação é diferente, porque o artefato gerado importa. Estamos criando um produto que será utilizado por muitas pessoas. Se pedirmos ao agente para fazer scripts que serão executados uma vez, resolver um problema para nós e nunca mais executá-los, não damos tanta atenção, não revisamos o código, apenas olhamos o resultado. Funcionou? Passamos para o próximo. Mas a atividade de desenvolver um produto que será utilizado, recebendo funcionalidades ao longo do tempo, é uma história diferente.

O que gostaríamos de trazer aqui é um pensamento, talvez uma provocação: antes de 2020, antes do ChatGPT ser criado como é hoje, como era a carreira? No início, estávamos mais próximos do código. Assim, a pessoa em início de carreira ou com alguma experiência estava normalmente envolvida em tarefas de implementação de código, escrevendo diretamente.

Refletindo sobre a evolução da carreira na era da IA

À medida que avançávamos para posições como sênior, líder, staff, ou especialista, nos afastávamos do código e nos aproximávamos da arquitetura, das regras de negócio e do entendimento do produto. Esse era o caminho natural antes da inteligência artificial. O que a IA fez foi acelerar esse processo. Agora, mesmo no início da carreira, não estamos tão próximos do código, pois a execução se tornou barata. Escrever código agora é rápido. O que importa mais do que antes é como planejamos, que arquitetura vamos usar e como vamos implementar isso. Esse pensamento continua relevante, mas a forma de trabalhar mudou. Mesmo no início, estamos mais distantes do código, no sentido de escrever código de verdade, digitando letra por letra.

Quando pensamos no fluxo de desenvolvimento, o que começa a ter um peso importante é a planificação. Precisamos planejar o que faremos na semana, detalhar bem a tarefa, escrever os critérios de aceitação, que podem variar de empresa para empresa, mas os conceitos estão todos lá. Precisamos entender o que estamos fazendo, por que estamos fazendo, para quem e como deve funcionar. Depois, a parte de implementação é combinar o que definimos na tarefa com nossa contribuição de engenharia e executar. Está tudo pronto? Vamos revisar. Mas há um detalhe: revisar código gerado por IA não é o mesmo que revisar código gerado por outra pessoa. Os padrões que detectamos ao revisar IA são totalmente diferentes do que fazíamos antes.

Enfatizando a importância dos testes e da revisão

E quanto aos testes? No fluxo tradicional pré-IA, testávamos apenas no final, pois passávamos a maior parte do tempo implementando. Agora, passamos mais tempo testando e iterando do que implementando de fato. Isso não elimina a necessidade de saber código. Há uma analogia que usamos: não podemos usar uma calculadora se não soubermos fazer operações matemáticas. Temos que saber o que estamos fazendo.

Estamos falando do processo de desenvolvimento de software de um produto que vai durar e tem usuários reais, não de um aplicativo que só usamos em nossa máquina para resolver um problema específico. Isso é diferente quando se trata de um produto real.

Concluindo com um convite à participação

Não estamos falando do futuro, as ferramentas já estão aqui. Vamos mostrar na prática como trabalhamos hoje com as ferramentas disponíveis, sem necessariamente escrever linhas de código. Faz tempo que não escrevemos um if e um else manualmente.

Se houver dúvidas ou comentários, convidamos a participar do fórum ou do Discord. Estamos atentos ao fórum do curso, então, se algo for publicado lá, a probabilidade de vermos e comentarmos é alta. Para este encontro, era isso que queríamos compartilhar. Nos vemos no próximo vídeo. Até então!

Entendendo o que mudou - O que a IA faz bem, o que ela faz mal, e o que ela não faz

Criticando o desempenho da inteligência artificial

Agora é o momento de fazermos algo comum em nosso dia a dia: criticar, no bom sentido da palavra, o que a Inteligência Artificial (IA) está fazendo. Antes de começarmos a falar sobre o estado da arte atual, é importante destacar que essa lista é mutável o tempo todo. Na data em que estamos gravando este curso, o que a IA faz bem hoje, há seis meses atrás, ela não fazia. Portanto, essa lista é modificável.

Além de listar o que a IA faz ou não faz, queremos que aprendamos a julgar o que ela está fazendo bem ou mal e a nos adaptarmos a isso, trocando de modelo ou de ferramenta, se necessário. Vamos apresentar alguns pontos e perceber que existe um padrão nas coisas que a IA faz bem hoje. Vamos discutir sobre isso. Esse aviso é importante, pois essa lista muda constantemente.

Discutindo as capacidades da IA

Vamos começar nossa discussão. O que a IA faz bem? Tudo que envolve levantar boilerplate e fazer scaffolding de nosso framework favorito, coisas bem documentadas, ela faz muito bem. Isso ocorre porque boilerplate e scaffolding não têm necessariamente relação direta com nossa regra de negócio. É a documentação do framework e da linguagem que usamos. Portanto, isso é tranquilo para a IA.

Outra coisa que a IA faz bem é a refatoração. Se temos um cenário com um código de e-mail muito conhecido e queremos refatorar para um padrão de projeto, podemos pedir à IA para usar um padrão de factory, por exemplo. A IA pode ajudar a extrair código duplicado, simplificar e aplicar padrões de design bem estabelecidos.

Explorando a escrita de testes e documentação pela IA

A IA também escreve testes com rapidez e qualidade. No entanto, é importante sermos explícitos sobre o que queremos testar, a abordagem e o ângulo do teste. A IA pode ter um viés e testar mais a implementação do que o comportamento. Devemos revisar os testes no final.

Quando chegamos a um projeto, especialmente um legado ou muito grande, podemos pedir à IA para explicar o contexto. Ela é muito boa nisso, mesmo em linguagens nas quais não temos expertise. A IA pode ajudar a entender endpoints, parâmetros e outros detalhes.

Avaliando as limitações da IA em grandes projetos

Agora, o que a IA faz mal hoje? Se temos uma base de código muito grande, como um monorepo com muitos microserviços, a IA pode ter dificuldades devido ao gasto de tokens e ao tempo necessário para processar tudo. Existem estratégias específicas para lidar com isso, mas é preciso cuidado.

Outra questão é a consistência. Precisamos manter a consistência como se fossem nossas diretrizes. Por exemplo, ao escrever uma aplicação em React, devemos seguir as melhores práticas e manter a consistência no código.

Abordando a consistência e casos extremos

Uma das formas de declarar funções é a function declaration (declaração de função) normal, utilizando a palavra reservada function. Declaramos a função, abrimos parênteses para os argumentos e seguimos com a implementação. Outra sintaxe que podemos utilizar é a arrow function (função de seta). Ambas são formas diferentes de realizar a mesma tarefa. Se não mantivermos consistência e não orientarmos a IA para seguir essa consistência, pode ocorrer de, em um momento, ela utilizar a arrow function e, em outro, a function normal. O que desejamos é manter um padrão. Às vezes, ela utiliza camelCase e, em outras, snake_case. Essa consistência é nossa responsabilidade.

Outra questão importante são os cenários que chamamos de edge cases (casos extremos), que são os cenários mais delicados e complicados, mas que podem existir e não estão cobertos. Por exemplo, em uma regra de negócio clássica, não podemos realizar uma transferência de uma conta se não houver saldo suficiente. Se temos 500 reais na conta e queremos transferir 750, não podemos realizar essa transferência. Essa é a regra de negócio. No entanto, se houver algo que permita saldo negativo ou se o banco permitir combinar a transferência via PIX com o crédito do cartão, talvez seja possível.

Especificando casos extremos e limitações da IA

Qual é o relacionamento da IA com os edge cases? Precisamos especificá-los. Esses casos extremos são comportamentos ou regras de negócio que estão em nossa mente, e se estamos fazendo algo que os impacta, devemos mencioná-los.

Outro ponto importante é que a IA não costuma dizer "não sei". Se pedimos para ela fazer algo, ela fará, e preencherá as lacunas assumindo algumas verdades. Ela não questionará se algo está correto ou não, mas tende a assumir e executar. Portanto, devemos ter cuidado com isso. Já observamos algumas melhorias, especialmente nos modelos da Anthropic, onde a IA faz perguntas antes de agir, mas ainda há espaço para melhorias. Devemos ter cuidado com o que está implícito e lembrar que o óbvio precisa ser dito, sem criar um prompt gigante, mas tomando esse cuidado.

Delegando decisões de arquitetura e priorização à IA

Outro aspecto é a decisão de arquitetura. Podemos delegar à IA a escolha entre um banco de dados relacional ou não relacional, por exemplo, e pedir que justifique sua decisão. Fornecendo todo o contexto, como o caso de uso, entrada, saída, quantidade de requisições, requisitos funcionais e não funcionais, ela pode ajudar a chegar a uma conclusão. Quanto mais contexto ela tiver, maior a chance de acertar o melhor cenário. No entanto, a responsabilidade final é nossa. Decisões de arquitetura têm um impacto significativo no projeto, e uma decisão mal tomada pode ter efeitos preocupantes no futuro.

A priorização é outro ponto. A IA pode ajudar a julgar o que deve ser feito primeiro, considerando o contexto do produto e o que a pessoa responsável está pedindo. Para facilitar testes, por exemplo, pode fazer sentido começar de fora para dentro, com testes incrementais. Isso também requer um contexto amplo se quisermos delegar a priorização à IA.

Compreendendo o papel da IA no entendimento do usuário

Entender o usuário é semelhante. Embora o modelo tenha muito conhecimento, saber a melhor posição de um elemento ou se o contraste está adequado é algo que a IA pode ajudar, mas a decisão final é nossa. Podemos usar a IA como um parceiro, mas a responsabilidade é nossa, e se tomarmos a decisão, a responsabilidade vem junto.

A IA pode fazer muitas coisas, mas precisa de um contexto bem detalhado, e a responsabilidade final é nossa. Em decisões de arquitetura, priorização e entendimento do usuário, a IA pode ajudar, mas a responsabilidade é nossa. Quanto mais contexto ela tiver, melhor será o resultado, mas há muitas variáveis envolvidas.

Concluindo a discussão sobre o uso da IA

Na nossa experiência, a IA brilha ao fazer coisas que já sabemos como fazer sem ela. Ela pode executar tarefas rapidamente quando já sabemos o que queremos. Se pedirmos, ela fará, mas devemos ter cuidado com o que está implícito. A nível de implementação, ela fará o que pedirmos.

Essa é a mensagem que queríamos compartilhar. Estamos sempre atentos ao que acontece no fórum e no Discord. Se quiser trocar ideias, trazer casos ou experiências, sinta-se à vontade. Nossa conversa continua no próximo vídeo.

Sobre o curso Engenharia de software na era da IA: como usar IA no fluxo real de desenvolvimento

O curso Engenharia de software na era da IA: como usar IA no fluxo real de desenvolvimento possui 202 minutos de vídeos, em um total de 51 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 que mudou
• Setup: modelos, custo e contexto
• Front-end com IA
• Back-end com IA
• Boas práticas, más práticas e segurança
• Automações e agentes