Como montar um portfólio de programador com IA e provar seu valor na entrevista?

Um portfólio de programador com IA não se prova por volume de código, e sim por decisão, arquitetura, teste e correção. Usar IA já não diferencia ninguém: 84% dos devs usam ou planejam usar ferramentas de IA no desenvolvimento, contra 76% em 2024. O que ainda diferencia é revisar, validar e consertar o output. Neste guia você monta o material do próprio repositório (commits, testes, bugs corrigidos, registro de decisão), declara o uso de IA de forma verificável e prepara o resumo de 60 segundos pra entrevista, na ordem problema, decisão, risco e prova.
Fala aí, beleza? O medo tem nome e todo mundo que programa com IA já sentiu: chegar na entrevista, abrir o projeto e ouvir o clássico "legal, mas o que exatamente VOCÊ fez aqui?"
Só que tem um detalhe: usar IA não te diferencia mais de ninguém
A pesquisa do Stack Overflow de 2025 mostra 84% dos desenvolvedores usando ou planejando usar ferramentas de IA no processo de desenvolvimento, contra 76% em 2024
O relatório DORA de 2025 vai na mesma direção, com adoção de IA em 90% dos respondentes (alta de 14% sobre o ano anterior)
Ou seja: dizer "fiz com IA" hoje é quase dizer "usei um editor de texto"
O que sobra pra provar, então? Exatamente o que a IA não entrega sozinha: a decisão, a arquitetura, o teste e a correção
Este post é o método pra montar isso, do material que você extrai do próprio repositório até a frase que você fala na entrevista 🙂
Por que entrevista técnica mudou: IA virou parte do teste, não trapaça
O Google está com um piloto de rodada de entrevista chamada "code comprehension" em que o candidato tem o Gemini disponível como assistente
Formação Claude Code
Domine Claude Code do absoluto zero até o avançado
- 110 aulas
- 4 projetos
- 9h 2min
É pra vagas júnior e pleno de engenharia de software, em times selecionados nos EUA, no segundo semestre de 2026, num formato descrito como "human-led, AI-assisted"
Quem confirmou publicamente o piloto foi Brian Ong, VP de recruiting do Google
E o que eles dizem avaliar nessa rodada é "AI fluency": engenharia de prompt, validação do output e capacidade de depuração
Repara que nenhum desses três é "escrever muito código rápido"
A Meta também entrou nessa: o piloto começou em outubro de 2025, substituindo uma das duas rodadas de código da etapa onsite, num ambiente de código ao vivo com uma janela de chat de IA integrada
E tem o número que resume o clima: Sundar Pichai declarou que 75% do novo código do Google é gerado por IA e aprovado por engenheiros, contra cerca de 50% no fim de 2025
Leia a palavra "aprovado" de novo
O valor migrou pra revisão e julgamento
Se a empresa já assume que a máquina escreve, o que ela precisa medir em você é se você sabe olhar aquilo e dizer "isso aqui vai quebrar em produção"
O que você precisa ter em mãos antes de montar o portfólio
Antes de escrever qualquer coisa bonita, junta o material bruto
Tudo isso sai do seu próprio repositório, não precisa de ferramenta nova:
- Histórico de Git com commits legíveis: mensagem que explica o que mudou e por quê, não trinta commits "fix"
- Os testes do projeto: quais existem, o que cada um protege e como rodar
- Os bugs que você corrigiu no que a IA gerou: issues, diffs, print de erro, anotação de bloco de notas, qualquer rastro serve
- As decisões de arquitetura: o que você considerou, o que escolheu e o que abriu mão
- A política de uso de IA do projeto, quando existir (em projeto open source isso já é comum)
Tome cuidado com uma coisa: nada disso dá pra reconstruir de memória seis meses depois
Se você não guardou, tudo bem, acontece
Aí o combinado é outro: o próximo projeto começa guardando desde o primeiro commit
Como montar um portfólio de programador com IA passo a passo
1. Escolha 2 ou 3 projetos e defina o problema real de cada um
Escreve em uma frase o problema que o projeto resolve e pra quem
Exemplo: "painel que junta os pedidos de três marketplaces num lugar só, porque a loja perdia pedido trocando de aba"
O erro comum deste passo: listar 12 repositórios vazios pra parecer produtivo
Quantidade aqui joga contra, porque quem entrevista abre um aleatório e você precisa saber defender aquele
2. Escreva o registro de decisão de cada projeto
Um arquivo curto por decisão importante: alternativas consideradas, escolha e trade-off aceito
Exemplo: "fila em banco versus fila dedicada; ficou banco porque o volume é baixo e o time é uma pessoa; o custo disso é que acima de X pedidos por minuto precisa migrar"
O erro comum deste passo: descrever o que o código faz em vez de por que ele é assim
O que o código faz a pessoa lê sozinha, e a IA também descreve
O porquê é só seu
3. Documente a arquitetura mostrando limites e responsabilidades
Um diagrama simples ou um README de estrutura já resolve: quais são os módulos, quem fala com quem, o que cada parte pode e não pode fazer
O erro comum deste passo: colar a árvore de pastas e chamar aquilo de arquitetura
Árvore de pastas mostra onde os arquivos estão, não mostra decisão de fronteira
4. Mostre os testes e ligue cada um a um risco
Não basta dizer "tem teste"
Diz o que o teste protege: "esse teste garante que pedido duplicado não vira cobrança dobrada"
Coloca no README como rodar:
npm test
O erro comum deste passo: cobertura alta sem asserção relevante
Dá pra ter número bonito testando getter e não testar a regra que dá prejuízo se falhar
5. Abra um caso de correção real
Esse é o passo que mais vale na entrevista, e o que quase ninguém faz
Pega um caso em que o output da IA estava quase certo: mostra o trecho, explica o que quebrava, como você descobriu e como provou que o conserto funcionou (de preferência com o teste que passou a existir depois)
E isso não é vergonha nenhuma, é o problema número um do mercado inteiro: 66% dos desenvolvedores apontam "soluções de IA quase certas, mas não totalmente" como problema, e 45% dizem que depurar código gerado por IA toma mais tempo
O erro comum deste passo: esconder que houve erro
Portfólio sem cicatriz parece portfólio de quem nunca rodou o projeto de verdade
6. Declare o uso de IA de forma verificável
Se você usa Claude Code, parte disso já acontece sozinho: ao criar um commit, ele adiciona por padrão o trailer Co-Authored-By: Claude <[email protected]> na mensagem, e um rodapé na descrição de pull requests
Na prática, o seu histórico fica assim:
feat: valida payload do webhook antes de enfileirar
Co-Authored-By: Claude <[email protected]>
Isso é ajustável pela chave attribution, com os campos commit e pr, no settings.json do Claude Code (o do usuário em ~/.claude/settings.json ou o do projeto em .claude/settings.json)
A antiga chave includeCoAuthoredBy está deprecada, então se você copiou config de tutorial velho, vale conferir na documentação de settings do Claude Code
Além do commit, existem convenções abertas pra declarar isso de forma legível por máquina
Uma é a convenção ai-disclosure, com um arquivo AI_DISCLOSURE.md no repositório, mantida pela comunidade (não é padrão oficial do GitHub nem de fornecedor de IA)
Outra é o padrão AI-DECLARATION.md, que usa um arquivo com frontmatter YAML seguido de uma seção de notas em markdown
E se você contribui com open source, dá uma olhada na lista pública de políticas de contribuição com IA, porque cada projeto tem sua regra
Esse também é o momento de pensar em onde o seu código roda quando você pede ajuda pra IA, assunto que rendeu um post inteiro sobre o código sair ou não da sua máquina
O erro comum deste passo: apagar o rastro de IA achando que fica mais convincente
Inverte a lógica: quem declara e mostra o que revisou passa a impressão de controle, quem esconde passa a impressão de que tem algo pra esconder
7. Escreva o resumo de 60 segundos
Último passo, e é o que você vai FALAR, não o que você vai publicar
A ordem é sempre: problema, decisão, risco, prova
"O problema era X, decidi Y em vez de Z por causa disso, o risco que sobrou é esse, e aqui está o teste que garante que não volta"
O erro comum deste passo: começar pela stack
Ninguém contrata lista de tecnologia, contrata alguém que sabe onde a coisa quebra
Como falar do projeto em cada situação: entrevista, proposta de freela e README
O material é o mesmo, o recorte é que muda
| Situação | O que você põe na frente | O que fica de fundo |
|---|---|---|
| Entrevista técnica | Narrativa de depuração: prompt, validação do output, conserto | Stack e print de tela bonita |
| Proposta pra cliente | Decisão traduzida em risco evitado e custo de manutenção | Nome de biblioteca e detalhe interno |
| README público | Contexto, arquitetura, como rodar os testes e declaração de uso de IA | Histórico pessoal do projeto |
Na entrevista, prepara a história de um bug do começo ao fim, porque é literalmente o que o Google diz avaliar na rodada assistida: engenharia de prompt, validação do output e depuração
Na proposta de freela, o cliente não quer saber de arquitetura hexagonal, quer saber quanto custa quando quebrar
Então a mesma decisão vira outra frase: "escolhi assim pra você conseguir trocar de gateway sem reescrever o checkout"
No README, escreve pra alguém que caiu ali de paraquedas e tem cinco minutos
E tem um pano de fundo que fecha os três: a conclusão central do DORA 2025 é que a IA amplifica pontos fortes e fracos existentes, times fortes melhoram e times com problemas têm os problemas intensificados
Traduzindo pro seu portfólio: a ferramenta não é o diferencial, ela é um multiplicador do seu processo
Se o processo é bom, aparece; se não tem processo, também aparece 😅
O que separa quem só gera código de quem é considerado programador
No vídeo abaixo eu falo sobre quando alguém pode se considerar programador júnior, e as respostas de lá servem quase inteiras pra essa conversa de portfólio
A primeira delas: não existe um parâmetro fixo nem uma prova que transforme a pessoa em júnior, a avaliação vem de um conjunto de sinais observáveis
O sinal principal que eu descrevo é autonomia: conseguir pegar uma tarefa pequena e entregar do início ao fim, testada e resolvida, sem depender dos colegas a cada passo
E eu faço questão de separar duas coisas que confundem muita gente: pesquisar no Google e tirar dúvida pontual é normal e sempre vai ser
O que caracteriza o júnior é não precisar que outra pessoa execute a solução por ele
Troca "outra pessoa" por "a IA" e a régua continua a mesma, né?
Outro ponto do vídeo que casa direto aqui: sair do loop de tutoriais
Eu vejo muita gente pulando de linguagem em linguagem na primeira barreira e repetindo o mesmo básico pra sempre, sem nunca sair do lugar
O conselho é parar de assistir e começar a construir, porque no projeto real você é obrigado a revisitar vários conhecimentos pra fazer a funcionalidade rodar de ponta a ponta
E olha que interessante: hoje dá pra montar coisa funcionando mesmo sem escrever uma linha de código, o que só reforça que o projeto pronto sozinho não prova nada
O que prova é o que você entendeu do que está ali dentro
Inclusive porque confiar cegamente no output não é o padrão do mercado: 46% dos desenvolvedores desconfiam ativamente da precisão das ferramentas de IA, 33% confiam e só 3% confiam muito no que sai
No DORA 2025 a divisão é parecida: 24% confiam "muito" ou "bastante" (4% mais 20%) e 30% confiam "pouco" ou "nada" (23% mais 7%)
E isso convive com ganho real percebido: mais de 80% dizem que a IA melhorou sua eficiência e 59% relatam impacto positivo na qualidade do código
Ou seja, o mercado usa MUITO e confia pouco
Adivinha quem ele contrata nesse cenário: quem sabe checar
Mais duas coisas do vídeo que eu levaria pro portfólio: planejar antes de escrever código nas tarefas maiores (raciocinar, colocar no papel, listar possibilidades e pensar no que pode dar problema) e estudar o que as vagas estão pedindo, abrindo uma vaga que você quer, listando os requisitos que faltam e estudando exatamente aqueles
Esse plano no papel, guardado, vira o seu registro de decisão de graça 😀
E fecha com o que eu falo lá no final: todo conhecimento novo, inclusive o que veio de projeto guiado por instrutor, precisa virar um projeto seu depois
Senão as dúvidas que aparecem são as do instrutor, não as suas
Com IA é idêntico: se você nunca esbarrou numa dúvida sua dentro daquele código, ele ainda não é seu
O próximo passo: escolha um projeto e prove uma decisão hoje
A régua do mercado já se mexeu, e ela não se mexeu pro lado de quem escreve mais linha
Quando 75% do código novo de uma empresa como o Google sai de IA e passa por aprovação de engenheiro, o que está sendo comprado é julgamento
Então a prova do seu valor é processo documentado: a decisão que você tomou, o limite que você desenhou, o teste que você amarrou num risco e o erro que você caçou no output quase certo
Não precisa refazer tudo hoje, se liga no tamanho do primeiro passo
Pega UM projeto seu, escreve o registro de uma decisão e o caso de um bug que você corrigiu no que a IA gerou, e publica com a declaração de uso de IA no repositório
Só isso já te coloca à frente de quem só tem link de deploy pra mostrar
Bora fazer? Até o próximo post!
Perguntas frequentes
Preciso declarar que usei IA no portfólio ou isso passa a impressão errada?
Declarar ajuda mais do que esconde, porque hoje isso é padrão de mercado: 84% dos desenvolvedores já usam ou pretendem usar IA no desenvolvimento. O que pesa na entrevista não é ter usado, é mostrar decisão, correção e teste em cima do que a IA gerou.
Como provar que corrigi um erro da IA se não guardei nada do processo na época?
Se não guardou, não dá pra reconstruir de memória meses depois, então o caminho é assumir isso e não forçar um caso frágil. O combinado vale pro próximo projeto: registrar issue, diff ou print de erro desde o primeiro commit.
Vale a pena mostrar o commit com Co-Authored-By: Claude no portfólio?
Sim, porque é um registro verificável, não uma alegação sua. O Claude Code adiciona esse trailer por padrão ao criar um commit, e a opção fica na chave ‘attribution’ do settings.json caso você queira ajustar o que aparece em commit e em pull request.
Qual a diferença entre mostrar o código e mostrar a decisão de arquitetura numa entrevista?
O código qualquer pessoa lê sozinha, e a IA também descreve o que ele faz. O porquê da escolha (a alternativa descartada, o trade-off aceito) é o que só quem decidiu consegue explicar, e é justamente isso que rodadas como a de ‘code comprehension’ do Google dizem avaliar.
Existe um jeito padronizado de declarar uso de IA num projeto open source?
O que existe são propostas abertas. Uma é o arquivo AI_DISCLOSURE.md da convenção ‘ai-disclosure’, mantida pela comunidade e que não é padrão oficial do GitHub nem de fornecedor de IA. A outra é o AI-DECLARATION.md, com frontmatter YAML seguido de uma seção de notas em markdown. Também há uma lista pública que reúne políticas de projetos sobre contribuição gerada por IA.
Cobertura de teste alta já é suficiente para provar qualidade no portfólio?
Não, número de cobertura sozinho não mostra nada, porque dá pra testar getter e deixar de fora a regra que dá prejuízo se falhar. O que convence é ligar cada teste a um risco específico, tipo ‘esse teste garante que pedido duplicado não vira cobrança dobrada’.
Formações
Formação Vibe Coding
Do Prompt ao Produto: Crie Software Real com IA
- 474 aulas
- 20 projetos
- 39h 27min
Blog | Mais populares
O que significa “ChatGPT network error” e como resolver
O “ChatGPT Network Error” é uma ocorrência frequente na rotina de muitos usuários do ChatGPT. Porém, poucos compreendem seu significado, quando esse erro surge, etc. […]
As diferenças de var, let e const
Checklist de segurança n8n VPS pública: guia essencial para proteger sua instalação
Checklist de segurança n8n VPS pública: guia essencial para proteger sua instalação A popularidade da automação de processos com o n8n está em alta, principalmente […]
