HANDS-ON
Do executor de código ao orquestrador cognitivo — uma transição que já começou
Prefere o essencial antes? Ler a síntese (~1 min)
Quantos de vocês passam mais de metade do dia resolvendo tarefas repetitivas… em vez de desenhar arquitetura?
Se você levantou a mão — mesmo que mentalmente — esta apresentação é para você.
E se você achava que a IA ia resolver isso, deixando seu dia mais leve — vamos precisar conversar sobre isso também.
APRESENTAÇÃO
Desenvolvedor desde 2003 · Na Rede desde 2018 · Apoio à conquista de novos clientes
44 anos. Casado com a Talita. Pai da Yumi (14), Lucas e Matheus (9).
Sistemas de Informação · Operações Logísticas · Estatística Aplicada · Ciência de Dados.
Mais de 22 anos desenvolvendo sistemas.
Não é apenas aprender uma ferramenta nova.
Ferramentas mudam. Modelos evoluem todos os dias.
O que não muda é a sua capacidade de pensar, julgar e decidir.
O que precisa evoluir é você.
Antes da ferramenta, três palavras.
O esqueleto invisível que sustenta tudo que vem depois — e que a IA jamais substitui.
O que expande você
Uma ferramenta é um recurso criado para facilitar, aprimorar ou tornar possível a execução de uma tarefa. Ela serve para expandir as capacidades naturais do ser humano — sejam físicas ou mentais — reduzindo o esforço necessário para atingir um objetivo.
A calculadora é a primeira ferramenta cognitiva da humanidade: em vez de gastar energia mental com cálculos repetitivos, você terceiriza esse esforço e libera sua mente para o que importa. A IA generativa é a calculadora cognitiva do século XXI — mas para pensamento, não para números.
O processo em execução
Definir o pensamento é como descrever o vento: você não o vê diretamente, mas sente seus efeitos em todas as ações. Em essência, pensamento é a nossa interface com a realidade. É o processo de manipular informações para formar conceitos, criar hipóteses, lembrar e decidir caminhos. É o que acontece entre o problema e a solução.
A IA processa. Você pensa. A diferença não está na velocidade — está na consciência e na intencionalidade por trás de cada movimento.
A qualidade do pensamento
Se o pensamento é a atividade em si, a inteligência é a qualidade dessa atividade. A IA possui inteligência analítica formidável — processa dados, encontra padrões, gera soluções em escala. Mas falha em inteligência contextual: não entende o que não está escrito, não percebe quando as premissas mudaram, não sente a pressão política de uma decisão.
O novo valor do profissional está exatamente nessa lacuna: ser o filtro crítico, o guardião do contexto, o juiz do que a máquina não consegue ver.
Ela não nos fez mais burros. Ela nos liberou para o que importa.
O cérebro humano usa o pensamento analítico para processar cálculos matemáticos de forma sequencial e lógica. Mas esse processamento gasta tempo e energia metabólica.
A calculadora terceiriza esse esforço mecânico — ela processa informação matemática de forma instantânea e devolve sua mente para tarefas de maior nível cognitivo.
A IA generativa é a evolução máxima dessa calculadora. Não apenas matemática — cognitiva. Ela assume o trabalho braçal do pensamento repetitivo para que você possa focar no trabalho estratégico do pensamento criativo.
O paradoxo que ninguém conta: a IA não torna o dia mais leve automaticamente. Ela elimina a fricção das tarefas simples e torna o dia muito mais denso. O gargalo deixou de ser a produção mecânica — e passou a ser a orquestração e a auditoria. Quem não evolui a forma de pensar, só sente o peso extra.
A tarefa que precisa ser resolvida
O que reduz o esforço de resolução (calculadora → IA)
O que você faz com a energia mental liberada
Vibe Coding não é digitar menos.
É pensar melhor.
É governar intenção com a mesma disciplina que antes você governava sintaxe.
O cliente pede um risoto que remeta a uma noite de outono.
Ninguém quer saber a temperatura do forno. Só a experiência.
Imagine um restaurante de alta gastronomia. Quando um cliente se senta à mesa e pede um "Risoto de Cogumelos que remeta a uma noite de outono", ele está fazendo um pedido puramente abstrato — quer uma experiência, não uma receita. Não dita a temperatura do forno nem a miligramagem do sal.
No desenvolvimento tradicional, o desenvolvedor era quem cortava cada ingrediente manualmente: linha por linha de código, configuração de servidor, exaustão de sintaxe.
Hoje, a cozinha foi hiper-automatizada. A IA generativa é a super-calculadora da cozinha: ela pica dez quilos de cebola em segundos, calibra o forno instantaneamente e conhece a "receita" de qualquer framework do mundo. O desenvolvedor parou de ser o operário da cozinha.
Mas há um perigo silencioso: o chef que para de entender os ingredientes porque a IA sempre picou a cebola começa a perder o julgamento sobre o prato. Velocidade sem maestria é eficiência sem direção. O risco não é a IA tomar o emprego — é você terceirizar o julgamento.
E há algo que a IA nunca vai saber: se aquele cliente tem alergia. Se a cozinha do restaurante atende às regras de segurança alimentar. Se a "noite de outono" daquele cliente é melancólica ou aconchegante.
Isso é com você.
Traz o desejo abstrato
Foca no valor final. Não dita receita, ingrediente ou método. Ele sabe o que quer sentir, não como fazer.
Pica, calibra, executa
Conhece todas as receitas, escreve qualquer linguagem, em segundos. É rápida, precisa e incansável — mas executa sem julgamento.
Garante que o prato tenha alma
Julga contexto, segurança, regras de negócio. Assume a responsabilidade pelo resultado. É o seu nome que está na porta do restaurante quando o prato sai errado.
ATO II
Mas afinal —
quem é o Devin?
Não é um chatbot que responde perguntas. É um agente operacional — um executor orientado a objetivos que usa ferramentas reais para alterar sistemas reais. A diferença muda tudo.
COMUNICAÇÃO COM IA · ÉPICO 04
Engenharia de prompt não é uma habilidade técnica de nicho — é a nova forma de liderança técnica. Dominar esses quatro princípios muda a qualidade do que você obtém de qualquer agente — Devin, Copilot, Stackspot ou qualquer outro. Pense nisso como a nova fluência profissional: quem articula melhor a intenção, obtém resultados melhores. Não é magia: é engenharia aplicada.
Comunique como um profissional sênior orientando um iniciante altamente capaz. Sem ambiguidade, sem subentendidos. A IA trabalha a partir do que você escreveu e preenche o resto por inferência, que pode estar errada. Se a instrução for vaga, o resultado será vago.
Clareza não é verbosidade — é precisão. Cada palavra na instrução deve carregar intenção. Remova tudo que for ambíguo; adicione tudo que for necessário para reduzir interpretações incorretas.
❌ Pouco claro
"Melhore esse código."
✅ Claro
"Refatore esse método para seguir o princípio de responsabilidade única, sem alterar o comportamento externo e mantendo os testes existentes passando."
Forneça o cenário, o histórico e as restrições. A IA executa um erro com a mesma velocidade que executa um acerto — a diferença está no contexto que você oferece.
Contexto inclui: qual sistema está sendo modificado, quais são as regras de negócio relevantes, quais decisões já foram tomadas e por quê, e quais são os limites que não podem ser ultrapassados. Quanto mais você tratar a IA como um colaborador que acabou de entrar no projeto, mais assertivo será o resultado.
Dica prática: Antes de cada tarefa significativa, passe ao Devin: (1) o que o sistema faz, (2) o que você está tentando mudar, (3) o que não pode quebrar. Três linhas de contexto valem por dez de instrução.
Mostrar é mais eficiente do que explicar. Sempre que possível, inclua um exemplo do resultado esperado — a IA aprende por padrão.
Em vez de descrever o formato da saída, mostre um caso concreto. Dar um exemplo é o atalho mais eficiente para alinhar expectativas. A IA vai deduzir o padrão e replicar — economizando iterações de ajuste.
Como aplicar: Ao pedir um relatório, cole um exemplo de relatório bem-feito. Ao pedir refatoração, mostre um trecho já refatorado como referência. O exemplo substitui mil palavras de descrição.
Encare a comunicação com a IA como um ciclo, não como um disparo único. Refine, ajuste, recalibre. Nenhum prompt perfeito sai de primeira.
Assim como nenhuma conversa importante acontece em uma única fala, instrução e resposta de IA são um diálogo. Se o resultado não for o ideal, analise onde a instrução falhou — e tente novamente com mais precisão. O problema raramente é a ferramenta; quase sempre é o contexto ou a clareza.
✅ Postura correta
"O resultado não foi o esperado. O que no meu prompt causou isso?"
❌ Postura incorreta
"A IA não presta."
ANATOMIA DO DEVIN · ÉPICO 05
Entender seus limites e pontos fortes é essencial para colaboração eficaz.
Entrada · Contexto visual e textual
Devin lê arquivos, histórico de commits, output de terminal, conversas anteriores. Ele trabalha com o que você forneceu — sem acessar bases externas ou fazer chamadas de API para "buscar conhecimento". Tudo que ele sabe vem do que está no contexto da conversa atual. Isso significa que contexto bem estruturado é a variável mais importante que você controla.
Cognição · Ciclo ReAct — Observar, Raciocinar, Agir, Verificar
Devin não "acha a resposta" em um banco de memória gigante. Ele opera em ciclos: Observa o contexto e o estado atual do sistema; Raciocina sobre a melhor sequência de ações; Age — escreve código, executa comandos, modifica arquivos; e Verifica o resultado antes de avançar. Esse loop rápido de feedback permite corrigir erros no caminho, não depois. É pensamento sequencial com validação contínua — o oposto de um oráculo que gera resposta sem verificação.
É por isso que o Devin cria um PR com testes passando — não uma resposta com código que "parece certo". Cada ação tem consequência verificável no mundo real.
Saída · Código, testes, documentação, reflexão
Devin não apenas escreve código — também fornece testes que validam comportamento, documentação que explica decisões, e reflexão sobre onde teve incerteza. Você recebe não apenas a solução, mas evidência de que funcionou. Essa transparência é estrutural: você pode auditar o raciocínio, não apenas aceitar o resultado.
O que Devin não consegue — e por que isso importa
Devin não é seu gerente de projeto. Não entende prioridades de negócio profundas. Não é seu arquiteto — decisões sobre trade-offs arquiteturais continuam sendo suas. Não é seu juiz — não pode dizer "em sua empresa, a forma correta é X". Tudo isso requer contexto humano que vai além de código.
⚠ Autonomia sem governança é o risco real. Um agente sem limites claros age — e as consequências são reais. Definir onde o Devin age e onde você decide é parte do trabalho do orquestrador soberano.
Onde o Devin é excelente
Refatoração sem receio de quebra — ele testa tudo. Documentação de código exaustiva. Iteração rápida sem ego ("fiz assim, mas posso fazer diferente se preferir"). Integração com ferramentas de build e test. Análise de erros precisa e sistemática.
GOVERNANÇA DE MEMÓRIA · ÉPICO 05
Cenário: Projeto novo, Devin não conhece a base de código.
Estrutura: Código walkthrough → explicação de arquitetura → constraints → exemplos reais de padrão.
Resultado: Devin entende nuances, evita erros de contexto, propõe soluções alinhadas com padrões existentes.
Cenário: Devin já conhece o projeto; você tem uma task bem definida.
Estrutura: Apenas arquivo relevante → erro específico → critério de sucesso.
Resultado: Velocidade máxima, execução precisa em escopo claro, economia de tokens.
Cenário: Conversa longa onde feedback refina progressivamente o resultado.
Estrutura: Incremento mínimo de contexto por turno → feedback do resultado anterior → refinamento.
Resultado: Aprendizado compartilhado, economia de tokens, qualidade progressivamente melhor.
Contexto governado permite ciclos rápidos e precisos. Feedback refina contexto para o próximo ciclo — qualidade cresce a cada iteração.
Contexto em uma conversa com a IA é como memória viva — persiste enquanto a janela de conversa está aberta. Quanto maior a janela de contexto (tokens disponíveis), mais história o Devin pode carregar e usar para decisões mais precisas.
Mas contexto bagunçado causa alucinação — o modelo tenta fazer conexões em informação fragmentada e incompatível. Contexto governado causa precisão — o modelo entende a estrutura da informação e a usa corretamente para gerar soluções alinhadas.
Pense no contexto como o briefing que você dá a um desenvolvedor sênior no primeiro dia. Se for vago, ele vai improvisar. Se for preciso — arquitetura, regras de negócio, restrições, exemplos — ele vai entregar alinhado desde o primeiro PR.
Em escala de time, isso evolui para o que chamamos de Context Lakes: repositórios estruturados de conhecimento corporativo que qualquer agente pode consumir — padrões de código, decisões arquiteturais, políticas de segurança, particularidades do negócio. O conhecimento para de morar na cabeça do desenvolvedor sênior e começa a escalar para o time inteiro.
OS TRÊS ARSENAIS · ÉPICO 06
Skills (o que você sabe fazer), Playbooks (como você faz) e Knowledge (o que você referencia) — os três eixos que governam toda colaboração eficaz com agentes de IA. Juntos, eles transformam conhecimento individual em inteligência organizacional escalável. É o que separa um desenvolvedor usando IA de um time usando IA.
O que você sabe fazer — especialidades onde Devin executa com excelência, sem supervisão linha por linha.
Como você faz — padrões de colaboração reutilizáveis. Scripts conversacionais para trabalho recorrente.
O que você referencia — memória corporativa estruturada. Documentação viva que cresce com o projeto.
| Skills | Playbooks | Knowledge | |
|---|---|---|---|
| Velocidade de execução | Alta | Média | Alta |
| Profundidade de resultado | Alta | Alta | Média |
| Autonomia do agente | Alta | Média | Baixa |
| Escalabilidade para times | Média | Alta | Alta |
| Complexidade de setup | Baixa | Média | Alta |
As especialidades onde Devin agrega máximo valor.
Cada skill é um domínio onde o Devin executa com excelência, sem necessidade de supervisão linha por linha.
Devin refatora código com confiança porque testa cada mudança. Sem receio de quebra, com compreensão profunda do padrão original e do comportamento esperado.
Quando usar
Quando seu código ainda funciona mas ficou complexo demais para evoluir com segurança.
Contexto esperado
Código original + testes existentes + critério de refactor (qual princípio aplicar).
Resultado esperado
Código refatorado + testes passando + explicação das mudanças realizadas.
Devin escreve testes que cobrem edge cases que você não pensou. Testa comportamento, não apenas happy path — cobertura real, não superficial.
Quando usar
Quando precisa cobrir casos extremos ou está migrando para nova arquitetura.
Contexto esperado
Função/módulo + exemplos de edge cases + padrão de teste existente no projeto.
Resultado esperado
Testes abrangentes + coverage report + análise de gaps identificados.
Devin documenta não apenas o "o quê", mas o "por quê" — decisões, trade-offs e armadilhas comuns. Documentação que realmente ajuda quem herda o código.
Quando usar
Quando seu código é novo ou precisa integrar novos engenheiros no projeto.
Contexto esperado
Código + histórico de decisões (git log, PRs) + público-alvo da documentação.
Resultado esperado
Documentação clara + exemplos de uso + links para código relevante.
Devin lê stack traces, hipotetiza causa, propõe fix, testa. Debug é pensamento sequencial — o ponto forte do Devin. Diagnóstico sistemático, não tentativa e erro.
Quando usar
Quando está preso em erro sem saída óbvia ou o root cause não é claro.
Contexto esperado
Erro completo + logs relevantes + código envolvido + passos para reproduzir.
Resultado esperado
Diagnóstico preciso + fix validado + explicação clara do root cause.
Devin integra componentes, estrutura workflows, orquestra múltiplos serviços. Segue padrões e convenções — não inventa arquitetura, executa a que você definiu.
Quando usar
Quando precisa conectar sistemas ou estruturar um novo fluxo entre componentes.
Contexto esperado
Diagramas/descrição de componentes + APIs envolvidas + requisitos de fluxo.
Resultado esperado
Integração funcional + testes de ponta a ponta + documentação de interface.
PADRÕES DE COLABORAÇÃO
Um playbook é um script conversacional — a sequência de contexto, instrução e iteração que funciona para um padrão recorrente de trabalho.
Situação: Você quer melhorar a qualidade de pull requests antes do merge.
Sequência
Situação: Novo engenheiro chega, precisa entender o projeto rapidamente.
Sequência
Situação: Precisa migrar codebase — Vue 2 → Vue 3, React Class → Function, etc.
Sequência
MEMÓRIA CORPORATIVA
Knowledge é documentação viva — arquitetura, padrões, decisões, lições aprendidas. Quanto melhor documentado seu Knowledge, mais eficiente cada conversa com Devin.
Diagramas de arquitetura, decisões de design, trade-offs aceitos e rejeitados.
Documento de exemplo: "ADR — por que escolhemos monolito modular sobre micro-serviços? Quais trade-offs foram aceitos?"
Benefício: Quando Devin conhece a arquitetura, evita propostas que quebram padrões estabelecidos — sem rework custoso.
Atualização: A cada grande mudança arquitetural (~2–4x por ano).
Code style, naming conventions, estrutura de pastas, padrões de componente.
Documento de exemplo: "Style Guide — como nomeamos componentes, como estruturamos state, como escrevemos testes no nosso projeto."
Benefício: Devin gera código que já segue seu padrão — sem necessidade de refatoração posterior.
Atualização: Quando padrão muda (~1x por semestre).
O que não funcionou, armadilhas que você já enfrentou, soluções que descobriu a partir de erros reais.
Documento de exemplo: "Bugs antigos — 'Performance degrada quando N > 10k registros porque X. A solução testada e validada é Y.'"
Benefício: Devin evita repetir erros que você já aprendeu a custo — sem reintroduzir problemas conhecidos.
Atualização: Contínua — sempre que descobre um novo gotcha.
Três exercícios incrementais. Do simples ao complexo.
Do protótipo ao production-ready.
Demonstração em ambiente real: Devin CLI na raiz de um projeto Salesforce, conectado à Org de Sandbox corporativa.
CENÁRIO
Você recebeu um código legado que funciona, mas é incompreensível. 200 linhas de callbacks aninhados. Prazos apertados impedem reescrita manual.
DESAFIO
Usar Devin para refatorar sem quebrar testes.
RESULTADO ESPERADO
Código funcional, legível, 40 linhas, com testes passando.
Step 1: Código legado
Step 2: Devin refatora
Step 3: Resultado
CENÁRIO
Função de cálculo financeiro. Testa happy-path, mas edge cases aparecem em produção: valores negativos, overflow, divisão por zero.
DESAFIO
Devin gera suite de testes exaustivos que cobrem 95%+ de código.
RESULTADO ESPERADO
80+ testes passando, cobertura de 97%, sem falsos positivos.
80 casos · cobertura 97% · 0 falsos positivos
CENÁRIO
Integrar 4 APIs externas (pagamento, analytics, CRM, logging) em fluxo coerente. Timeout, retry, fallback — orquestração complexa.
DESAFIO
Devin cria orchestrator robusto com circuit breaker pattern.
RESULTADO ESPERADO
Sistema resiliente, testado sob falhas, logging rastreável.
Em vez de o agente adivinhar, ele lê. Em vez de improvisar, ele segue uma partitura. Isso é o que separa Vibe Coding de Engenharia de Intenção: o desenvolvedor não digita menos — ele especifica com mais precisão. Atua como Orquestrador Soberano, definindo arquitetura, critérios de sucesso e restrições antes de qualquer linha de execução.
Refatore esse código.
GenAI retorna refactor que quebra testes existentes.
Falta contexto. Falta clareza.
O prompt violou dois pilares: Clareza — não explicou por que refatorar — e Contexto — não mencionou os testes existentes nem as restrições de compatibilidade.
Lição: A ferramenta não falhou. A comunicação falhou.
Refatore o método getOrders() em
OrderService.cls para adicionar filtro por data.
Restrição: manter assinatura pública. Manter testes existentes passando.
Critério: cobertura ≥ 75%.
Diferença: objetivo + restrições + critério mensuráveis.
Refatoração preserva testes. Novo parâmetro de data adicionado. Cobertura alcançou 92%. PR draft criado automaticamente.
Com SDD — Spec Versionada o agente lê o documento estruturado antes de qualquer execução. A tarefa fica registrada, auditável e revisável pela equipe inteira.
Sempre especifique o objetivo. Sempre inclua restrições. Sempre forneça exemplos do resultado esperado. Vale para a maioria das ferramentas e linguagens.
EFEITO — Menos variação: a mesma spec aproxima o comportamento entre sessões e entre pessoas do time, sem torná-lo idêntico — o agente não é determinístico. Quando um bug aparece, a falha pode estar na spec, no teste ou no código; quem tem autoridade sobre a regra decide o que corrigir.
EFEITO — Antídoto ao Deskilling: A spec força você a articular o raciocínio antes de executar. Você não perde a compreensão — você a documenta. É o que separa quem usa IA como muleta de quem usa como alavanca.
A pasta de especificações como ponto de partida do agente. Tudo versionado no Git. Tudo revisável antes da execução.
salesforce-bupj-project/
│
├── force-app/main/default/classes/
│ ├── OrderService.cls
│ └── OrderServiceTest.cls
│
├── sfdx-project.json
│
├── .agents/skills/
│ └── run-tests.md
│
└── specs/
├── _template.spec.md ← Template base
├── 001-filtro-data.spec.md ← Em execução
└── 002-refactor-pagamento.spec.md
devin@sandbox:~$ sf apex test run --code-coverage --result-format human ✓ 12 testes passando · cobertura: 92%
Você está em um squad de backend refatorando módulo de pagamentos. Aplicação direta dos Exercícios 1-3: refatora, adiciona testes, integra com CRM.
Ganho: Economia de 8 horas vs. refactor manual. Código 40% mais legível. Confiança imediata em deploy.
Junior fez PR com padrão ruim. Em vez de corrigir manualmente, você usa Devin como segundo revisor. Devin analisa padrão, gera exemplos corretos, junior aprende vendo a transformação.
Ganho: Junior sai do code review entendendo por que, não apenas o quê.
Sistema legado sem documentação. Você usa Devin para gerar README, ADRs, guias de contribuição. Skills de documentação aplicadas a arquivos reais.
Ganho: Novo engenheiro onboards em 2 dias vs. 2 semanas. Documentação mantida viva porque integrada ao workflow.
Devin lê a spec. Devin executa o Salesforce CLI. Devin roda os testes. Você revisa e decide.
O desenvolvedor cria ou atualiza o arquivo de spec em /specs/,
descrevendo a regra de negócio, o módulo Apex envolvido e os critérios de aceite.
vi specs/001-filtro-data.spec.md
O Devin interpreta a spec, identifica quais artefatos Salesforce são relevantes e executa o retrieve via Salesforce CLI da Sandbox corporativa — sem que o desenvolvedor precise listar os arquivos manualmente.
sf project retrieve start --metadata ApexClass:OrderService
O agente localiza os arquivos recuperados, aplica a regra de negócio descrita na spec e atualiza os testes correspondentes. Cada modificação é guiada pelos critérios de aceite, o que reduz — sem eliminar — a interpretação livre.
edit force-app/main/default/classes/OrderService.cls edit force-app/main/default/classes/OrderServiceTest.cls
Antes de propor o PR, o Devin executa a suite de testes unitários no Salesforce CLI. Só finaliza a sessão e abre o PR se todos os testes passarem com a cobertura mínima exigida.
sf apex test run --code-coverage --result-format human
Test Results: 12 passed, 0 failed · coverage 92%
HANDS-ON · DEMO AO VIVO
$ devin run --spec specs/001-filtro-data.spec.md › Planner: decomposing spec into 4 subtasks… › Executing: sf project retrieve start --metadata ApexClass:OrderService ✓ Retrieved 1 ApexClass, 1 ApexTest from sandbox-bupj › Refactoring OrderService.cls (added dateFilter param) › Updating OrderServiceTest.cls (3 new assertions) › Validating: sf apex test run --code-coverage ✓ Test Results: 12 passed, 0 failed · coverage 92% › PR draft created — ready for review.
Este é o fluxo real de uma sessão do Devin executando uma spec do projeto Salesforce BUPJ. Do comando inicial até o PR draft criado, o agente operou de forma autônoma. O desenvolvedor entra apenas na última etapa: revisar o PR. O seu tempo foi liberado do trabalho mecânico para o trabalho estratégico.
REFLEXÃO
Não há resposta certa. Apenas a sua.
Você é um orquestrador cognitivo.
A ferramenta não te diminuiu. Te liberou.
ATO III
Agora que vimos o instrumento —
como tocamos juntos?
O Ato III é sobre cultura, time e gestão. Sobre transformar você em força catalisadora de transformação em outros.
O cirurgião não pega o livro de anatomia no meio da cirurgia.
Quando a IA escreve código mais rápido do que você lê, o que justifica a sua presença no time? A resposta está em três dimensões que a IA não substitui: o que você sabe profundamente, o que você treinou até virar instinto, e como você usa a IA a seu favor.
As cinco dimensões humanas que nenhuma máquina consegue replicar:
Domínio da anatomia
O cirurgião dominou anatomia, fisiologia e técnicas cirúrgicas durante anos de estudo antes de pisar na sala de cirurgia. No nosso mundo: arquitetura de sistemas, design patterns, segurança de aplicações, modelagem de dados. Esses fundamentos não mudam quando o framework muda.
A IA é o bisturi. Mas é você quem opera. Operar com bisturi sem saber anatomia é perigoso.
Memória muscular
O cirurgião simulou centenas de cenários antes de sua primeira cirurgia real. No nosso mundo: post-mortems de incidentes, simulações de crise, debugging de sistemas complexos, revisões de código rigorosas. Quando a produção cai às 2h da manhã e a IA não consegue diagnosticar — é a memória muscular do desenvolvedor que salva.
A IA não sente a pressão de um sistema fora do ar. Você sente. Isso não tem substituto.
Ritmo, não força bruta
O cirurgião não usa força para fazer uma incisão. Usa ritmo, ângulo, preparação e precisão. Aperfeiçoamento não é trabalhar mais horas. É trabalhar com mais precisão, aproveitando a IA como alavanca — não como muleta.
Medir seu desenvolvimento por "quanto código a IA gerou por você" é a métrica errada. A métrica certa: qual a complexidade dos problemas que você consegue resolver?
Estudar, treinar, se aperfeiçoar — não é para você trabalhar mais.
É para você trabalhar melhor.
O Devin é um estagiário brilhante.
Você ainda precisa ser o sênior.
Quando cada desenvolvedor usa a IA no seu próprio ritmo, sem alinhamento, o resultado não é uma sinfonia. É ruído. Quatro elementos precisam estar em sincronia para o time produzir algo que vai além da soma das partes.
Processo e Planejamento
Nenhum músico senta no palco e decide o que vai tocar na hora. A partitura é o planejamento estratégico, a arquitetura definida, os processos ágeis desenhados e os rituais de alinhamento.
Arquitetura documentada
Refinamentos com critérios claros
Specs versionadas no Git
Backlog com Definition of Done explícito
Sem partitura, o esforço se perde em improvisação. Cada desenvolvedor segue sua própria interpretação e os entregáveis não convergem.
Ferramentas e IA
Um violino desafinado não é apenas ineficiente — ele destrói a apresentação de toda a orquestra. Devin, Copilot, Stackspot, frameworks e pipelines de CI/CD são os instrumentos. Amplificam o talento, mas precisam ser escolhidos, calibrados e usados com disciplina.
Skills e Playbooks configurados
Ferramentas integradas, não fragmentadas
Padronização antes da escala
Knowledge do contexto corporativo
Um time que usa 17 ferramentas sem integração não está sendo mais produtivo — está criando ruído estruturado.
Pessoas e Treinamento
A melhor partitura do mundo não soa bem se for executada por quem não domina o instrumento. Dev, UX, negócio — são os especialistas. É o humano quem sente a emoção da música, aplica o pensamento crítico e toma decisões quando a partitura é ambígua.
Desenvolvimento humano contínuo
Pensamento crítico sobre output da IA
Maestria antes da velocidade
Colaboração transversal
Times sem investimento em desenvolvimento humano continuarão produzindo código sem alma — por mais avançada que seja a IA disponível.
Liderança e Sincronismo
O Maestro é a única pessoa no palco que não produz um único som. Ele não toca pelo músico. O que ele faz — e que ninguém mais no palco consegue fazer — é garantir que todos entrem em cena no milissegundo exato.
Na era da IA, o líder técnico evolui para Arquiteto de Contexto: sua função principal não é supervisionar tarefas, mas proteger a carga cognitiva da equipe e criar as condições para que o sincronismo aconteça.
Olha para o todo, não para o instrumento
Percebe quando o time está desalinhado
Protege o sincronismo coletivo
Remove obstáculos, não cobra planilhas
Documenta o contexto como "API do time"
Liderança, na era da IA, não é cobrar prazo. É proteger o sincronismo.
Qualquer ferramenta é tão boa quanto o julgamento que a governa. Vibe Coding ensina que a IA é execução, nunca decisão. O desenvolvedor que julga o output é insubstituível. O que apenas aceita sem entender é descartável.
Clareza, contexto, exemplos, iteração são engenharia, não etiqueta. O refinamento ágil se tornou o super-prompt da sprint. Se o pedido chegar vago, a IA executa o erro com precisão e velocidade absolutas. Comunicação é a ferramenta primária.
Nenhuma pessoa tem todas as respostas. Nenhuma IA tem. A força está em admitir incerteza e aprender junto com a equipe. Equipes que aprendem juntas escalam. Devin é facilitador, não oráculo.
Você governa a inteligência que entra em produção. Código rápido sem qualidade é débito técnico com juros. Qualidade é seu nome na porta. A IA não assina o PR. Você assina.
A ferramenta serve os humanos. Nunca o contrário. Vibe Coding quer desenvolvedores mais contemplativos, não mais cansados. O objetivo final não é mais velocidade — é mais liberdade para o trabalho que importa.
Vibe Coding é governo inteligente de ferramentas inteligentes por pessoas cada vez mais inteligentes.
Se o pedido for vago, a IA executa o erro na velocidade da luz. O gargalo do desenvolvimento não é mais a velocidade de digitação — é a clareza da decisão.
O backlog não pode ser um depósito de ideias vagas. O PO e o time de negócio precisam especificar com a clareza de quem está delegando para um desenvolvedor sênior. O refinamento se torna o momento de construção do prompt mais importante da sprint.
O Kanban é a bancada preparada antes do serviço. Num ambiente onde a IA entrega tarefas rápido demais, sem controle de WIP o time tenta fazer oito coisas ao mesmo tempo e nenhuma delas fica bem. A ferramenta não se cansa. O cérebro humano, sim.
A Sprint não é um prazo de esgotamento. É a cadência do trapezista — o balanço que dá impulso e o momento de revisão que corrige a rota. O Scrum não serve para entregar mais. Serve para garantir que o que está sendo entregue é o que deveria ser entregue.
O Scrum Master na era da IA não é um cobrador de planilhas. É a extensão do Maestro — aquele que olha para o todo enquanto cada músico olha para a sua partitura. O papel da facilitação ágil é blindar a mente da equipe do caos externo.
Quando uma métrica se torna meta, ela deixa de ser uma boa métrica. O time otimiza o número e não o resultado. Aumentar a geração de código com IA em 55% sem escalar a validação apenas cria gargalos maiores — e entrega ilusão de velocidade, não velocidade real.
Pare de medir o quê.
Comece a medir o para quê.
FLOW METRICS — O QUE MEDIR NA ERA DA IA
Não é tempo cronológico. É complexidade × número de ações que o agente executa. O Devin cobra por trabalho realizado — quanto mais complexa a tarefa, mais ACUs consome.
Planejamento denso
Decompor objetivos complexos em subtarefas verificáveis
Interações em browser
Navegar em docs, validar UI, interpretar resultados visuais
Pipelines locais
Executar builds, rodar suites de teste, fazer deploys na sandbox
Inferência de modelos
Chamadas a LLMs durante o raciocínio e geração de código
Quando o Devin está aguardando uma ação sua ou esperando um serviço externo finalizar, ele entra automaticamente em modo Sleep. No modo Sleep, o contador de ACUs para completamente. Você não paga por espera.
Esperando sua resposta a uma pergunta → Sleep (contador parado) Aguardando conclusão de uma suite de CI/CD → Sleep (contador parado) Clonando um repositório grande do Git → Sleep (contador parado) Esperando aprovação de PR no repositório → Sleep (contador parado)
A máquina faz o trabalho pesado.
A maestria continua sendo nossa.
A IA é a ferramenta mais poderosa que a nossa profissão já viu. Ela vai picar a cebola, calibrar o forno, escrever a primeira versão de qualquer coisa. Ela não se cansa, não reclama, não pede aumento.
Mas o pensamento — esse continua sendo seu.
A inteligência diante do inesperado — essa continua sendo sua.
O julgamento sobre o que é certo para aquele cliente, naquele contexto,
com aquelas restrições — esse continua sendo exclusivamente humano.
O ritmo, a maestria, a capacidade de fazer um sistema complexo parecer simples para quem está do outro lado: essas continuam sendo exclusivamente nossas.
Você revisa cada ação da IA antes que ela aconteça. Máxima segurança, menor velocidade. Use em tarefas de alto risco ou em domínios desconhecidos.
A IA executa autonomamente; você monitora e pode intervir. Equilíbrio entre velocidade e controle. O fluxo padrão de uma sessão Devin.
Você define intenções; a IA orquestra múltiplos agentes. Máxima escala. Requer Context Lakes, Playbooks e governança consolidada.
O profissional que prospera na economia cognitiva navega pelos três modos com consciência — e sabe quando usar cada um. Isso é a Inteligência Centauro: o humano no comando estratégico, a máquina na execução tática.
Comece pequeno. Meça impacto. Itere.
Não comece pelo projeto mais crítico. Escolha algo com escopo pequeno e resultado verificável: um bug bem definido, uma refatoração pontual, cobertura de teste em código existente. Tamanho ideal: sessão XS ou S.
Use o template em /specs/_template.spec.md. Escreva o Objetivo em uma frase.
Defina os Critérios de Aceite como um checklist verificável. Inclua as Restrições.
Leia a spec em voz alta — se soar vaga, reescreva.
Antes de usar o Devin em produção, configure o que o agente precisa saber: regras de segurança, padrões de código, particularidades do Salesforce, limites de governor aplicáveis, políticas de deploy. Um Devin sem Knowledge é um desenvolvedor sem onboarding.
As eficiências que você descobrir não devem ficar só com você. Padronize os fluxos repetitivos em Playbooks compartilhados. Um time que compartilha Playbooks evolui coletivamente. Um time onde cada desenvolvedor inventa seu próprio fluxo perde o multiplicador mais poderoso do Vibe Coding: a consistência.
Depois de duas semanas usando o Devin, resista à tentação de medir ACUs consumidas ou linhas de código geradas. Meça: o tempo liberado do desenvolvedor foi para trabalho estratégico ou para mais tarefas mecânicas? A qualidade do código entregue melhorou? O onboarding de novos engenheiros ficou mais rápido? Essas são as métricas que revelam se você está usando IA para crescer — ou apenas para correr mais rápido no mesmo lugar.
Os oito episódios que fundamentam o raciocínio desta apresentação — para quem quer ir além do hands-on e entender o sistema completo.
Obrigado.
Continue a conversa.
Mauricio Yokoyama Issei
Tech Lead
Próximo passo → Devin no Salesforce: Quick Start com Flosum
Em síntese
O Vibe Coding maduro não é caos de prompts: é intenção estruturada e persistente. O humano sobe de executor a Orquestrador Cognitivo — dirige a inteligência da máquina com intenção clara, como um chef executivo que responde por cada prato sem cozinhar todos.
É o pilar M0/M3 (Despertar/Orquestrar) da Engenharia da Confiança.
Perguntas frequentes
Vibe Coding é desenvolver software dirigindo um agente de IA por intenção em vez de digitar cada linha. Na forma madura, a intenção é estruturada e persistente (uma especificação versionada), não um prompt efêmero — é o que separa o experimento do método.
No SDD a especificação versionada é a referência da intenção: escreve-se o quê e o porquê, e a IA implementa contra a spec, com testes (BDD) para verificar. A spec não é infalível: quando spec, testes e código divergem, uma pessoa com autoridade decide o que corrigir. Quando a intenção vive num prompt descartável, ela se perde; numa spec versionada no repositório, pode ser revisada e auditada.
É o profissional que dirige a inteligência da máquina com intenção — define o quê e o porquê e julga o resultado — em vez de executar cada linha. Ele consome ferramentas tipadas derivadas de schemas e versiona não só o código, mas o raciocínio que o produziu.
É o arsenal de inteligência organizacional que cresce com o tempo: Skills são procedimentos reutilizáveis (refatorar sem risco, testar de forma exaustiva), Playbooks são receitas de processo (code review, onboarding, migração) e Knowledge é o ativo que acumula (arquitetura, convenções, lições e gotchas).
É a evolução do MCP da consulta para a renderização: o agente usa o protocolo para emitir intenção de interface — o Cérebro decide o quê mostrar (dados sob contrato) e a Vitrine determinística decide como renderizar. A interface deixa de ser texto livre imprevisível e passa a ser output governado, testável e reproduzível.