Robert C. Martin, o Uncle Bob, autor do livro Clean Code, anunciou que não lê mais o código que os agentes de IA escrevem. Clean Code morreu? 🚨 Participe do maior workshop avançado de IA para devs do Brasil https://tinyurl.com/rmranaws Você vai ver o que sobreviveu do Clean...
Robert C. Martin, o Uncle Bob, autor do livro Clean Code, anunciou que não lê mais o código que os agentes de IA escrevem. Clean Code morreu?
🚨 Participe do maior workshop avançado de IA para devs do Brasil https://tinyurl.com/rmranaws
Você vai ver o que sobreviveu do Clean Code na era dos agentes, o que inverteu, e o que o Uncle Bob faz no lugar de ler código.
💎 Participe da maior comunidade para devs senior+ do Brasil https://tinyurl.com/4rd35sj4
Capitulos
00:00 Uncle Bob parou de ler código
00:43 Função pequena: o empate que ninguém esperava
01:44 Código grepável: o caso dos 35% menos tokens
02:31 1 arquivo, 1 assunto: a regra que substitui tudo
03:31 O limite de 2000 linhas do Claude Code
04:04 Recado rápido: workshop
04:22 Camada tem custo: o Navigation Paradox
04:52 A estrutura que o agente ama: vertical slice
05:06 O que Uncle Bob faz no lugar de ler
06:11 Gherkin é a tua spec: escreve antes
06:46 O direito de não ler código
07:08 Como parar de ler na prática
07:45 Me conta os teus desafios
Links Importantes
Tweet do Uncle Bob https://x.com/unclebobmartin/status/2044114698451476492
Does Code Cleanliness Affect Coding Agents? (SonarSource, o estudo das 660 execuções)
https://arxiv.org/abs/2605.20049
CodeCompass: The Navigation Paradox (o do gradiente de camadas e do grafo de dependências)
https://arxiv.org/abs/2602.20048
Meu outro vídeo sobre arquitetura na era da IA https://youtu.be/qLEg0PLWj2k
Depois de uma votação disputada e conteúdo de alto nível, chega a hora do TLC Share Day #06. Nossa sexta edição acontece no dia 01/08, às 10h, reunindo membros da Tech Leads Club para compartilhar experiências reais, aprendizados práticos e reflexões relevantes sobre...
Depois de uma votação disputada e conteúdo de alto nível, chega a hora do TLC Share Day #06.
Nossa sexta edição acontece no dia 01/08, às 10h, reunindo membros da Tech Leads Club para compartilhar experiências reais, aprendizados práticos e reflexões relevantes sobre tecnologia, carreira e desenvolvimento profissional.
O TLC Share Day é um ciclo de palestras feito pela própria comunidade, em um ambiente aberto, colaborativo e seguro para aprendizado. O encontro acontece ao vivo no Zoom (com transmissão ao vivo pelo YouTube), com espaço para perguntas, debates e troca direta entre palestrantes e participantes.
Convide seus amigos, reserve um tempo na agenda e venha participar ao vivo.
PROGRAMAÇÃO:
10:00
Feature Flags: a forma certa de desacoplar deploy e release
Emilio Heinzmann
Deploy não deveria significar que uma funcionalidade precisa estar disponível para todos os usuários. Com feature flags, é possível controlar a liberação de recursos, realizar rollouts graduais, executar testes A/B, validar hipóteses em produção e reverter mudanças instantaneamente, sem a necessidade de um novo deploy. A palestra explora os conceitos fundamentais, boas práticas de arquitetura e governança para evitar que feature flags virem dívida técnica, e como isso beneficia times cada vez mais autônomos na era da Inteligência Artificial.
10:30
Operação como Arquitetura: o que decide se a automação gera valor ou custo escondido
Joaquim Borges
A maior parte das iniciativas de automação não falha por limitação técnica, mas porque decisões arquiteturais nunca são formalizadas. A palestra trata operação como arquitetura, usando quatro mecanismos de governança operacional em fintech: RFC para decisões operacionais, WIP explícito em backlogs, governança de capacidade pós automação, e One Door versus Two Door aplicado a processo.
11:00
Harness Engineering: O desafio de construir software confiável na era da IA
Italo Castro
A inteligência artificial mudou drasticamente a forma como software é desenvolvido, e com ela surgem novos desafios de confiabilidade, contexto e governança. A palestra apresenta o conceito de Harness Engineering, uma abordagem para construir sistemas de IA preparados para ambientes reais de produção, e como empresas e times de tecnologia precisarão evoluir suas práticas de engenharia para lidar com sistemas probabilísticos e decisões assistidas por IA em escala.
11:30
O agente que aprendeu a dizer "não sei": construindo um agente de plataforma confiável em produção
Felipe Rodrigues
Qualquer um pluga um LLM no Slack, mas difícil é ser confiável. A palestra abre a arquitetura de um agente de IA em produção (AWS Bedrock AgentCore + Strands) que atende suporte de plataforma, e três lições para construir agentes que verificam antes de propor, sabem quando escalar e evoluem sem quebrar o que já funciona.
📆 A nossa sexta edição acontecerá em 01/08, às 10h. Então já marque esse sábado na sua agenda e venha aproveitar esse dia de muito conteúdo de qualidade com a gente.
Aguardamos vocês!
Marque o 🔔 e nos vemos lá!
💎 Conheça a comunidade: https://tinyurl.com/yu7b342m
Loop Engineering tomou conta da comunidade de IA nas últimas semanas: os criadores do OpenClaw e do Claude Code dizem que não trabalham mais com prompts, e sim com loops. 💎 Participe do maior workshop de IA para devs do Brasil https://tinyurl.com/nbex5mds A migração do Bun...
Loop Engineering tomou conta da comunidade de IA nas últimas semanas: os criadores do OpenClaw e do Claude Code dizem que não trabalham mais com prompts, e sim com loops.
💎 Participe do maior workshop de IA para devs do Brasil https://tinyurl.com/nbex5mds
A migração do Bun para Rust, com 1 milhão de linhas geradas por IA, é a prova mais visível disso. Nesse vídeo eu explico a diferença entre loop fixo e loop criador, por que loops sem um bom harness só perpetuam bugs, e mostro o jogo completo que construí em um fim de semana deixando a IA rodar sozinha.
👉🏼 Venha para a maior comunidade de devs sênior do Brasil https://tinyurl.com/57y7meea
Capitulos
00:00 O Bun, a IA e o tal do Loop Engineering
00:44 Como chegamos aqui: a evolução do dev loop
04:05 Loop agêntico x cron job: a diferença real
05:42 Os 2 tipos de loop: fixo e criador
06:48 Loop fixo na prática (benchmark multiagente)
08:20 O jogo que a IA construiu num fim de semana
09:19 O roadmap de 18 fases
12:22 Como o Bun migrou 500 mil linhas pra Rust
13:19 O loop NÃO roda pra sempre
14:58 Por que o harness é tudo (e por que Rust)
15:55 O erro que quase estragou o jogo
16:35 Loop Engineering não é bala de prata
17:39 As 4 perguntas antes de usar um loop
Vídeos importantes
https://www.youtube.com/watch?v=gK1atE0ssfg
https://www.youtube.com/watch?v=dLs-Pbn8stU
https://youtu.be/YFDp-smGYqQ
Links do vídeo
https://agent-skills.techleads.club/tlc-spec-driven/
https://bun.com/blog/bun-in-rust
https://github.com/tech-leads-club/nj-mmo
https://link.excalidraw.com/l/7V6DWtFSy3p/9uZyGFkKjpP
Benchmark completo de frameworks de Spec Driven Development em 2026: testei SpecKit, Superpowers, TLC Spec Driven e OpenSpec contra um modelo puro (Opus 4.8) pra descobrir qual entrega melhor código e melhores testes. 🦾 Lista de espera para o maior workshop de IA avançado do...
Benchmark completo de frameworks de Spec Driven Development em 2026: testei SpecKit, Superpowers, TLC Spec Driven e OpenSpec contra um modelo puro (Opus 4.8) pra descobrir qual entrega melhor código e melhores testes.
🦾 Lista de espera para o maior workshop de IA avançado do Brasil https://tinyurl.com/ywb7dbpz
Gastei mais de $2.000 criando uma metodologia de avaliação de harness pra sair do achismo e medir extração de requisitos, qualidade de implementação, testabilidade e custo em tokens.
💎 Lidere a transformação na era da IA venha para a Tech Leads club https://tinyurl.com/3y7jrnn6
Partes importantes
00:00 Gastei $2.000 pra acabar com o achismo
00:41 Como testei: 12 execuções e um PRD sem código
02:40 O método que removeu o "depende": LLM as judge
04:58 A nota que decidiu tudo: 60% código, 40% teste
05:07 OpenSpec: extrai bem, mas será que testa?
05:35 TLC Spec Driven: pior em requisitos, melhor em qualidade
05:54 SuperPowers: o mais usado me decepcionou no que importa
08:19 GitHub Spec Kit: detalha tudo e queima mais tokens
09:30 O ranking final: quem realmente ganhou
11:21 O plot twist: o modelo puro foi tão bom quanto os melhores
13:06 Por que o modelo puro foi tão bem (a real sobre harness)
15:13 As métricas escondidas: escopo, requisito implícito e robustez
17:09 Quanto custa cada um: a conta em tokens
17:46 Qual usar pra você: os 4 perfis na prática
18:43 Como fazer seu próprio benchmark
Referências
👉🏼 TLC Spec Driven = https://agent-skills.techleads.club/tlc-spec-driven/
👉🏼 TLC Spec Driven Eval = https://agent-skills.techleads.club/skills/spec-driven-eval/ (para utilizar instale ela e leia o quickstar.md)
👉🏼 Análise detalhada https://www.techleads.club/c/blog/spec-driven-em-2026-testei-speckit-superpowers-tlc-e-openspec-contra-um-modelo-puro-analise-completa
A Uber queimou o orçamento de IA de 2026 em 4 meses. A Microsoft cortou Claude Code interno. 71% das empresas pagam caro e não veem retorno. Mas dados contam uma história que ninguém tá falando. O problema não é a IA, é onde o dinheiro tá vazando. 💎 Participe do meu workshop...
A Uber queimou o orçamento de IA de 2026 em 4 meses. A Microsoft cortou Claude Code interno. 71% das empresas pagam caro e não veem retorno. Mas dados contam uma história que ninguém tá falando.
O problema não é a IA, é onde o dinheiro tá vazando.
💎 Participe do meu workshop de IA avançado https://tinyurl.com/2hku9a9m
Capítulos
0:00 A Uber queimou o orçamento de IA em 4 meses
1:24 O estudo Writer e os 71% sem retorno
2:13 O custo explodiu: de centenas a milhares por dev
3:21 Token mais barato, conta maior (NVIDIA: compute - dev)
4:30 9 horas por semana que somem no caminho
5:09 O diagnóstico cruel do MIT: só 5% capturam valor
6:30 Demitir não gera ROI (a bolha de verdade)
8:54 Por que é um caminho sem volta
11:41 Resumo: o que separa os 29% dos 71%
Fontes
- https://writer.com/blog/enterprise-ai-adoption-2026/
- https://fortune.com/2026/05/22/microsoft-ai-cost-problem-tokens-agents/
- https://www.infoworld.com/article/4170263/gitlab-ceo-sees-developer-tool-bill-increasing-100-fold.html
- https://fortune.com/2026/05/26/uber-coo-ai-spending-tokens-claude-code/
- https://www.mercer.com/about/newsroom/mercer-s-global-talent-trends-2026-report/
- https://fortune.com/2026/04/28/nvidia-executive-cost-of-ai-is-greater-than-cost-of-employees/
- https://www.mckinsey.com/capabilities/quantumblack/our-insights/the-state-of-ai
- https://www.theregister.com/software/2025/10/29/ai-layoffs-to-backfire-half-quietly-rehired-at-lower-pay/937713
- https://www.prismnews.com/workplace/goldman-sachs/goldman-sachs-ceo-says-ai-job-apocalypse-is-overblown
- https://hbr.org/2026/03/research-how-ai-is-changing-the-labor-market
- https://pt.wikipedia.org/wiki/Paradoxo_de_Jevons
💎 Esteja na frente na transformação da IA, venha para a Tech Leads club https://tinyurl.com/yhdt5ybs
💎 Participe do meu workshop de IA avançado https://tinyurl.com/mtmxdtjp Voltei do Vale do Silício depois de uma semana conversando com engenheiros do Cursor, Stripe, Databricks, Trae e várias outras empresas. Descobri qual é o perfil de dev que essas empresas estão...
💎 Participe do meu workshop de IA avançado https://tinyurl.com/mtmxdtjp
Voltei do Vale do Silício depois de uma semana conversando com engenheiros do Cursor, Stripe, Databricks, Trae e várias outras empresas. Descobri qual é o perfil de dev que essas empresas estão contratando em 2026, e a resposta não é o que a maioria pensa.
Não é criar agentes. Não é aprender machine learning. É algo muito mais transformador que se divide em dois perfis que estão transformando o mercado e eu vou te mostrar como estar à frente dessa transformação!
━━━━━━━━━━━━━━━━━━━━
⏱ CAPÍTULOS
00:00 Construir a coisa que constrói a coisa
00:55 40% dos usuários do Cursor não são devs
02:50 O que dev profissional virou no Vale
04:53 A alavanca que a IA amplifica
06:29 O cargo que tá emergindo
09:02 4 histórias do dia a dia
14:09 4 movimentos práticos pra começar essa semana
16:04 Onde você está nessa escala
━━━━━━━━━━━━━━━━━━━━
💎 TECH LEADS CLUB
Participe do Tech Leads club e lidere a transformação da era da IA: https://tinyurl.com/mrx4w2sv
━━━━━━━━━━━━━━━━━━━━
📚 LIVROS MENCIONADOS
Video sobre Harness Engineering https://youtu.be/dLs-Pbn8stU
The Product-Minded Software Engineer: https://www.amazon.com.br/Product-Minded-Engineer-Building-Impactful-Software/dp/1098173732
Extreme Programming Explained (Kent Beck): https://www.amazon.com.br/Extreme-Programming-Explained-Embrace-Change/dp/0321278658
Designing Data-Intensive Applications (Martin Kleppmann): https://www.amazon.com.br/Designing-Data-Intensive-Applications-Martin-Kleppmann/dp/1449373321
🎯 CANAIS E RECURSOS
ByteByteGo (system design): https://www.youtube.com/@ByteByteGo
Camadas, interfaces, use cases, mappers, padrões comuns em Clean Architecture, tudo isso tem um custo de carga cognitiva para humanos mas ainda mais para agentes de IA. E quase ninguém tá medindo. 💎 Participe do meu workshop de IA avançado https://tinyurl.com/2tjz96n3 Nesse...
Camadas, interfaces, use cases, mappers, padrões comuns em Clean Architecture, tudo isso tem um custo de carga cognitiva para humanos mas ainda mais para agentes de IA. E quase ninguém tá medindo.
💎 Participe do meu workshop de IA avançado https://tinyurl.com/2tjz96n3
Nesse vídeo:
→ Por que LLMs são enviesadas pro complexo (abstraction bloat)
→ O que o paper Navigation Paradox (2026) provou sobre o custo real da abstração
→ Encapsulamento vs Dependency Inversion
→ Por que DDD estratégico ficou mais importante, não menos
→ Regra de 3 passos pra decidir quando vale abstrair
Não é sobre acabar com Clean Architecture. É sobre uma pergunta que quase ninguém tá fazendo.
Capítulos
00:00 O caso que ninguém te contou
00:30 Por que não dobrou a produtividade
01:15 A indústria já vinha simplificando antes da IA
02:42 O paper que mediu o custo da abstração
03:31 A ferramenta que o agente ignora em 58% das vezes
03:45 Por que a IA sugere código complexo
05:01 Abstraction Illusion
05:46 YAGNI voltou com força
06:17 O que a IA não matou no DDD
07:32 Onde questionar Clean peça por peça
08:30 Encapsulamento não é Dependency Inversion
10:45 A regra: estratégico primeiro, flat depois
12:02 Três perguntas pra decidir se vale abstrair
14:02 O contra-argumento honesto
15:01 Minha posição
15:31 A pergunta pra você
💎 Esteja à frente na era da IA, venha para a Tech Leads club https://tinyurl.com/chv9uvvk
Vídeo sobre o custo de abstrações erradas https://youtu.be/-xY817_5ORY
Vídeo sobre ecanpsulamento https://youtu.be/PV7nJWMbtro
Referências
- https://addyo.substack.com/p/the-80-problem-in-agentic-coding
- https://arxiv.org/html/2602.20048v1
- https://blog.vertigrated.com/go-is-not-java
- https://super-productivity.com/blog/ai-software-architecture-guide/
A próxima fase do desenvolvimento agêntico vai precisar mais do que specs, e eu te mostro como harness engineering quer resolver isso. 🎫 Participe do meu workshop de IA avançado https://tinyurl.com/3vpbn3wy Spec Driven é só metade do caminho. A OpenAI gerou 1 milhão de linhas...
A próxima fase do desenvolvimento agêntico vai precisar mais do que specs, e eu te mostro como harness engineering quer resolver isso.
🎫 Participe do meu workshop de IA avançado https://tinyurl.com/3vpbn3wy
Spec Driven é só metade do caminho. A OpenAI gerou 1 milhão de linhas de código sem escrever nenhuma manualmente. A Anthropic fez agentes construírem apps inteiros em sessões de dias. O segredo? Harness Engineering — o conceito que transforma agentes capazes em agentes confiáveis.
📌 Capítulos:
0:00 O problema dos agentes de IA
1:07 O que é Harness Engineering
2:38 Por que agentes falham sem harness
2:58 Spec Driven já resolve isso?
3:13 Problema 1
3:40 Problema 2
5:38 Problema 3
6:24 Problema 4
8:09 Problema 5
8:53 Harness na prática
11:01 Evaluation e QA automático
12:04 O fundamento de Harness Engineering
12:21 Conclusão
💎 Esteja à frente na transformação da IA, venha para a Tech Leads club https://tinyurl.com/c8uf6h28
Aprenda Spec-Driven Development https://youtu.be/YFDp-smGYqQ
Links mostrados:
- https://openai.com/index/harness-engineering/
- https://www.anthropic.com/engineering/harness-design-long-running-apps
- https://martinfowler.com/articles/harness-engineering.html
- Skill TLC spec-driven https://agent-skills.techleads.club/skills/tlc-spec-driven/
- Get Shit Done 2 - https://github.com/gsd-build/gsd-2
A IA já escreve quase todo o código. Mas a demanda por desenvolvedor continua subindo. Como isso é possível? 💎 Participe do maior workshop avançado de IA para devs https://tinyurl.com/yakjtt64 Nesse vídeo eu explico o que está realmente acontecendo no mercado de dev em 2026....
A IA já escreve quase todo o código. Mas a demanda por desenvolvedor continua subindo. Como isso é possível?
💎 Participe do maior workshop avançado de IA para devs https://tinyurl.com/yakjtt64
Nesse vídeo eu explico o que está realmente acontecendo no mercado de dev em 2026. Conversei com dezenas de líderes tech — nacionais e internacionais — e compilei tudo aqui.
Você vai entender por que existem 3 tipos de empresa reagindo de formas completamente diferentes à IA, por que as big techs estão demitindo (e não é pelo motivo que você pensa), e qual é o perfil de dev que o mercado está buscando agora.
Se você é dev — júnior, pleno ou sênior — esse vídeo vai te dar clareza sobre onde se posicionar.
⏱ TIMESTAMPS
00:00 — O paradoxo: IA escreve o código, mas a demanda sobe
00:22 — O impacto real da IA no desenvolvimento
00:49 — Tipo 1: Empresa burocrática — por que a IA não resolveu nada
01:34 — Tipo 2: Empresa ágil — entregando mais sem demitir
02:53 — Tipo 3: Big Techs demitindo — o que está por trás
04:37 — O novo perfil do dev que o mercado quer
05:42 — Júnior, Pleno e Sênior: quem está em risco?
06:55 — Como se posicionar agora
💎 Conheça comunidade que acelera sua evolução para sênior+ na era da IA
https://tinyurl.com/2h8xyh4r
📊 FONTES CITADAS
- Pragmatic Engineer AI Tooling Survey: https://newsletter.pragmaticengineer.com/p/ai-tooling-2026
- TrueUp Vagas: https://www.trueup.io/job-trend
Nesse vídeo eu te mostro Spec-Driven Development na prática: um padrão para desenvolver com IA otimizando o contexto, reduzindo retrabalho e escalando implementações com segurança. 💎 Workshop IA Avançado https://tinyurl.com/yvwmy62w Você vai aprender como aplicar as 4 fases...
Nesse vídeo eu te mostro Spec-Driven Development na prática: um padrão para desenvolver com IA otimizando o contexto, reduzindo retrabalho e escalando implementações com segurança.
💎 Workshop IA Avançado https://tinyurl.com/yvwmy62w
Você vai aprender como aplicar as 4 fases (Specify → Design → Tasks → Execute) em qualquer coding agent — Claude Code, Cursor, Copilot, Windsurf — e ver o fluxo completo rodando num projeto real.Esse não é mais um vídeo teórico. Eu mostro na tela: a spec sendo criada, o design arquitetural, o breakdown de tasks com paralelização, subagents executando em paralelo, e o STATE.md garantindo memória entre sessões.
💎Participe da comunidade que acelera sua evolução para sênior+ na era da IA
https://tinyurl.com/ysevhb5e
⏱️ Timestamps:
0:00 — O problema que ninguém fala sobre coding agents
0:32 — O que separa resultado medíocre de sistema funcional
1:30 — O que as pessoas fazem errado com IA
2:08 — Context Engineering: como funciona a janela de contexto
3:10 — RPI: Research, Plan, Implement
4:20 — Como Spec-Driven Development funciona (as 4 fases)
5:28 — A skill TLC Spec-Driven na prática
5:50 — Fase 1: Specify (obrigatória)
6:37 — Fase 2: Design (opcional)
7:21 — Fase 3: Tasks — breakdown com paralelização
8:01 — O que uma task precisa ter
9:20 — Subagents em paralelo na implementação
9:54 — STATE.md: memória persistente entre sessões
10:40 — Como usar na prática (demonstração real)
11:44 — Como instalar e começar agora
12:04 — Flexibilidade: nem sempre precisa de tudo
Skill tlc-spec-driven disponível aqui https://agent-skills.techleads.club/
Nesse vídeo eu mostro as 5 skills de IA que mais uso no meu workflow como dev — e todas estão disponíveis de graça. 💎 Participe do nosso workshop de IA Avançado https://tinyurl.com/yc56h6nc São skills reais, que uso em projetos grandes todo dia. Cada uma resolve um problema...
Nesse vídeo eu mostro as 5 skills de IA que mais uso no meu workflow como dev — e todas estão disponíveis de graça.
💎 Participe do nosso workshop de IA Avançado https://tinyurl.com/yc56h6nc
São skills reais, que uso em projetos grandes todo dia. Cada uma resolve um problema específico: desde documentação técnica até análise de código legado e execução paralela com agentes.
Os nomes das skills estão nos comentários para quem assistir ao vídeo até o final.
Timestamps
00:00 — Introdução e o que são skills
00:47 — Skill 5: Design Doc Creator
02:16 — Skill 4: Resolver Comentários do GitHub
02:49 — Skill 3: Análise de Acoplamento
03:57 — Convite Especial
04:31 — Skill 2: Análise de Domínio
05:39 — Skill 1: TLC Spec Driven
07:08 — Skill marketplace
💎 Participe da comunidade que acelera sua evolução para sênior+ na era da IA https://tinyurl.com/e243nuax
Nomes da skills mostradas pra você pegar no nosso marketplace (https://agent-skills.techleads.club/ )que mostrei:
- tlc-spec-driven
- coupling-analysis
- technical-design-doc-creator
- domain-analysis
- gh-address-comments
Um paper testou AGENTS.md e CLAUDE.md em projetos reais com IA, e os resultados são mais complexos do que o pessoal tá divulgando. Antes de deletar esses arquivos do seu repositório, assista a esse vídeo. 💎 Lidere a transformação da IA, venha para a Tech Leads club...
Um paper testou AGENTS.md e CLAUDE.md em projetos reais com IA, e os resultados são mais complexos do que o pessoal tá divulgando. Antes de deletar esses arquivos do seu repositório, assista a esse vídeo.
💎 Lidere a transformação da IA, venha para a Tech Leads club https://tinyurl.com/3h88a742
📄 Link do paper https://arxiv.org/pdf/2602.11988
Capitulos
00:00 – O paper que está gerando polêmica
00:41 – Os 3 cenários testados (humano, IA e sem contexto)
01:24 – Os resultados reais de taxa de sucesso
02:04 – Por que o agente fica mais lento e mais caro
02:24 – O que o paper não avaliou (e é crítico)
03:27 – Como o agente alucina sem instrução clara
03:47 – O erro mais comum: contexto desnecessário
04:07 – Como estruturar seus arquivos do jeito certo
Neste video você vai aprender a usar agentes de IA para refatorar sistemas inteiros, não arquivo por arquivo, mas em paralelo, com contexto otimizado e planos que um modelo barato consegue executar. 💎 Venha para a comunidade que acelera sua evolução para sênior+ na era da IA...
Neste video você vai aprender a usar agentes de IA para refatorar sistemas inteiros, não arquivo por arquivo, mas em paralelo, com contexto otimizado e planos que um modelo barato consegue executar.
💎 Venha para a comunidade que acelera sua evolução para sênior+ na era da IA
https://tinyurl.com/36nat5pc
O fluxo que eu mostro aqui é o mesmo que uso em consultorias para modernizar sistemas legados. Começa num code smell simples, escala para análise de domínio completa e termina nos novos times de agentes autônomos que o Claude Code está introduzindo.
Se você trabalha com código legado, monolitos ou simplesmente quer multiplicar sua produtividade com IA, essa aula é pra você.
⏱️ TIMESTAMPS
00:00 - Intro e overview da aula
00:58 - Code smell identificado: ORM vazando para a camada de domínio
02:13 - Modo ASK: conversando com a IA antes de implementar
03:26 - Pedindo um plano de refatoração para a IA
05:38 - Transformando o caso em uma skill reutilizável
06:25 - Docs de especificação: qual o tamanho ideal?
08:33 - Escalando para todo o code base com sub-agentes em paralelo
10:07 - Resultado: janela de contexto em 13%, pesquisa completa
12:57 - O fluxo 80/20 para refatorar sistemas
15:42 - Skill de análise de domínio para decompor monolitos
17:02 - Como era feito na mão em consultorias (e por que é sofrido)
19:04 - Skill de análise de domínio baseada em DDD
22:02 - Usando o output da pesquisa para criar tasks
24:11 - Spec Driven + paralelização de tasks
30:06 - De uma grande pesquisa para tasks acionáveis
32:26 - Work trees do Git para paralelizar implementações
33:31 - O próximo nível: agentes autônomos
35:29 - Times de agentes vs sub-agentes: a diferença crucial
37:41 - Times de agentes no Claude Code: Foundation Engineer, Migration Specialist...
39:09 - O nível de autonomia é absurdo — mas exige boa instrumentação
40:06 - Conclusão: o caminho para chegar nos times de agentes
🔗 RECURSOS MENCIONADOS
→ Repositório de Skills da comunidade https://agent-skills.techleads.club/
→ Livro: Aprendendo Domain-Driven Design
→ Livro: Fundamentos de Arquitetura de Software: As Partes Difíceis
