🧠 Entre a IA e a síndrome do impostor: será que precisamos saber tudo para continuar programando?

🌌 CodeVerse2026 | Artigo #22

🧑💻 Fala, Galera Dev! 👋

Quem acompanha o CodeVerse2026 sabe que normalmente escrevo sobre programação, projetos que estou desenvolvendo, tecnologias que estou aprendendo e os desafios que encontro pelo caminho. Mas, desta vez, quero trazer uma reflexão um pouco diferente, sobre algo que acredito que muitos desenvolvedores já sentiram em algum momento da carreira.

Quero falar sobre aquela mistura de satisfação, insegurança e frustração que aparece quando estamos desenvolvendo um projeto, principalmente quando precisamos aprender uma tecnologia que ainda não dominamos. E sobre como a inteligência artificial está mudando não apenas a maneira como programamos, mas também a quantidade de responsabilidades que estamos assumindo.

Porque, se tem uma coisa que venho percebendo nos últimos projetos, é que a IA consegue acelerar muito o nosso trabalho, mas isso não significa que estamos preparados para resolver todos os problemas que aparecem pelo caminho.

E talvez seja justamente aí que aquela velha conhecida, a síndrome do impostor, encontre espaço para aparecer.

🚀 De uma engrenagem a responsável pelo projeto inteiro

Há alguns anos, quando pensávamos em desenvolver um sistema mais complexo, normalmente imaginávamos uma equipe com vários profissionais. Tínhamos desenvolvedores responsáveis pelas telas, outros pelo funcionamento interno, especialistas em banco de dados, designers, profissionais de segurança e tantas outras áreas.

Era como uma fábrica, onde cada pessoa cuidava de uma parte da produção. Uma montava determinada peça, outra verificava seu funcionamento e outra era responsável por juntar tudo e entregar o produto final.

Hoje, com a evolução das ferramentas de inteligência artificial, essa realidade está começando a mudar. Dependendo do projeto, uma única pessoa consegue utilizar diferentes IAs para realizar tarefas que antes precisariam ser divididas entre vários profissionais.

E isso é algo impressionante!

Mas existe um detalhe nessa mudança que considero importante. Antes, muitas vezes éramos apenas uma engrenagem dentro de um projeto maior. Agora, podemos acabar assumindo a responsabilidade pela máquina inteira.

Nos meus últimos projetos, por exemplo, precisei pensar não apenas no código, mas também nas funcionalidades, no visual das telas, na organização do banco de dados, na hospedagem, na segurança e em como tudo deveria funcionar para o usuário.

É quase como deixar de ser apenas um funcionário da construção e passar a ser o responsável pela obra. Podemos ter várias ferramentas e pessoas ajudando, mas alguém precisa conferir se as paredes estão no lugar certo, se a estrutura está segura e se aquilo que foi construído corresponde ao que o cliente pediu.

E, quando desenvolvemos utilizando IA, esse responsável somos nós.

🤖 Viramos os líderes de uma equipe de IAs?

Uma comparação que tenho feito é imaginar que estamos assumindo o papel de um desenvolvedor sênior orientando uma equipe de inteligências artificiais. Precisamos explicar o problema, dividir tarefas, avaliar as entregas, solicitar correções e decidir quando determinada funcionalidade está realmente pronta.

Só que existe uma diferença importante: nem sempre temos a experiência de um desenvolvedor sênior em todas aquelas tecnologias. Muitas vezes estamos orientando a IA enquanto aprendemos, ao mesmo tempo, como aquela ferramenta funciona.

Foi algo que percebi bastante nos projetos que desenvolvi recentemente. Precisei aprender novas formas de hospedagem, trabalhar com banco de dados, configurar autenticação e entender conceitos de arquitetura que ainda não dominava completamente.

A IA ajudou muito, mas não eliminou a necessidade de estudar. Pelo contrário, em alguns momentos ela me colocou diante de problemas que eu provavelmente demoraria muito mais para encontrar se estivesse desenvolvendo tudo manualmente.

E acredito que esse seja um dos grandes desafios dessa nova fase: conseguimos construir coisas cada vez mais complexas, mas precisamos acompanhar esse crescimento com conhecimento.

🎢 Um dia você é o melhor programador do mundo...

Quem nunca passou horas tentando resolver um problema e, quando finalmente conseguiu, sentiu que era o melhor programador do mundo? 😅

Você termina aquela funcionalidade complicada, consegue publicar uma aplicação, vê tudo funcionando e pensa: "Caramba, olha o que eu consegui fazer!". Dá até aquela sensação de que poderia sentar ao lado do Elon Musk para discutir o próximo grande projeto tecnológico.

Mas basta chegar no dia seguinte e encontrar um erro aparentemente simples para essa confiança começar a desaparecer. Você testa, altera o código, pede ajuda para a IA, tenta novamente e nada parece funcionar.

De repente, aquele desenvolvedor que estava comemorando uma grande conquista começa a pensar: "Será que eu realmente sei programar? Será que estou dependendo demais da IA? Será que conseguiria fazer isso sem ela?".

E é justamente nesse momento que a síndrome do impostor tenta aparecer.

Aquela sensação de que talvez não sejamos tão bons quanto imaginávamos, mesmo depois de estudar, desenvolver projetos e superar vários desafios. Como se tudo aquilo que conseguimos construir não tivesse tanto valor porque utilizamos ferramentas para nos ajudar.

Mas será que faz sentido pensar assim?

🧠 Ninguém precisa saber tudo

Uma coisa que procuro lembrar quando encontro alguma dificuldade é que nenhum desenvolvedor domina todas as linguagens, ferramentas e tecnologias disponíveis. Até profissionais muito experientes precisam pesquisar, consultar documentação, pedir ajuda e aprender coisas novas.

É como um mecânico que conhece muito bem o funcionamento de um motor, mas precisa estudar para trabalhar com um modelo diferente. Ele pode não conhecer todas as peças daquele veículo, mas possui uma base que o ajuda a entender o problema.

Na programação acontece algo parecido. Podemos mudar de linguagem, framework ou banco de dados, mas muitos fundamentos continuam presentes, como lógica, condições, funções, organização das informações e regras de funcionamento.

Claro que cada tecnologia possui suas particularidades, mas ter uma boa base facilita muito o aprendizado. Talvez não saibamos exatamente qual comando utilizar, mas conseguimos compreender o problema e buscar uma solução.

Por isso acredito que não precisamos saber tudo, mas precisamos continuar aprendendo. E, principalmente, confiar na base que já construímos ao longo dos estudos e projetos. Não conhecer uma tecnologia hoje não significa que não somos capazes de utilizá-la. Significa apenas que ainda temos algo novo para aprender.

Um bom exemplo prático disso esta sendo eu ter de usar Kotlin para desenvolver dois aplicativos que se conectam ao meu backend, conhecendo minimamente a linguagem. E digo do fundo do meu coração, esta sendo um baita desafio.

🔍 A IA escreveu o código. Mas você sabe o que ele faz?

Aqui entra um ponto que considero muito importante.

Quando utilizamos inteligência artificial para desenvolver, existe uma tentação enorme de simplesmente aceitar aquilo que ela entrega. Pedimos uma funcionalidade, recebemos o código, executamos e, se aparentemente está funcionando, seguimos para a próxima tarefa.

Mas será que está tudo certo?

Imagine contratar alguém para construir uma casa. A pessoa termina a obra, pinta as paredes, instala as portas e entrega tudo aparentemente perfeito. Mas você não verifica se a parte elétrica foi instalada corretamente ou se a estrutura apresenta algum problema.

A casa pode estar bonita, mas isso não significa que esteja segura.

Com o código acontece algo parecido. Uma aplicação funcionar na tela não significa que tudo o que está por trás dela esteja correto. Podem existir falhas de segurança, consultas desnecessárias, informações expostas ou funcionalidades que funcionam apenas em determinadas situações.

E é por isso que tenho procurado analisar cada vez mais o código que a IA produz.

Mesmo quando não entendo completamente uma implementação, procuro investigar, pesquisar e perguntar. Às vezes peço para explicar determinada função, mostrar como os dados estão sendo tratados ou verificar quais problemas aquela solução poderia apresentar.

E perguntar não é vergonha nenhuma!

Na verdade, acredito que uma das melhores maneiras de utilizar IA para programação é transformar aquilo que não entendemos em uma oportunidade de aprendizado.

😂 "Você tem toda razão! Cometi um erro..."

Quem utiliza IA para programar provavelmente já passou por uma situação parecida.

Você pede para a ferramenta desenvolver uma funcionalidade, ela entrega o código e afirma que está tudo funcionando corretamente. Mas, depois de analisar melhor, você percebe algo estranho e resolve questionar.

"Mas essa implementação não permite que um usuário acesse informações de outro?"

E então vem aquela resposta que já virou praticamente um meme:

"Você tem toda razão! Identifiquei uma falha importante de segurança na implementação anterior. Vou corrigir isso agora!" 😂

O curioso é que, poucos minutos antes, a mesma IA havia apresentado aquela solução como se estivesse completamente correta.

Isso mostra por que precisamos ter cuidado ao confiar cegamente nas respostas. A inteligência artificial pode ajudar muito, mas também pode cometer erros, deixar passar problemas e até concordar conosco sem verificar adequadamente aquilo que estamos dizendo.

A quantidade de vezes que você pedir para uma analisar seu código e te reportar os erros, é a mesma quantidade de vezes que ele lhe retomará múltiplos erros a serem corridos, infinitamente. Pelo menos foi isso que percebi quando testei.

Recentemente, inclusive, recebi uma pergunta técnica sobre a segurança de um dos sistemas que desenvolvi. A pessoa questionou como eu estava garantindo que uma clínica não conseguiria acessar as informações de outra. Foi uma pergunta muito pertinente, porque me fez olhar novamente para uma parte da arquitetura que ainda precisava melhorar.

E esse é outro aprendizado importante: às vezes, uma boa pergunta nos ensina muito mais do que uma resposta pronta.

No final das contas, se uma aplicação apresentar uma falha, não podemos simplesmente dizer que foi a IA que escreveu o código. Quem decidiu publicar e disponibilizar aquela solução continua sendo responsável por ela.

🎨 Pedi três coisas e a IA me entregou quinze!

Outra situação que tenho encontrado bastante acontece durante a criação das interfaces.

Às vezes precisamos de uma tela simples, com três informações, dois botões e uma tabela. Explicamos isso para a IA e esperamos receber algo organizado, bonito e fácil de utilizar.

Mas, quando abrimos a aplicação, encontramos dez cards, vários gráficos, menus adicionais, animações e funcionalidades que ninguém pediu. 😅 Você queria uma bicicleta e a IA resolveu entregar uma moto cheia de acessórios!

E o pior é que, em alguns momentos, o resultado até parece bonito. Mas será que aquilo realmente atende ao que precisamos?

Uma interface com muitos elementos pode acabar confundindo o usuário. E, dependendo da implementação, ainda podemos ficar com componentes, funções e arquivos desnecessários que aumentam a complexidade do projeto.

É o que chamamos de código morto, ou seja, partes do código que não são mais utilizadas, mas continuam dentro da aplicação. É como guardar durante anos peças de equipamentos que você já não utiliza. Elas continuam ocupando espaço e dificultam encontrar aquilo que realmente precisa.

Por isso tenho aprendido que nem sempre adicionar mais funcionalidades significa melhorar um sistema. Às vezes, a melhor solução é justamente simplificar.

📋 Um bom PRD pode evitar muito retrabalho

É justamente por isso que venho dando cada vez mais importância ao planejamento antes de começar um projeto.

Nos últimos sistemas que desenvolvi, procurei estruturar um PRD (Product Requirements Document), que basicamente é um documento utilizado para explicar o que queremos construir, quais funcionalidades serão necessárias e como esperamos que a aplicação funcione.

Gosto de comparar o PRD com a planta de uma casa. Antes de começar a construção, precisamos definir quantos cômodos teremos, onde ficarão as portas, quais materiais serão utilizados e como tudo deverá funcionar.

Se começarmos a construir sem planejamento, podemos descobrir no meio da obra que esquecemos um banheiro ou que a cozinha ficou no lugar errado. E corrigir isso depois pode dar muito mais trabalho. Com o desenvolvimento de software acontece algo parecido.

Quando elaboramos um PRD bem estruturado, conseguimos explicar melhor para a IA o que realmente queremos. Mas também precisamos revisar esse documento, porque a própria IA pode sugerir funcionalidades que não são necessárias naquele momento.

Tenho procurado analisar o que é essencial, o que pode ficar para uma próxima versão e quais partes precisam ser melhor explicadas.

Um bom PRD não serve apenas para orientar a inteligência artificial. Ele também nos ajuda a organizar nossas próprias ideias dentro de nossas cabeças. Afinal como já li em algum lugar que não me lembro onde: Quando conseguimos explicar nosso problema ele já esta 80% resolvido. 

E quanto mais claro estiver aquilo que queremos construir, menores serão as chances de receber algo completamente diferente do esperado.

💡 Pulo do gato: antes de pedir o código, peça uma imagem!

Aqui quero compartilhar uma prática que comecei a utilizar bastante e que tem me ajudado principalmente na criação dos layouts. Depois de estruturar o PRD, em vez de pedir imediatamente para a IA desenvolver todas as telas, primeiro peço para ela gerar duas ou três imagens mostrando como aquela aplicação poderia ficar.

Por exemplo, se estou criando um sistema de gestão, posso pedir três propostas diferentes para o painel principal, com menus, indicadores e informações organizadas de maneira simples. Nesse momento, não estou preocupado com o código. Quero apenas visualizar como a aplicação poderia ficar.

É parecido com o que fazemos quando vamos reformar uma casa. Antes de comprar os móveis e começar a quebrar paredes, podemos olhar algumas imagens e simulações para decidir qual estilo realmente queremos.

Com a IA, consigo fazer algo parecido.

Se gostei das cores de uma imagem, mas não da organização, peço para ajustar. Se ficou com informações demais, solicito algo mais limpo. Se determinado botão não deveria estar ali, peço para remover. Vou refinando a imagem até chegar próximo do resultado que imaginei.

E aqui está a parte que considero mais interessante: somente depois de definir a aparência da tela é que peço para a IA transformar aquela referência visual em instruções para desenvolver o layout.

Dessa forma, em vez de deixar a ferramenta decidir tudo enquanto escreve o código, já consigo mostrar visualmente aquilo que espero receber.

Isso não elimina a necessidade de testar responsividade, acessibilidade e funcionamento dos componentes, mas ajuda bastante a reduzir o retrabalho.

E o melhor é que consigo utilizar as próprias ferramentas de IA que já fazem parte do meu fluxo, sem precisar obrigatoriamente começar por um programa específico de design ou adicionar novos plugins.

🖼️ Como tenho feito na prática

Meu processo costuma seguir cinco etapas simples:

1. Primeiro organizo o PRD: descrevo as funcionalidades, os usuários e aquilo que realmente precisa existir no sistema.
2. Depois peço algumas imagens: solicito duas ou três propostas visuais diferentes para a tela que quero desenvolver.
3. Escolho e refino o layout: ajusto cores, posições, espaçamentos e retiro os elementos desnecessários.
4. Transformo a imagem em instruções: peço para a IA criar um prompt de implementação respeitando o PRD e o visual escolhido.
5. Por último, desenvolvo e testo: verifico se a interface ficou como imaginei e se tudo está funcionando corretamente.

Parece algo simples, mas essa abordagem tem me ajudado bastante.

Às vezes, antes de pedir para a IA construir alguma coisa, precisamos primeiro mostrar exatamente o que queremos que ela construa.

⚖️ Estamos produzindo mais, mas também assumindo mais responsabilidades

Uma coisa que venho percebendo é que a inteligência artificial está mudando a velocidade com que conseguimos desenvolver aplicações.

Hoje podemos criar funcionalidades em minutos que antes levariam horas ou até dias. Conseguimos experimentar ideias, testar tecnologias e construir projetos completos com muito mais facilidade.

Mas existe outro lado dessa evolução.

Quanto mais conseguimos produzir, mais decisões precisamos tomar e mais responsabilidades acabamos assumindo, no mesmo tempo que tínhamos antes.. Afinal, uma aplicação não deixa de precisar de segurança, testes, organização e manutenção apenas porque foi desenvolvida com inteligência artificial.

É como dirigir um carro muito mais rápido. Conseguimos chegar ao destino em menos tempo, mas isso não significa que podemos deixar de prestar atenção na estrada.

Na verdade, quanto maior a velocidade, maior precisa ser o cuidado.

E acredito que algo parecido está acontecendo com o desenvolvimento de software. A IA está nos dando mais velocidade, mas precisamos acompanhar essa evolução com conhecimento e responsabilidade.

Não acredito que todos os desenvolvedores precisarão trabalhar sozinhos ou que equipes especializadas deixarão de existir. Mas vejo cada vez mais oportunidades para quem consegue utilizar essas ferramentas sem deixar de compreender aquilo que está construindo.

🧩 Talvez o problema não seja não saber, mas achar que deveríamos saber tudo

Voltando àquela sensação que comentei no início do artigo, acredito que parte da insegurança que sentimos vem justamente da expectativa de precisar dominar tudo.

Quando assumimos um projeto completo, começamos a lidar com tantas tecnologias e responsabilidades diferentes que parece impossível acompanhar todas as novidades e ainda conhecer profundamente cada uma delas.

E realmente é impossível saber tudo.

Sempre existirão ferramentas que ainda não utilizamos, problemas que nunca enfrentamos e conceitos que precisaremos estudar.

Mas isso não significa que somos incapazes.

Pense em quantas coisas que hoje fazemos com naturalidade também pareciam complicadas quando começamos a estudar programação. Quantos erros precisamos cometer antes de entender determinado conceito? Quantas vezes pensamos que não conseguiríamos resolver um problema e, depois de algumas tentativas, encontramos uma solução?

Talvez o maior erro seja comparar aquilo que ainda não sabemos com tudo aquilo que imaginamos que deveríamos saber. A síndrome do impostor pode aparecer justamente quando esquecemos de olhar para o caminho que já percorremos.

E aqui não estou dizendo que basta acreditar em nós mesmos para resolver qualquer problema. Precisamos reconhecer nossas limitações, estudar e pedir ajuda quando necessário.

Mas também precisamos dar valor àquilo que já aprendemos.

Não dominar uma tecnologia hoje não significa que não podemos aprendê-la amanhã.

🚀 Utilizar IA para aprender, e não apenas para entregar

Nos últimos meses venho desenvolvendo projetos que me fizeram estudar tecnologias, ferramentas e conceitos que eu ainda não conhecia profundamente.

Em alguns momentos, a IA entregou exatamente aquilo que precisava. Em outros, passei horas corrigindo problemas, refazendo prompts, analisando código e pesquisando soluções. Mas percebi que, mesmo quando alguma coisa não funcionava, sempre existia uma oportunidade de aprender.

Às vezes era uma configuração de hospedagem, uma regra de segurança, um conceito de banco de dados ou uma maneira diferente de organizar o código. Em outras situações, o aprendizado estava em perceber que precisava planejar melhor ou simplificar determinada funcionalidade.

E talvez essa seja uma das principais mudanças que estou tentando incorporar na minha maneira de trabalhar.

Não quero utilizar IA apenas para receber respostas. Quero utilizá-la também para aprender a fazer perguntas melhores.

Porque existe uma diferença enorme entre pedir para uma ferramenta resolver um problema e realmente compreender por que aquela solução funciona. E quanto mais conseguimos entender, mais preparados ficamos para enfrentar o próximo desafio.

🌌 Mais um aprendizado no CodeVerse2026

Dessa vez não quis apresentar um novo sistema, uma linguagem ou uma tecnologia específica. Quis compartilhar uma reflexão sobre algo que venho vivendo durante essa jornada de aprendizado e desenvolvimento com inteligência artificial.

Existem dias em que conseguimos resultados incríveis e outros em que um problema aparentemente simples parece colocar em dúvida tudo aquilo que já aprendemos.

Mas tenho procurado entender que essas dificuldades também fazem parte do processo.

Não precisamos dominar todas as tecnologias, acertar todas as decisões ou compreender imediatamente cada linha de código gerada pela IA. Precisamos continuar estudando, questionando, testando e assumindo a responsabilidade pelas soluções que desenvolvemos.

A inteligência artificial está mudando a maneira como programamos, e acredito que ainda veremos muitas transformações nos próximos anos. Mas, independentemente das ferramentas que surgirem, quero continuar valorizando aquilo que me trouxe até aqui: a curiosidade de aprender, a vontade de construir e a persistência para tentar novamente quando alguma coisa não funciona.

E quando aquela velha síndrome do impostor resolver aparecer, quero lembrar que não preciso saber tudo para continuar evoluindo. Preciso reconhecer o que ainda não sei e estar disposto a aprender.

Porque, no final das contas, não é sobre competir com a inteligência artificial para descobrir quem escreve mais código.

É sobre aprender a utilizá-la para construir soluções cada vez melhores, sem deixar de desenvolver o nosso próprio conhecimento.

Seguimos evoluindo, um aprendizado e um commit de cada vez. 🚀

💬 E você, já passou por isso?

Já teve aquele momento em que a IA ajudou a construir algo incrível e, pouco depois, você ficou horas tentando resolver um problema aparentemente simples? Ou já se pegou questionando seus próprios conhecimentos enquanto desenvolvia um projeto com tecnologias que ainda estava aprendendo?

Compartilhe sua experiência nos comentários! Acredito que muitos desenvolvedores passam por situações parecidas e que podemos aprender bastante conversando sobre esses desafios.

Se gostou dessa reflexão, curta e compartilhe para que ela alcance outros desenvolvedores que também estão nessa jornada. E, se quiser acompanhar meus projetos, estudos e os próximos artigos do CodeVerse2026, deixo aqui meus perfis:

• 🔗 LinkedIn: Carlos CGS
• 💻 GitHub: Carlos-CGS
• Link do CodeVerse 2026: https://github.com/Carlos-CGS/CodeVerse2026

Obrigado por acompanhar mais um artigo do CodeVerse2026. Nos vemos no próximo! 🚀