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

Desenvolvedor organizando portfólio de programador com IA com commits, testes e decisões documentadas no repositório
Resposta rápida

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
Formação Recomendada

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’.




Subscribe
Notify of
guest

0 Comentários
Oldest
Newest Most Voted

Formações

Formação Vibe Coding

Formação Vibe Coding

Do Prompt ao Produto: Crie Software Real com IA

  • 474 aulas
  • 20 projetos
  • 39h 27min

Blog | Mais populares