YT YouTube2Text

YouTube2Text → Transcripts → App do Zero com IA: Harness, Sub Agents, Spec-Driven, Novas Skills e Workflows

App do Zero com IA: Harness, Sub Agents, Spec-Driven, Novas Skills e Workflows — Transcript

by Waldemar Neto - Dev Lab · 15,172 words · 2,097 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00Não importa se tu já desenvolve com IA
0:01ou se tu é iniciante com IA. Na era da
0:03IA a gente tem que estar sempre
0:04atualizado. As coisas mudam rápido. A
0:06cada 3 meses tudo muda. E é por isso que
0:08eu tô disponibilizando uma hora de
0:09vídeo, que é uma parte do workshop meu
0:11de início ao fim, que a gente vai criar
0:13uma app do zero usando o IA e colocando
0:16os conceitos para ver onde eles se
0:18encaixam. Se a gente começa do zero, a
0:20gente vê plan mode, a gente vê sub
0:22agents, a gente vê verificação, a gente
0:23vê harness, a gente chega em spec
0:26driven, a gente fala dos limites do spec
0:27driven pros modelos atuais e a gente
0:29termina com o workflow mais efetivo
0:32possível pros modelos atuais e os
0:35modelos da próxima geração. Ou seja, em
0:37uma hora tu vai te atualizar em tudo e
0:39vai mudar a maneira como que tu
0:40desenvolve software. E também eu vou te
0:41deixar um monte de skills, as minhas
0:43skills mais novas, toda a minha
0:45pesquisa, tudo para ti melhorar o teu
0:47desenvolvimento com IA. Então, a gente
0:48vai ver hardness, Speck Driven, o que
0:50que vem depois do Spect Driven, várias
0:52skills minhas, tudo disponibilizado para
0:54te melhorar o teu workflow. E a única
0:55coisa que eu te peço é dá like, comenta,
0:57compartilha esse vídeo porque me ajuda
0:59bastante, me ajuda bastante a trazer
1:01mais conteúdo de qualidade e também
1:03ajudar toda a comunidade do Brasil.
1:05Então, eh, eu tenho uma app full stack
1:07aqui bem bem simples, acabei de começar
1:09ela, tá? Então, é, tem só um app, um
1:12API, que é o back end, backend ban. Ó,
1:15tem um service, item service e um web,
1:19que é uma aplicação web white com React,
1:22bem simples pra gente vocês irem
1:24acompanhando o que eu tô fazendo, tá?
1:26Muita gente pediu nos outros: "Ah, eu
1:27quero que vão fazendo do zero." Então, a
1:28gente vai fazendo do zero, a gente vai
1:29entendendo aqui as coisas juntos. Eh,
1:32beleza? Então, eu vou começar aqui que é
1:34o seguinte, essa app, o que que última
1:36empresa que eu trabalhei era um RP nos
1:38Estados Unidos. RP é um domínio
1:39complexo, né? Então, era e tem controle
1:42de estoque, esse monte de coisa. A gente
1:43vai trabalhar mais ou menos nisso.
1:45Primeira coisa que eu vou fazer aqui é ã
1:47vou dar um prompt que é o seguinte. E
1:49aqui eu tô eu tô usando, eu tô usando o
1:51cursor, tá? Na ver eu tô usando o agents
1:54window, uso mais essa janela aqui. Vocês
1:55vem que inverteu code base fica em
1:57segundo plano, o código fica em primeiro
1:59plano. Aqui eu tô na minha janela de
2:01agente, eu tô usando o Grock e eu vou
2:03usar o 4.6 Fast por como é um como é um
2:07um workshop, eu quero que a coisa vá
2:09rápido, tá? Então eu vou usar o Fest
2:11aqui. Ele ainda assim no Fest ele é mais
2:12barato que um Opus. Então vale muito a
2:14pena. Primeira coisa que eu vou dizer
2:15aqui é pesquisa quais módulos são
2:17necessários para termos um RP completo
2:20funcional com controle de estoque eh
2:23warehouses, obras, alocamento de STF,
2:25administrador e operador. Isso aqui não
2:27é uma coisa que vocês vão fazer no dia a
2:28dia, tá gente? Só que eu tô fazendo isso
2:30para quê? pra gente ter um arquivo de
2:32roadmap, que é o que a gente vai
2:33trabalhar nele. E aí cada ciclo do
2:35roadmap a gente vai usar alguma técnica
2:37diferente. Eh, Adam, olha, se tu
2:38precisar falar alguma coisa, eu não vou
2:40ver o chat por um tempo, tá? Tu pode me
2:42interromper. Aqui não tem nada de
2:43especial, tá gente? Cunhar, é só um
2:45start mesmo, só para vocês ir
2:47acompanhando comigo o que que tá
2:48acontecendo. Então ele vai fazer uma
2:49busca na internet sobre e coisas
2:52similares e a gente vai criar um
2:54roadmap. Enquanto isso, o que que eu
2:55tenho nesse repositório, tá? Eu tenho
2:57agents.m. Que que é o agents.m? É uma, a
3:00gente chama de rules, são coisas que
3:02sempre carregam na janela de contexto.
3:03Se eu descer aqui na janela de contexto,
3:05ó, tá o que tá na minha janela de
3:06contexto aqui. Lembra que a gente paga
3:08tokens por é loops na janela de
3:10contexto. Cada vez que manda pro modelo
3:12e volta, eu tô pagando por isso. Então
3:13aqui eu tenho meu system prompt, o
3:16system prompt que é do cursor, as tos
3:18que é tipo ah, read file, é chamar o MCP
3:22a um ato MCP, esse tipo de coisa. rules
3:25e ponm aqui as skills. É, então aqui me
3:28deu, ó, módulos necessários identity,
3:31autorização, identificação, catalogue,
3:33warehouse, inventory, job, staff,
3:35assignment, procuramente. OK. OK. Crie
3:37ummap oldmap.md.
3:40Ah, então vou criar aqui. Então, tava
3:42explicando agents.md. É, a gente fez uma
3:44live sobre isso. Quem não assistiu
3:45aquela live e tem dúvida sobre o que que
3:47é um agentesm, como como criar um.Md,
3:50bom, assista a live. Mas em resumo, o
3:52que que ele é? Eles são regras, coisas
3:54que eu quero que sempre o agente
3:55carregue. Aqui eu vou botar, gente, o
3:57mínimo de coisa possível, tá? Só coisas
3:59que o modelo não vai entender sozinho.
4:01Como eu falei, os modelos evoluíram
4:03bastante. Essa última versão de modelos,
4:05além de ser muito inteligente, eles são
4:06muito bons em usar tools. Ou seja, eles
4:08são muito bons em tipo buscar skill para
4:10usar, é saber chamar o MCP. Eles são
4:14muito inteligentes. Então eu não preciso
4:15botar tanta coisa no agent.md. Que que
4:17eu botei só aqui? Principalmente coisas
4:19que ele não saberia. como que é feito o
4:21dependência injection nesse repositório.
4:23Isso depois de eu ter bastante código
4:25feito sempre do mesmo jeito, eu posso
4:26remover porque o código é o melhor
4:28exemplo, tá? E a minha estratégia de
4:30teste, ah, eu digo que service tem que
4:31ser, tem que sempre ter unidade porque
4:33tem lógica de domínio. Rota e banco, tu
4:36testa indiretamente com teste de
4:38integração. Só o repositório não não
4:40prova nada, ele só testa com o teste end
4:43to end, tá? e web eu não tenho testes,
4:45eu vou explicar depois sobre isso. Então
4:47essa é a o básico que eu preciso para
4:50começar a trabalhar nesse repositório
4:51aqui. Agora eu vou botar mais uma coisa,
4:53tá gente? Mais uma coisa que é
4:55importante. Eu quero que sempre que eu
4:58implemente algo que toque no front end,
5:01ã, eu quero que o próprio agente teste
5:04aquela coisa para ver se deu certo, tá?
5:05Então vou dizer o seguinte. Hã, coloque
5:08uma regra no agents.m para sempre
5:12validar uma implementação. Validar no
5:16final da implementação usando playw
5:20quando toca em telas. Que que eu tô
5:22dizendo aqui? Eu tô dizendo para ele
5:24usar o meu playght. É, quem não sabe o
5:26que que é o playght, eu vou mostrar para
5:28você. Aqui em e customize, eu tenho meus
5:31MCPs. Um deles que eu tenho é o
5:33Playwright. Playwright é bem famoso,
5:35tipo Cypress. Ele é bem famoso com
5:37automação de teste no front end, end to
5:39end, tá? A pessoa entra, navega e clica
5:41em tudo. O MCP, ele me, basicamente me
5:44permite fazer essas, permite o agente
5:46fazer essas coisas. Ele tem várias tools
5:47que ele pode usar encontrar um browser,
5:49cadê abrir o browser, clicar nas coisas
5:52e tal. Então eu basicamente dou pro
5:54agente isso fazer e digo: "Olha, cara,
5:57tu vai ter que provar o teu trabalho
5:59fazendo isso, tá?" Ó, tá aqui, tal,
6:01tarará. E aí ele botou uma regra aqui.
6:03Então quer dizer que todo o agente que
6:05eu abrir, toda a janela de agente que eu
6:06abrir, vai saber disso aqui e vai fazer.
6:08Espero que ele faça, tá? Então a gente
6:10tem o que agora? A gente tem um roadmap
6:12que a gente vai seguir. Isso aqui eu só
6:13de novo, eu só fiz isso para eu não
6:15precisar estar pensando na próxima
6:17coisa. Tem o roadmap e eu vou botar mais
6:19uma coisa aqui, ã, que é seguinte, para
6:22[limpando a garganta] ver ver se para
6:23vocês, eu quero que vocês vão entendendo
6:25como que a coisa funciona com IA, tá?
6:27Tem muita coisa que vocês vão ter que ir
6:28dizendo basicamente. Então, hold
6:32em H aqui. Every time a road map item is
6:39completed. Mark it as done in the road
6:45map. Então, só botei isso aqui que é o
6:46seguinte, sempre que eu implementar
6:48alguma coisa no roadmap, ele vai lá e
6:49marca aquele road map como dano, tá? Só
6:51pra gente saber onde a gente tá
6:53progredindo. Então vamos começar.
6:54Primeira coisa, qual é? Qual o próximo
6:57item? Item do roadmap. Vamos ver qual
7:00que é o meu próximo item do meu roadmap
7:02aqui. Ah, que é o warehouse stock, eu
7:05acho, porque eu só tenho tenho só um
7:06item no momento. Warehouse stock.
7:08Beleza? Então, vamos lá. A maneira mais
7:10fácil de implementar é qual? É, OK,
7:12implemente isso. Implo. Eu vou fazer do
7:14jeito mais básico que a gente vai
7:15entender o quais são as limitações
7:17disso. Por quê? Porque a gente tá com
7:18momento que as pessoas têm muita dúvida,
7:20né? Principalmente, ah, spec driven é
7:21waterfall, eh, não sei quê. Tipo, todas
7:25essas coisas a gente tem que entender a
7:26nível fundamental e a gente vai
7:28entendendo a nível fundamental aqui para
7:29vocês conseguirem entender e ter as
7:31respostas para essas coisas. Ah, o que
7:32que é loop engener? O que que é graphic
7:34engineer? Todo esse tipo de coisa. A
7:35gente vai chegar lá quando a necessidade
7:37aparecer. Então, eh, eu dei um prompt
7:39para construir, tá? Ou a gente vai
7:41buscar os arquivos que eu vou
7:42explicando. Eu tô usando um reason em
7:44high aqui, tá vendo? E high. Que que
7:46isso quer dizer? Quer dizer que ele vai
7:47pensar mais. Se eu clicar aqui e olhar,
7:49ele me mostra os arquivos que ele leu e
7:51tudo que ele tá pensando. Então ele fica
7:52num loop de pensamento, gasta mais
7:54tokens, mas é importante quando ele tem
7:56que pensar bastante, principalmente fase
7:57de planejamento que a gente vai entrar
7:59depois, tá? É bem importante. Eu gosto
8:01de usar eh nas fases de planejar, eu uso
8:05bastante reasoning high. para
8:07implementar, normalmente eu uso medium,
8:09[limpando a garganta] mas hoje em dia
8:10com o Grock que eu tô usando aqui, ó,
8:12antes eu usava um modelo bom para
8:13planejar, o modelo mais ou menos para
8:14implementar, tipo, ah, opos para
8:16planejar, eh, son para implementar. Hoje
8:18em dia o groque tudo, tipo, é barato,
8:21barato comparado com os outros, é
8:22rápido, é bom, cara, toca aí, faz o que
8:24tu quiser. Mas às vezes eu uso tá às
8:27vezes eu uso opos quando eu preciso de
8:29pensar muito em coisas.
8:31Acho o reasoning é do Opus melhor, as as
8:35conclusões dele melhor, mas realmente
8:37ele é bem mais caro. E no cursor eu
8:39tenho o Grock dentro do meu plano também
8:41que me ajuda bastante. Então, ó, ele fez
8:43uma pesquisa dos arquivos e tá começando
8:44a alterar, tá? Foi lá, vou alterar tudo
8:46que ele tem para alterar. Ele também vai
8:49botar aqui no no meu context. MD que eu
8:52não mostrei para vocês, mas é um
8:53arquivo, eu gosto bastante de ter isso,
8:54tá gente? Inclusive, tem uma skill que
8:56eu vou deixar para vocês depois que é do
8:58context context map. Basicamente os
9:00itens de domínio, cada coisa nova que eu
9:02boto no meu domínio, ele bota nesse
9:03arquivo. Ah, o que que é um item? Que
9:05que é um catálogo? Que que é um uma
9:07unit? Que que é uma warehouse? Que que é
9:09um estoque? Porque assim, eh, o a gente
9:12não precisa pensar de novo o que que é
9:13essa coisa, sabe? Ah, o que que é um que
9:14que é uma warehouse? É onde os itens, as
9:17quantidades vivem, tá? E o que que ela
9:19não é aqui? Ela não, o que que eu não
9:21quero ter? Eu não quero ter estoque num
9:22catálogo, por exemplo. Stock tem que
9:24estar na warehouse. Então, são regras da
9:26minha arquitetura que são bem
9:27importantes ter também. Eu gosto
9:29bastante disso. Então ele vai
9:30implementar essa parte aqui, ó. Já tá
9:32implementando um teste e tal e vai
9:33atualizar o roadmap. Vamos ver. Cadê?
9:35Ele vai atualizar aqui agora, ó. Dane
9:37catálogo. Deve chegar nesse cara aqui
9:39depois. Aí assim vocês viram que que que
9:42eu que eu fiz para isso aqui acontecer.
9:44Eu basicamente escrevi aqui. Então qual
9:46que é a ideia de vocês? Primeira coisa
9:47que vocês tiram daqui. Os modelos estão
9:50cada vez melhores e mais confiáveis.
9:52muitas das coisas eles vão seguir. E a
9:54ideia é assim, provavelmente no nosso
9:56workshop do início do ano que vem eu vou
9:58est dizendo para vocês, cara, quase não
10:00usem skills, porque vai ter técnicas que
10:02a gente vai usar pro modelo seguir as
10:04coisas. Eh, muito bem. Hoje em dia a
10:06gente tem que usar, ainda vou explicar
10:07para vocês depois, mas eh só de eu botar
10:10isso aqui, screens e o roadmap, ele já
10:12atualizou o roadmap aqui para mim, ó, a
10:14warehouse tá done, tal. Então eu não
10:17preciso me preocupar muito em nessas
10:19coisas. Eu vou botando essas regras
10:20naquele arquivo ali. Ah, agora ele vai
10:23ah fazer um teste e tal. E isso. Beleza.
10:26Outra coisa que eu vou dar uma olhada
10:28aqui, deixa eu ver. Vou atualizar. Ó,
10:30agora ele vai subir a API web. Quero
10:33deixar ele abrir aqui para vocês verem,
10:34ó. Abriu o web. E assim tá feião meu
10:36site ainda, gente. Tá feião. A gente vai
10:38arrumar isso aqui tudo junto, tá? Mas
10:39olha ali, entrou, testou. Então, outra
10:42coisa muito importante, principalmente
10:44para quem trabalha com front end, tá? O
10:46IA, sem ela ver a coisa, é quase
10:49impossível ficar bom ou tu conseguir
10:52validar que fica bom. Eh, modelos são
10:54muito bons com imagens, muito bons com
10:56imagens, mas muito ruins em interpretar
10:58algo visual sem ter aquela imagem. Eh,
11:01se tuud um componente frontend, quem é
11:03frontange deve saber disso aí, manda no
11:04chat. Tu manda um, sei lá, uma coisa do
11:07Figma, uma parada assim, tu acha, ah,
11:08vai ficar pixel perfect, não fica, tá
11:10ligado? Aí tu manda uma imagem, ele
11:11consegue chegar próximo daquilo ali.
11:13Então é playw, pô, para quem trabalha
11:16com front end. Mas agora vem outro, vem
11:18um problema assim, pô, mas aí eu crio
11:20testes com playw, comito esses testes,
11:23cara. Aí é outra conversa. Eu sugiro
11:25daqui a pouco ter testes para os raps,
11:28alguns deles, mas manter teste end to
11:31end caro, é lento, é desafiador. Então
11:34é, eu sugiro tomar cuidado com essa
11:36parte, mas usar para validar é bem
11:38importante, tá? Porque eu venho aqui,
11:39ele entrou e testou tudo que ele fez,
11:41ele vai me dizer lá depois que beleza,
11:42deu certo. Então isso eu uso bastante,
11:44tá? Ah, gasta tokens, gasta um pouco
11:46mais de token, obviamente, mas evita
11:48retrabalho, né? Se eu tivesse que entrar
11:50eu, humano, testar tudo e deixar as
11:51coisas passar, é, ia gastar o meu tempo
11:54também. Aí vai de quando vocês estão
11:56disponíveis, é, a para gastar. Então, ó,
11:59ele vai terminar de testar aqui.
12:00>> Acho se puder fazer um recap rápido
12:03assim de o que que tu fez até agora, que
12:05tu tá focando basicamente em estressar a
12:08capacidade do modelo usando poucas
12:11coisas como guia ali, né? Porque tem
12:13gente perguntando quais skills tá usando
12:14e tal, tudo mais. Se puder dar uma
12:16repassada sobre isso.
12:17>> Boa, gente. Eu não tô usando skill
12:18nenhuma aqui, tá? Eu tô usando o básico
12:20do básico. Eu dei, é, a gente começou
12:22pelo básico do básico. Eu dei um
12:24promptir
12:26warehouses stock, tá? E a única coisa
12:28que eu dei a mais foi instruções do meu
12:31agents. MD nas regras. Dizer: "Olha,
12:32tudo que tu tudo sempre que tu tocar uma
12:35um screen, tu tem que testar com playw,
12:37abrir, fazer isso aqui que eu mostrei.
12:39Vai lá, testa as telas com playrht e a
12:41gente tem o roadmap do que a gente vai
12:42fazer que tá atualizado. Beleza? Eu dei
12:44um prompt aqui, digo, ó, disse constrói.
12:46Agora eu construí isso daqui, tá? Pode
12:48dei um prompt e construí. Qual que é o
12:50problema agora? Qual que é o problema
12:51que eu tenho agora na minha mão? Tipo,
12:53vamos ver aqui. Vou abrir o chat, mano.
12:55E qual que é o problema desse desses que
12:56eu fiz? Code review, arquitetura, vibe
12:59code regressão. Exato. Gente, eu não
13:01sei, eu não sabia o que ia ser feito. E
13:03eu agora para para validar a resposta,
13:06tá? Eh, pô, como que eu valido que isso
13:08aqui ficou bom? Eu vou ter que ir
13:09mudança por mudança olhando. E como que
13:12eu sei que ele testou que tinha que
13:13testar? Como que eu sei que todas as
13:15regras de negócio eh foram
13:18implementadas? Cara, eu não sei. Sabe?
13:20Aqui, como não é uma mudança grande, eu
13:23imagino que foi feito praticamente tudo.
13:24Mas vocês não vão fazer isso em
13:25produção, tá? Eu vou comentar isso
13:27daqui. Ah, só um minuto. Então, pô, em
13:29produção vocês não vão fazer isso aqui,
13:30né, gente? Ah, então o que que é a
13:32primeira coisa que a gente vai fazer,
13:33pô? Então, eh, o que que a gente pode
13:36fazer aqui? A gente pode usar um plano
13:38mode, por exemplo, beleza? Eh, planeje o
13:42próximo, que é esse daqui, ó, próximo
13:44item do roadmap. Qual que que que a
13:46gente vai ter agora de diferente? Pô, a
13:48gente e assim, eu tô falando aqui,
13:50gente, para quem escreve código em
13:52produção, tu vai ter que saber o código
13:54que vai entrar e tu vai ter que ler o
13:55código no final para ver se ele foi na
13:56direção certa. a gente vai ver como a
13:58gente vai minimizar isso ao máximo, mas
13:59tu vai ter que fazer isso por um bom
14:00tempo ainda. Quem diz: "Ah, não lei",
14:02não leio o código comprovadamente não é
14:05possível com código em produção de
14:07verdade. Vou deixar referências para
14:08vocês, mas tem um cara que, cara, o cara
14:10que cunhou com o o termo context
14:12engineering e tal, ele eh tentou fazer
14:16isso por 4 meses, chegou um ponto que
14:17ele não conseguiu nem refaturar o código
14:19mais. Ele teve teve que refazer toda a
14:21aplicação porque ele não leu o código,
14:22tá? Então ele ele é um cara que fala que
14:24sim, a gente vai ter que ler por um bom
14:25tempo. Mas pô, agora eu fiz diferente,
14:27né? Eu dig eu disse: "Olha, planejo
14:29usando plan mode". Eu vou explicar o
14:31próximo item do roadmap. Então que que
14:33que ele fez aqui? Ele abriu é sub agents
14:36para explorar. Que que são sub agents,
14:38gente? Só para relembrar, subagents é
14:40pensa que como se fosse uma trader
14:44é muito importante isso. Para não poluir
14:46a janela de contexto. Daqui ele abriu,
14:48ele explorou as duas coisas. Quais são
14:50os padrões da API? Ah, os padrões, quais
14:53[limpando a garganta] são como que
14:54funciona o web? Explorou os dois, trouxe
14:56só uma resposta pro agente principal,
14:58tá? E assim o agente principal consegue
15:01tomar uma decisão. Eu não precisei fazer
15:03nada para isso, tá? As ferramentas
15:05novas, cursor, cloud code e tal e e os
15:07modelos inclusive são inteligentes e
15:09saber, olha, isso aqui é, eu tenho que
15:11fazer uma varredura no code base. Eu não
15:13vou fazer isso na minha janela de
15:14contexto principal porque ela é
15:15limitada. O Grock ele nem tem janela de
15:171 milhão. A janela máxima dele é 250.000
15:19tokens. Então não vou encher essa janela
15:21aqui. Vamos ver. Ã, fase dois é user
15:23roll. Blá blá. O que entra nesse slide?
15:26A roll fica como campo user, não como
15:28uma tabela própria. Só cadastro.
15:30Cadastro mais login. Vamos botar aqui
15:33cadastro, cadastro mais login. Show.
15:35Isso aí. Isso que ele vai fazer. Essa
15:37pergunta que veio também é o próprio
15:39modelo usando uma tool de pergunta
15:41porque não ficou bem claro. Então o plan
15:43mode vem da própria ferramenta. Dentro
15:46dele ele é como se fosse uma skill, tá?
15:47Tem algumas instruções de como fazer as
15:49coisas. E aí ele me manda isso aqui para
15:51deixar mais claro como as coisas têm que
15:53ser feitas, tá? Então essa essa aqui é
15:55basicamente a ideia do plan mode. E o
15:57que que vai acontecer agora? Agora eu
15:59vou conseguir ter uma das primeiras
16:01coisas que são úteis que eu conseguir
16:03ver o que vai acontecer. Ó, você fechou
16:05o escopo, ele vai passar pelas coisas e
16:06vai escrever um plano pra gente. O
16:08cursor e o cloud code já abrem o
16:10browser. Por que usar o playwite? Porque
16:12o playwite não depende da ferramenta que
16:13tu vai usar, né? Tá num time onde todo
16:15mundo usa o cursor, por exemplo, e tu
16:17testou o browser e funcionou bem. Eh,
16:19pô, pode usar ele, mas eu tenho uma
16:21experiência muito boa com o Playght e
16:24ele basicamente tem o MCP, funciona em
16:26qualquer lugar. Então eu eu deixo ali
16:29minha dica de playeroid para mim ainda é
16:30muito útil. Então, tá, agora a gente tem
16:32um plano. Pô, o plano já me permite
16:34revisar o que que vai ser feito. O plano
16:36pegou a linguagem, ele me explicou aqui
16:39o domínio, o que que vai ser feito, ele
16:41mostrou as rotas que vão entrar também e
16:44o que que vai ser alterado. Ah,
16:46[limpando a garganta] o shape da API, os
16:48testes que vão ser feitos. Então, eh,
16:51ter um plano, uma spec, não é, não é,
16:54eh, waterfall, né, a galera tá falando,
16:57porque é basicamente tu pegar um bloco
16:59de trabalho e tu usar o agente paraar
17:02nesse bloco antes de tu escrever código.
17:04Assim, lembra da primeira implementação
17:05que a gente fez? Tu corrigir aquilo lá é
17:07muito mais difícil, porque tu não sabe
17:08exatamente o que que ia ser feito e tu
17:10não sabe exatamente o que que tu pediu.
17:12Então, tu vai ter que ficar lupando com
17:13a gente até corrigir e gastando tokens.
17:15Então é muito melhor tu lupar com o
17:17agente numa especificação, porque
17:19basicamente é como se tivesse
17:20implementando a coisa sem implementar do
17:22que tu lupar um agente num código já
17:24feito, tá? Então o plan mode ajuda isso
17:26aí. Todas as ferramentas têm plan mode
17:28por padrão, tá? E aqui, ó, beleza? Tem
17:30algumas coisas que eu vou revisar, então
17:32eu não vou revisar no detalhe aqui, até
17:33por isso que é um código de teste, mas
17:35na vida real eu dou uma boa passada. Mas
17:37assim, vocês vão ver quando eu fizer o
17:38nosso código de verdade de produção, um
17:40código que já tá bem estruturado, que já
17:43tem eh um bom harness que eu vou
17:44explicar. Normalmente as coisas saem com
17:46modelo bom num numa situação, num
17:49detalhe bem bom, mas claro, se é um
17:50código legado que tu ainda tá adotando
17:52IA nele, tu vai ter que a cada vez que
17:54tu planeja ver o que que ficou pendente,
17:56o que que ele errou, arrumar e também
17:59arrumar no teu MD ou skill para ele não
18:01errar mais. É um processo de longo
18:03prazo, tá? Mas aqui a gente tem a
18:04primeira coisa, beleza? Pô, fiz isso
18:06aqui. Aqui, olha, eh, pensa o seguinte,
18:09esse agente aqui, primeira outra coisa
18:11que a gente vai ver agora, esse agente
18:12aqui pensou em um monte de coisa para
18:14poder planejar isso. E aqui tem um
18:16resumo do que do que que tem ser feito.
18:18Na vida real, provavelmente essa janela
18:20de contexto ia est lá pelos 60, 70% já.
18:23Não tem por eu construir nessa janela e
18:25fazer ela ser compactada. Eu vou
18:27explicar sobre isso. É muito mais fácil
18:28eu pegar esse plano aqui, ó. Vou pegar
18:30esse plano aqui e vou dizer o seguinte:
18:32pô, constrói isso aqui em outro agente
18:35com uma janela de contexto zerada.
18:36Então, basicamente, em um agente eu fiz
18:38uma busca e no outro eu vou construir a
18:41coisa ali com uma janela de contexto
18:43zerada. E por que que isso é importante,
18:44gente? Deixa eu, enquanto ele constrói
18:46agora, eu vou voltar aqui. Por que que
18:48isso é importante? Por a gente tem hoje
18:51janela de contexto até maiores, tá? A
18:53gente tem janela de contexto de 300.000
18:55tokens para quem usa é Opos, duas, dois
18:58níveis, né? Normalmente é um que é o
18:59safe, que é assim, olha, dentro dessa
19:01janela, nós antropic, open AI dizemos
19:05que é seguro tu trabalhar. Quando vai
19:07para 1 milhão é tua responsabilidade. E
19:09tem dados comprovados que quanto maior a
19:12janela de contexto, mais a qualidade
19:14cai, tá? Então eu tenho, não sei se,
19:16deixa eu ver se eu acho, é aqui a
19:17comparação do GPT em um em um paper
19:19científico. Quanto maior a janela de
19:21contexto, tá vendo? Cada, basicamente
19:22cada 100.000 tokens a mais, mais a
19:24qualidade cai. Então vocês têm que
19:27cuidar a janela de contexto para manter
19:28a qualidade do output boa. E a gente
19:30gosta de falar que, pô, cara, em torno
19:32de 40% tá safe da janela. Tá 60%, cara,
19:34dá para ir tranquilo. Acima de 60% tu
19:37vai começar a pagar um pouco com a
19:39qualidade. Ah, mas é extremamente
19:41preocupante. Depende do contexto, né?
19:43Depende do contexto em dois sentidos,
19:46né? defe do contexto, amor. É, se tu
19:48tem, por exemplo, um plano, um plano e
19:51depois tu tem uma maneira de checar
19:52aquele plano, pode ser que perder
19:54informação no meio, não importe, porque
19:56o agente sempre tem para onde voltar.
19:57Mas se tu dá um prompt frio para um
19:59agente e tu, o teu único contexto é a
20:01janela de contexto, aí a qualidade
20:03começa a cair. E se ele compacta, aí
20:06piora, porque compactar faz o quê?
20:08Resume tudo que tá na janela de contexto
20:09e reinjeta as as regras de volta. Então,
20:12tu perde tudo que tu conversou. Então,
20:14quando que deixar jela de contexto
20:16encher é tranquilo ou quando que
20:19compactar é tranquilo? Quando eu sei que
20:21as minhas regras tão em uma spec ou num
20:24plano ou e também eu tenho uma maneira
20:25de checar, tá? E assim, tranquilo até
20:28ali, porque o agente vai tomar decisões
20:31daqui a pouco que ele já tomou ou
20:32decisões diferentes porque ele compactou
20:34a janela e perdeu aquele resumo. Tem um
20:36paper que eu vou deixar para vocês que
20:37mostra assim que ele joga tudo fora, tá?
20:40Ele não ele não escolhe. Tá, isso aqui é
20:42uma coisa importante, isso aqui não é
20:43uma coisa importante, não. Ele compacta
20:44tudo e só reinjeta as coisas de volta,
20:46tipo pmmd e as skills. Então é bem
20:49perigoso. Eu tento manter mais ou menos
20:51nesse tamanho ali de uns 60%. E outra
20:53coisa importante para para lembrar é que
20:55LLMs elas são stateless, tá? Elas não
20:57sabem ter o code base, elas não sabem
20:58nada. A cada prompt, ou na verdade, a
21:01cada loop que o agente dá aqui, cada
21:03chamada de modelo, ele manda tudo que tá
21:05nessa janela aqui para para pro modelo.
21:09O modelo faz eh uma análise, ó, qual que
21:11é a próxima coisa aqui, manda de volta.
21:13Então é, gente, é por isso que a janela
21:15vai enchendo, tá? Ah, tá. Mas se usar
21:17uma janela de 1 milhão de tokens, como a
21:19gente falou, vai perdendo a qualidade.
21:21Quando que eu uso uma janela de 1 milhão
21:22de tokens? Quando eu tô fazendo uma fase
21:24de research, ó. Então, pensa assim, o
21:26loop de trabalho de vocês vai ser o quê?
21:28pesquisar algo, usar o agente para
21:30ajudar vocês a chegarem em alguma
21:32definição. Nessa fase aqui, tu vai abrir
21:34o máximo a busca e tu vai usar também
21:36sub agents, tá? Então aqui, por exemplo,
21:38ó, ã, aqui nesse aqui que eu criei o
21:40plano, tá vendo que ele usou um sub
21:42agent? Cadê? Hum, aqui, lembro cadê
21:46agora, mas ele tinha usado dois
21:47subagents, eu não lembro qual foi o o
21:50chat. E é OK, tá, gente? Deixar o modelo
21:52usar sub agents para fazer pesquisa é
21:53bom, ele mantém a janela de contexto
21:55menor, ele consegue separar os
21:57contextos. Vocês viram que quando ele
21:58usar subent lá, um sub angent buscou
22:00coisa do back end, outro do back do do
22:02front end. Então cada um sai com uma
22:04missão. Isso é bom, isso a própria
22:06ferramenta faz, tá? E nessa fase tu pode
22:08mandar link de coisa, conectar um monte
22:10de coisa. A gente vai ver depois é
22:12quando for o exemplo de construir a
22:14feature na na Techlads Clube, é, a gente
22:17usa muitas métricas, post, conecta um
22:19monte de coisa. Beleza? Só que aqui vai
22:20ter um monte de ruído. Depois quando tu
22:22vai paraa implementação de verdade, tu
22:24não quer ter esse ruído. Aí tu pega isso
22:26e joga em um plano, uma spec, o que for,
22:30tá? Ó, terminou, terminou de
22:32implementar, tá? Terminou de implementar
22:34esse cara aqui. Eu só vou terminar de
22:35explicar. joga num plano, depois tu vai
22:38para uma fase de implementação e
22:40verificar aquela implementação. Então,
22:42voltando aqui, pô, meu meu plano
22:44terminou de implementar, implementou
22:46tudo aqui que a gente tinha falado. Eh,
22:48tã, aí rodou o playgrid, deixa eu ver.
22:51Tá, tá aqui, tal. Beleza, testou as
22:53coisas. É, o que que falta agora nesse
22:56daqui? O que que falta nesse approach
22:58com plan mode? Vamos lá. Que é o que que
23:01falta? Eu já vou botar a imagem do funil
23:03de volta. A gente vai voltar. Não se
23:04preocupem, gente. A gente vai voltar lá.
23:05Só quero, como a gente tem um agente
23:07rodando, eu quero deixar ele rodando
23:08enquanto eu falo alguma coisa. Que que
23:09faltou? Code review. Revisar agora. Tá.
23:12Mas como que a gente revisa? Eu humano,
23:15eu sei que tinha um plano, eu consigo
23:16bater, eu consigo eu revisar, tipo,
23:19pegar o plano e revisar o output um por
23:21um. Cara, isso não é sustentável, não é?
23:23Pô, por exemplo, se eu vier aqui e eu
23:25olhar pro plano aquele que ele fez e
23:27revisar cada uma das coisas, cara, não
23:29dá. Então, o que que é a coisa mais
23:30fácil que a gente pode fazer? Usar outra
23:32LLM para validar. Ah, bom. Playwright
23:34não validou, ele validou a navegação das
23:37coisas, mas, pô, todas as regras de
23:38domínio tão tão aplicadas, tudo que a
23:40gente falou que ia fazer foi feito,
23:42cara, não sei. Então, qual que é a coisa
23:44mais simples que a gente pode fazer, tá?
23:46Que eu vou mostrar para vocês agora.
23:48Vamos lá. Vamos botar aqui. E aí eu
23:49volto com aquela explicação do contexto,
23:50tá? Não se preocupem. Pum, fit idente.
23:54Ah, show. Qual que é a coisa mais
23:56simples que eu posso fazer? Eu vou criar
23:57uma skill. Der, crie uma skill que é
24:01planeja, pergunta. Eh, tira dúvidas,
24:04dúvidas do trabalho com o usuário, cria
24:08um plano spec com given, when, then e
24:12todas toda todas regras de domínio
24:16também também marca as decisões técnicas
24:22e tem uma fase de implemente de
24:26implementação que após implementar
24:30inicia um sub agent. que valida se tudo
24:34foi feito como na spec, ó. Beleza?
24:38Então, o que que eu vou fazer aqui? Eu
24:39tô criando uma skill. Por quê? Eh,
24:41porque as pessoas também tm muita
24:42dúvida. Ah, como que eu crio uma skill?
24:44É, que que vai na skill e tal? Então, já
24:46vou aproveitar para fazer duas coisas ao
24:48mesmo tempo. Primeiro é mostrar para
24:49vocês é o o mais fundamental que vocês
24:52tem que entendiar e depois em cima a
24:54gente constrói as coisas, tá? Depois a
24:55gente vai entrar, a gente vai entrar em
24:57spec driven, a gente vai entrar nos
24:58limites de spe driven atuais por causa
24:59dos modelos, a gente vaientrar o que que
25:01vem depois de spe driven, mas a gente
25:02tem que alinhar muito nessas coisas
25:04fundamental fundamentais aqui, que é o
25:06que que eu consigo fazer hoje. Lembra
25:08que eu falei que a gente tava
25:09construindo uma ferramenta, né, o o
25:10Felipe tá aqui, o Spectror, que era uma
25:12ferramenta que fazia um pouco dessas
25:13coisas. Hoje tu consegue instruir um
25:14modelo e os modelos bons eles seguem a
25:17maioria das instruções, tá? Ele inicia
25:19um sabi agent, ele inicia um um playw e
25:21e eu chuto que até o final do ano isso
25:23vai ser muito muito muito mais
25:25confiável, tá? Ã, por que uma skill e
25:28não um agente? Eu raramente crio
25:29agentes, porque pensem o seguinte,
25:31skills são reusáveis. Tu pode iniciar um
25:35sub agent genérico e dizer usa três,
25:38quatro skills. Um sub, um agente, quando
25:40cria um agente custom, ele é um papel
25:43só, ele não é flexível. A skills
25:45basicamente tornaram agentes quase
25:47obsoletos. Tem casos que tu quer usar,
25:49mas basicamente tu faz tudo com skills,
25:51tá? Então ele vai criar essa skill para
25:52nós e a gente vai ver, ó, que tá skill,
25:55cursor, skill. Que que é uma skill? É
25:58como se fosse uma instrução que eu não
25:59quero ter que digitar toda hora, tá? Ó,
26:01ela tem um nome e uma descrição. Isso
26:03aqui é sempre carregado no contexto.
26:04Quanto mais skill tu tiver, mais isso
26:06aqui vai pesar no teu contexto. Isso que
26:07o agente decide, usa para decidir se ele
26:09usa ou não uma skill. Ele lê isso aqui e
26:11pensa: "Ah, essa pessoa quer planejar,
26:13eu tenho spe and build lá, eu vou
26:15carregar aquela skill". É isso que ele
26:16faz. Aqui tem eh o que ele colocou, fase
26:20um, fase dois, write the spec, fase
26:22três, implementa. Fase quatro, verifica.
26:24Claro que tu vai revisar, ver se se fez
26:27sentido, mas normalmente é assim que eu
26:29crio uma skill. O que que eu faço para
26:30criar uma skill? Eu resolvo um problema
26:32eu mesmo digo pro agente controlar,
26:34criar skill, depois eu reviso o que ele
26:36fez, porque eu não vou escrever um monte
26:38de markd, mas eu também não posso deixar
26:39ele desenfriado, criar um monte de
26:41coisa, que ele vai botar um monte de
26:42coisa inútil, tá? Então aqui a gente tem
26:44uma uma skill já para implementar. E eu
26:46vou dizer, beleza, use eh planeje o
26:50próximo item do map usando
26:54spec, como é que é o nome dessa skill?
26:56Speck unbuild. Vamos lá, deixar ele
26:59planejar agora. E a se a minha skill é
27:00boa, ela vai me perguntar para tirar a
27:02ambiguidade, tá? Porque eu disse que
27:05tinha que ter isso na skill. Vamos ver.
27:06Ah, pararã. Cadê? Speck and build. Fase
27:10um discover. Lê os arquivos. Tã,
27:14pergunte uma vez, uma vez one one
27:17question at the time. Isso aqui é muito
27:19bom, tá? Porque tem muita skill até de
27:20spec driven que ela manda as perguntas
27:22todas juntas, só que às vezes uma
27:23pergunta depende da outra. Só então é
27:25bom vir uma pergunta de cada vez. Ó,
27:26quem cria o job e o que muda no mundo?
27:29o que muda no mundo é profundo,
27:31não sei. Ah, faça o recomendado. E é, e
27:33ela normalmente recomenda, tá? Isso aqui
27:35o próprio eh o o própria IA já vai fazer
27:38recomendar uma coisa que ela acha ideal.
27:40Ah, faça o recomendado, que é o quê?
27:41qualquer usuário autenticado,
27:43administrador ou operador registra um
27:45job com um nome. Beleza? É isso. Então,
27:47faça o recomendado. Não vou ficar é
27:49pensando muito, mas pensa o seguinte, é
27:51muito bom tu usar a Ll para te perguntar
27:54bastante coisas, tá? Ah, faça todos o
27:57recomendado. Tem uma skill que a galera
27:59usa bastante que é de um youtuber Mat
28:01Pecock, que é Grillmi. É uma skill muito
28:04boa. Se puderem mandar no chat aí pra
28:05galera, ela basicamente te pergunta um
28:07monte de coisa. Tu quer fazer começar um
28:09projeto, ela te pergunta um monte de
28:10coisa. Eu vou te mostrar uma, eu vou
28:11mostrar para vocês depois uma skill
28:12nossa que eu uso bastante, que é um
28:14pouco similar, mas diferente, né? Mas é,
28:18é bom nessa fase de pesquisa fazer a IA
28:22te abrir os olhos, te ajudar bastante,
28:24porque ela tem um contexto code base,
28:26ela tem contexto da indústria, ela pode
28:27ir lá na indústria e buscar coisas e
28:29tal, eh, buscar referências da
28:31indústria. Então, isso é bem importante.
28:33Ó, vamos ver. Cadê? Ah, criou um job.
28:36Docs specs job. Bom, tenho um plano
28:39basicamente agora, né? Então é da minha
28:42skill. Vocês estão vendo isso? Eu quero
28:44fazer para vocês entenderem também que
28:45quando a gente fala de spec driven, não
28:47tem mágica ali, sabe? Um monte de gente
28:48fez um monte de skill e foram ajustando
28:50elas. Ó, que que tem aqui? Domain rules.
28:53Ele colocou cenários. Ah, lista empty,
28:56create list contains the created job.
28:59Botou, ó, given, um usuário signed.
29:02Quando ele posta para jobs, ele recebe
29:04um erro. Então agora eu tenho o quê?
29:06todas as regras que eu consigo verificar
29:09no final, porque antes eu não tinha, eu
29:10preciso ter as regras para poder
29:12verificar no final. Decisões técnicas
29:14que o a gente tomou também. Então, só
29:16isso aqui, gente, vocês já estão
29:17muito bem. E aí, mesma coisa. Vou lá,
29:20não preciso pegar aquela janela poluída,
29:22vou dizer spec and build e construa
29:26o job. Markdown. Então, ele vai
29:30construir aquilo ali. Eu precisava ter
29:31chamado barra speec and build job
29:34construa. Talvez não, tá? Talvez o
29:36próprio agente ia ser inteligente de
29:38usar skill, porque na descrição da skill
29:40mostra isso aqui. Mas eh eu eu gosto de
29:43chamar que eu não quero ter certeza que
29:44a coisa vai rodar do jeito que eu quero.
29:46Bom, ele vai começar a implementar. A
29:48gente vai voltar pra nossa pra nossa eh
29:50pra nossa explicação. Então, a gente viu
29:52research planejou, agora a gente vai
29:54entrar na fase de implementação.
29:56Implementa a coisa baseada na spec e
29:58verifica a coisa contra aquela spec ali.
30:01Esse é o fundamento que você tem que
30:02pensar. Ai, mas como que verifica? A
30:05gente vai, a gente vai fazer essa
30:06verificação e vai falar das limitações
30:08de verificação com o Ll, tá? Mas
30:11enquanto isso a gente vai passar para
30:13essa parte aqui, ó. Já tá no verify
30:15aqui, tá? Tá. R. Pô, o Grock é genial,
30:17gente. Pô, eu tenho meu meus meus
30:20questionamentos do El Musk, mas é um
30:22belo trabalho que eles fizeram no Grockp
30:24muito rápido. É, a gente vai sempre
30:25tentar trabalhar numa estrutura de
30:27progressive disclosure, ou seja, de aia,
30:30o agente, ele ir descobrindo as coisas
30:32que ele precisa. E skills permitem isso.
30:35A própria estrutura do Code base permite
30:37isso. Então, ah, quando que eu uso uma
30:38skill? Quando eu quero ter uma,
30:41basicamente, uma instrução que eu
30:43carregue sob demanda, quando o modelo
30:44precisar, porque a skill ela tem, ela é
30:47um markd. Quando tu traz aquele markd
30:49para dentro do contexto, ele enche teu
30:50contexto. Então, eh, skills são coisas
30:53sobre demanda, rules, tu bota só o que
30:55tu precisa no agents.m, tá? Isso é bem
30:57importante. E a estrutura de research
30:59plan implement ela ajuda nisso porque tu
31:01abre um research, um monte de skill, um
31:03monte de coisa, depois tu salva num
31:04plano e tu não carrega aquelas coisas de
31:06novo. Aí a gente entra na coisa, tá? Mas
31:08research plan implement não é spec
31:09driven? Gente, esse pack driven virou um
31:12grande guarda-chuva de coisas que
31:14ninguém mais entende o que que é, porque
31:16cada um adaptou paraa sua realidade. A
31:19gente vai falar um pouco sobre isso, e
31:20meio que perdeu a identidade. Então eu
31:22sempre volto pra coisa de não importa
31:23como que eu tô trabalhando, eu sempre
31:25tenho uma fase de research, uma fase de
31:26planejar, uma fase de implementar e
31:27agora uma fase de verificar, tá? Então
31:29aí quando a gente entrar mais em spec
31:30drift, a gente vai entender um pouco
31:31mais dessa desse momento da coisa. Ã,
31:34tá? Tá verificando com com playw.
31:36Beleza? E aí a gente entra em outro
31:37termo bem importante que é harness. Eh,
31:41você deve ter ouvido bastante falar
31:42sobre harness, talvez foi, talvez seja
31:44coisa que foi mais falada nos últimos
31:46tempos. E harness tem dois sentidos. Tem
31:50o harness estrito que a gente fala, que
31:51é a ferramenta que a gente usa, tá? né?
31:53Então, seja cursor, cloud code, esse é o
31:55Harness que a gente não tem muito
31:56controle sobre ele. A gente confia que a
31:58empresa fez um bom trabalho. Inclusive,
32:00uma dica que eu dou para vocês é: tomem
32:02muito cuidado com ferramentas de
32:03terceiros, porque a ferramenta que tu
32:05usa interfere muito no output que tu vai
32:07ter. Então, se tu baixar uma ferramenta,
32:08ah, não quero pagar, eu quero usar
32:10modelos open source, vou pegar aqui
32:12qualquer harness na internet, cara, pode
32:14ser que a pessoa, o desenvolvedor fez um
32:16trabalho muito ruim para gastar mais
32:18token usando aquele harness ali. Então,
32:19sugiro usar daqui a pouco um open code,
32:21algo que é conhecido do que usar
32:22qualquer coisa. Aí, em cima disso vem a
32:25parte que a gente consegue controlar ou
32:27a gente consegue adicionar para ter uma
32:29melhor resposta, que é o agents.m, é as
32:32skills, o próprio código, a estrutura do
32:34código é um dos melhores hardness que
32:36tem. Se tu conseguir que a gente entenda
32:37o código sem tu ter que dizer para ele o
32:38que que é muito melhor. Isso eh, a gente
32:41chama de guias, a coisa que guia o
32:43agente para chegar em algum lugar. E
32:45depois a gente tem a coisa que valida,
32:47que dá o feedback pro agente. É muito
32:49importante um agente ter feedback. Vocês
32:51viram que, pô, por que que eu uso
32:53Playwght para validar o Fronte? Porque
32:54se ele não tem um feedback que o que ele
32:56fez tá certo, ele vai assumir que tá
32:57certo. E assim, não dá para deixar o
33:00mesmo agente que a missão dele é
33:02implementar a coisa, dizer se a coisa tá
33:05pronta, porque ele vai dizer que tá,
33:06porque a missão dele é terminar aquela
33:08coisa ali. Aí quando tu abre outro sub
33:10agent, que a missão do sub agent é
33:11provar que aquela coisa tá funcionando,
33:13ele vai fazer de tudo para tentar
33:14validar aquela coisa ali. E o que que
33:16são essas validações? A gente chama de
33:18sensores, testes, lints, CI,
33:21observabilidade, hooks, que o Felipe vai
33:23falar também. Isso tudo dá feedback pro
33:25agente e é determinístico e não depende
33:27do julgamento dele. Então esse é o
33:29fundamento que você tem que pensar.
33:30Então voltando ao desenvolvimento de
33:32software, testes são extremamente
33:34importantes, Lint é extremamente
33:35importante, C é extremamente importante,
33:37todo esse tipo de coisa, porque eles dão
33:40feedback pra gente, tá? Ó, ele tá
33:42rodando aqui, deve tá rodando playw
33:44agora. Deixa eu ver, talvez seja isso,
33:45tá? Deixa eu voltar aqui. Beleza. Então,
33:47eh, nada mudou. Desenvolvimento de
33:49software. Uma boa arquitetura vai
33:50ajudar, é uma boa estrutura que o agente
33:52entenda. Isso a gente vai ver amanhã. É
33:54extremamente importante porque tu gasta
33:56menos tokens, é, ele acha as coisas mais
33:58rápido, é uma boa qualidade, é
34:00extremamente importante porque ele vai
34:01ter feedback do que ele tá fazendo.
34:02Vocês veem que aqui no meu code base, eu
34:04tenho dois tipos de teste, tá? Eu tenho
34:06a nível de API, eu tenho teste de
34:08integração, por quero validade ponta a
34:10ponta. E a nível interno, nos services,
34:13eu tenho teste, eh, opa, eu tenho teste
34:16eh unitário, porque eu tenho bastante
34:18lógica de negócio. Ó, terminou a
34:19validação, ele diz que a spec passou,
34:22ele verificou todas as regras de negócio
34:24que tinha no spec, lembra? Então, voltar
34:25aqui. Cadê apps, Doc, Job? Ele validou
34:29tudo isso contra aquela spec ali. Isso
34:31aqui já é bom, gente, sinceramente, isso
34:33daqui já é melhor que vários frameworks
34:36de spec driven que vocês vão usar por
34:37aí. E agora a pergunta que eu vou falar
34:40é a pergunta que eu tenho para vocês é o
34:42que que faltou aqui? A gente fez essa
34:44validação, mas o que que o que que
34:45faltou para ser pô para ser melhor? Hum,
34:48checklist. Code review. Review,
34:51sensores, gates. Não, os gates rodaram,
34:53tá? Os gates rodaram. Ó, 106 testes
34:56passaram. Então, ele rodou tudo aqui. Os
34:58gates ele passou, ele ele rodou tudo.
35:00Faz parte da minha coisa aqui, ó. Ele
35:01não só validou, como ele rodou tudo e
35:03garantiu que tudo funcionou. Teste de
35:05mutação, segurança e tal. Revisar. Sim,
35:07review é óbvio, gente. Review vai ter, a
35:09gente vai chegar no code review depois,
35:11mas pensando que tu quer que o agente
35:13consiga implementar coisa e se
35:14autovalidar, pensa o seguinte, pensando
35:16em review, primeira coisa sobre review.
35:18Se eu tô dando uma lista de coisas e
35:20essa lista de coisas eu validei que tem
35:22as regras de negócio que eu espero e o
35:24agente foi lá e revisou e provou que
35:26tudo tá funcionando, eu já tenho uma
35:28baita segurança. O que que falta aqui?
35:29Falta basicamente a gente ter mais
35:31validações que nos nos garantam que, pô,
35:35a arquitetura tá certa. os testes estão
35:37certos, esse tipo de coisa. Aí a gente
35:39entra numa estrutura um pouco maior, pô,
35:41eu tenho que pensar um pouco mais na
35:43arquitetura e esse tipo de coisa. Daí
35:45vem a ideia de spec driven. Deixa eu
35:48comentar aqui. Essa aqui é fit, qual que
35:49era fit? Jobs. Agora vou fazer o
35:51seguinte. É agent skills install TLC
35:55pack D. Agora a gente vai ir para spec
35:58driven que é beleza, a gente já fez um
36:00mini spec driven aqui, já funcionou para
36:02nós, mas a gente tá construindo eh
36:04software Enterprise, a gente precisa eh
36:06ter mais estrutura na spec, a gente tá
36:09construindo algo que eu preciso validar
36:10arquitetura. Speck driven ajuda bastante
36:12nisso. Eh terceiro Speck Driven. Planeje
36:16a o próximo item. O próximo item do road
36:19map. Vamos lá. Agora vamos fazer o
36:21seguinte aqui. Quanto ele planeja, a
36:23gente vai dar uma olhada em uma skill.
36:25Que que eu fiz aqui também para
36:26instalar? A gente tem um projeto, gente,
36:28que é o Agent Skills. Esqueço que tem
36:30gente nova aqui. Então, vamos lá. Agent
36:32Skills. Vou mandar aqui para vocês.
36:33Felipe já deve ter mandado. Manda no
36:35chat pra galera. Então, esse aqui é a
36:37nossa lista de skills open source. Todas
36:38as skills que eu vou mostrar estão aqui.
36:40Vocês foram no GitHub, inclusive dei uma
36:42estrelinha lá para nós que não deu ainda
36:44que a gente tá vendo aqui. Eu vou passar
36:45todo esse material para vocês, não se
36:47preocupem. Foquem em entender as coisas.
36:48A gente tá com 5.000 stars e aqui dentro
36:50de packag skills estão as skills no
36:52skill do catálog. É, e tem esse front
36:54end aqui que o William Fernandes tá aqui
36:56que fez. Sensacional. O Felipe Rodrigues
36:58também que tá aqui que vai falar com
37:00vocês mais tarde, fez. E aqui tá todas
37:01as nossas skills. A gente tem scan de
37:03segurança. A gente tem uma baita
37:05auditoria para não entrar skill lixo.
37:07Cuidado com skill lixo, tá gente? Skill
37:08é um prompt que vocês estão botando é
37:10dentro do sistema de vocês e tem muito
37:12problema com isso. E aí eu instalei a
37:13TLC Speck Driven daqui. É a nossa skill
37:16de spe driven development. Ah, mas por
37:18que que vocês fizeram uma skill de spe
37:19driven development? Porque a gente
37:21começou a ver que a maioria das skills
37:23elas eram só é uma instrução de prompt e
37:27não era nenhum prompt muito efetivo. E
37:28por quê? Porque ninguém fazia, vamos
37:31botar isso daqui, botar um monte de
37:32coisa. Porque ninguém fazia o quê?
37:33Ninguém fazia um benchmark de verdade
37:35dessas skills. El só dizer: "Ah, essa
37:36skill aqui é boa". Aí tu pega spec kit,
37:39é super powers, open spec. Era muito
37:42sentimento da pessoa, mas eu pensava:
37:43"Pô, cara, se a gente tá gastando token
37:45numa coisa, eu não vou saber se ela é
37:47realmente efetiva ou não". E aí a gente
37:48fez muito benchmark e ao mesmo tempo a
37:51indústria começou a mudar e a gente viu
37:53que as skills de spec driven elas
37:55ficaram para trás, principalmente por
37:57vocês já viram uma coisa aqui que
37:59praticamente nenhuma skill do spec
38:00driven tem, ela não valida o próprio
38:02trabalho. Então tipo, eu comecei a ver,
38:04cara, a indústria tá focando só em criar
38:06um monte de spec sem validar. Se quanto
38:09mais spe, quanto mais input eu tiver e
38:11menos output de qualidade eu tiver, pior
38:13é. Então, a gente começou a criar por
38:15causa disso e a gente vai ver a
38:16funcionalidade dela aqui. Ah, isso aí
38:19[limpando a garganta] pode fazer, pode,
38:21pode criar pack, o design e as testes,
38:24mas agora eu vou vou explicar um pouco
38:25para você sobre isso, tá? Vamos lá. Eh,
38:28enquanto ele cria esse pack, eu vou
38:30voltar aqui. Depois eu vou explicar spec
38:32driven ali assim que ele terminar. Mas
38:34normalmente o spec driven tem essas
38:35fases aqui. Eu tô usando a spec a TLC
38:37spec driven como como padrão, mas é
38:40normalmente os frameworks pega spec
38:43power são famosos. Esse é uma fase que
38:45tu especifica, aquela especificação, ela
38:47cria aquele bem similar ao give when lá
38:49que a gente viu, que é como um em BB, em
38:52BDD, em Gking. Tem uma fase de design
38:54que é podado que tu concordou no que que
38:57tu tem que fazer. A fase de design é o
38:59teu design técnico, decisões técnicas,
39:01arquitetura, diagrama. E tu passa paraa
39:03fase depois as tesques, que é a fase de
39:06implementação, é a fase de o que que vai
39:08ser usado para implementar. Por que que
39:09a gente como indústria fez isso? Por que
39:11que spec driven veio com uma ideia de,
39:13pô, Speck Driven é a spec fonte da
39:16verdade e tal? Speck driven é a grande
39:18coisa. Porque a gente trabalhava com
39:20modelos bem, não, não digo ruins porque
39:23eu vou comparar com quê, mas tinha muito
39:26retrabalho, ou seja, tu planejava algo,
39:28tu tinha que olhar a especificação,
39:30depois olhar o design, ajustar um monte
39:32de coisa no design. Isso ainda é
39:33realidade, obviamente, para quem
39:34trabalha com código mais complexo,
39:36código legado, mas não é realidade para
39:38muita gente, tá? Muita gente que já tem
39:41um code base que já tá bom, uma
39:43estrutura boa e trabalha com modelos
39:45bons, praticamente não revisa mais spec.
39:47Quem, se alguém trabalha aqui com eh
39:49spec driven, comentem aqui. Vocês ainda
39:52revisam no detalhe a spec? Eu que tenho
39:53visto assim, a maioria das pessoas já
39:55não revisa mais. E o que que a gente
39:56começou a ver na indústria e
39:59principalmente as as pessoas que usavam
40:00o TLC Speck Driven, elas usavam, elas
40:03usam muito TC Speck Driven porque elas
40:04gostam muito da garantia de execução e
40:07de implementação que dá, mas elas já não
40:09revisam mais. Aí eu comecei a ver, pô,
40:11mas esa aí a indústria tá movendo para
40:12outro outra fase que talvez a gente não
40:14precise de tanta coisa assim. Eu vou
40:16explicar um pouco sobre isso, tá? Mas ã
40:19ele tá criando os arquivos, vai criar o
40:20design e depois vai deixar implementar.
40:22Então gente, o que que acontece? A gente
40:24também fez bastante benchmark, tá? Tá
40:26aqui, ó. A gente fez benchmark. O como
40:28que é feito esse benchmark? A gente tem
40:30uma feature que é uma feature complexa,
40:32é integração com stripe. Uma feature é
40:35que levaria uns duas semanas para um ano
40:36e a gente fica reimplementando ela
40:38várias vezes, é, com os frameworks até
40:40até validar. E aí na versão dois, a
40:42Telec Spec Driven, foi quando a gente
40:43começou o o benchmark, ela batia muito
40:46pouco os outros frameworks,
40:48principalmente na parte de qualidade. E
40:49aí a gente fez bastante alteração para
40:51ela na versão três ela ser bem melhor,
40:54principalmente que ela se autifica e
40:55esse tipo de coisa. Então eu garanto
40:56para vocês hoje que se vocês testarem
40:59qualquer framewor spec driven, testarem
41:01terceira spec driven, ela vai ser
41:03melhor. Não só porque a gente bastou
41:04bast bastante esforço, mas porque ela
41:06tem essa parte de autverificação. Tudo
41:08que ela faz, toda a estrutura dela é
41:11feita para se autovalidar. Ah, mas eu
41:13tenho que usar a TLC Pack Driven? Não.
41:15Muita gente na própria empresa fez o
41:17próprio próprio framework da empresa
41:19baseado no nosso uso fundamentos. Então
41:21penso assim, cara, eu não tô vendendo
41:23para vocês até se pack dribl tô dizendo
41:25que essa é uma maneira confiável de
41:27fazer e são markds. Tu pode pegar, pegar
41:29essa skill e dizer, Cláudio, me explica
41:31como que funciona essa skill, como que
41:33eu faço isso no meu time pode fazer isso
41:35também, tá? Beleza? Cadê? Vamos lá,
41:37então. O que que tem no spec driven que
41:39a gente tem que ver? A spec que é bem
41:41similar aquela spec que tinha lá antes.
41:43Que que ela tem? O que tá fora de
41:44escopo, questões abertas que foram
41:47confirmadas. Isso aqui é muito bom para
41:48logar. As histórias de usuários, mesma
41:50coisa. Given when then. Eu já vou botar
41:52a construir porque eu não quero perder
41:54muito tempo. Tot spec driven build. Hã,
41:57qual que é o nome da da feature? Mesma
41:59coisa. Abrir outro features inventory.
42:01Tá, vou deixar ele construir. Enquanto
42:03isso, eu vou voltar pra explicação que
42:04eu tava dando da TC specd. Cadê specs,
42:07features? Ó, então a gente tem uma spec,
42:09tá? Que que essa spec tem? Open
42:11questions, esse tipo de coisa. O given
42:14ali. Por que que isso aqui é importante,
42:15gente? As pessoas pensam, pá, mas por
42:17que que tem que ter essa esse texto ali?
42:21Porque pensem o seguinte, é muito
42:22difícil tu representar lógicas de
42:26domínio de alguma forma, tá? Ó, ele me
42:27perguntou se eu quero usar sub agents.
42:29Por quê? Porque se eu for em tesqus,
42:31provavelmente tem várias fases, são 18
42:34eh 18 fases. Eu vou explicar sobre isso
42:36depois. Vou dizer: "Ah, usa fazem line".
42:38Tá? Eu vou voltar para não atrapalhar
42:40minha a minha explicação. Isso aqui é
42:42importante por quê? Toda a regra de
42:44negócio tá aqui. Isso aqui é parciável,
42:46tá? A skill, inclusive, se a gente
42:48entrar nela aqui, barra TLC Packdriven,
42:50ela usa um pouco de determinismo e um
42:53pouco de não determinismo para fazer as
42:55coisas. O Felipe fez vári várias
42:57alterações onde ela valida os arquivos e
43:00ela extrai coisas usando Python em vez
43:03de deixar a IA extrair. Então tu
43:05consegue validar que tudo isso aqui foi
43:08implementado e validado porque tem uma
43:10parte determinística que extrai isso.
43:11Então para quem tá construindo skills,
43:13tentem misturar coisas determinísticas
43:15com não determinísticas porque te dão
43:17mais segurança. Então voltando até LC
43:19spec driven, tu pode ter scripts dentro
43:21de uma skill. Aqui tem vários exemplos.
43:22Copia isso, gasta menos token, é mais
43:25seguro e te dá eh mais segurança,
43:28obviamente, né? Redundante. Então, spec
43:30é isso. Ah, o que que tem que ser feito?
43:31Aí a gente passa pra parte do design.
43:34Aqui normalmente é que a gente gasta
43:35mais tempo se tá numa arquitetura que
43:36precisa ajustar coisa, porque aqui tu
43:37tem uma visão do futuro de como a coisa
43:39vai ser. Aí tu vai lá e tal, é, valida,
43:42pô, que vai ser feito assim. tem um o
43:44job service, data model é importante,
43:47ah, error handling, risco e concerns.
43:50Então, tu tem um um snapshot de como a
43:52coisa vai ser feita, tá? Aí depois tu
43:54tem as tasqus. As tes são uma aqui, ó,
43:57tá vendo? Tesk um. As tes são pequenas e
44:00atômicas pro a gente ir implementando
44:02uma a uma. E por que que isso é
44:04importante? Até a geraça, geração
44:06anterior de modelos, gente, a gente não
44:08só tinha que dar um input bom pro
44:10modelo, mas também tentar dar instruções
44:12claras de implementação para ele não
44:14pular as coisas. Eu usei muito o
44:17Composer, o modelo Composer 2.5 da do
44:21cursor. Ele é um modelo totalmente
44:22maluco assim, pô. Eu digo que ele é tipo
44:25JNY assim, tipo, é o attention span dele
44:28é muito pequeno, então se dá uma coisa
44:29muito aberta para ele, ele faz metade da
44:31coisa. Então, quanto mais estruturada
44:34for a coisa, tu dizer: "Olha, tu tem que
44:35implementar isso, você tem que rodar um
44:37teste para provar isso". Tá vendo? Uma
44:38tes que tem o quê? A tes que tem o que
44:39que tem que ser feito e como que ele
44:41valida. Então, aquela coisa só tá
44:44completa quando ele roda um gate
44:45determinístico, que é um teste, tá? Isso
44:48aqui a skill faz normalmente. E então
44:50isso aqui é muito útil pra gente lidar
44:53com esses modelos antigos. E outra coisa
44:56também é que isso dá uma estrutura de
44:58implementação, mas tem um tradeoff, né?
45:01Pô, quando o modelo vai fazendo tesque
45:02por tesque, é mais lento, tá? Vocês
45:04estão vendo aqui, ele tá fazendo uma,
45:06ele tá provando que tá funcionando, vai
45:07fazer a outra e assim ele vai ficar
45:09rodando até implementar todas as tesqus.
45:12Cara, isso tem um efeito, né? Tem um
45:15efeito na na velocidade, basicamente é
45:17mais lento, gasta mais tokens porque ele
45:20roda um teste, ele para e tal, mas é
45:23necessário, era necessário até então
45:25pros modelos que a gente tava lidando,
45:27tá? Porque sem isso tu não tinha
45:29segurança de que ia ser tudo feito e
45:31tal. Então são coisas necessárias. Outra
45:34coisa que a gente não faz aqui, mas o
45:36superpers que é o framework faz, é ele
45:39dá o código pronto pro tipo, uma fase de
45:42uma fase planeja e no próprio plano ele
45:44já bota o código de como vai ser e o
45:46outro modelo só implementa. Isso não é
45:47uma coisa boa também, tipo com os
45:49modelos evoluindo, o modelo que vai
45:51implementar, ele deveria saber
45:53implementar. O que que tu tem que dar
45:54para ele é um uma direção e depois
45:56validar. A gente vai vai ver sobre isso.
45:58Então, o que que o spec driven fazia?
46:00Então, pra gente recapitular uma spec,
46:02revisar o design e depois tesques pro
46:05modelo seguir uma a uma e rodando teste
46:07e tal. Isso aqui, gente, muito bom.
46:09Então, para quem tá hoje trabalhando,
46:11ainda não tem acesso, pô, eu não consigo
46:13usar sempre um sonet para implementar,
46:15eh, eu não consigo usar um Grock para
46:16implementar, vocês ainda vão se
46:18beneficiar bastante desse modelo aqui de
46:20spec driven por um bom tempo. Ah, mas
46:22não, eu já tô que nem tu, pô. Eu consigo
46:24usar um Grock, consigo que nem o
46:26William, que o William usava Opos para
46:28planejar e implementar. Se tá nesse
46:30nível, essa estrutura que tá te tá te
46:32atrapalhando, porque esses modelos são
46:34muito mais inteligentes para
46:35implementar. Eles conseguem fazer bet,
46:37eles conseguem implementar muito mais
46:38rápido. Isso aqui basicamente é fazer
46:40babysitting desses modelos. Eh, e eu vou
46:42explicar como a gente passa por isso,
46:44tá? Outra coisa interessante aqui que
46:46tem no TC6 pack driven que é importante
46:49é um log de decisões, tá? Então ele eh o
46:52que que o que que foi decidido e por
46:54isso aqui é muito bom para te ver tudo
46:56que aconteceu. Então para quem tá nessa
46:58situação de da tu tá fazendo aquele
47:00composição de modelo, tu usa um modelo
47:01bom para planejar, o modelo mais barato,
47:03tipo composer para implementar, usa o
47:05composer? Cara, eu testei o composer, o
47:08meu a minha meta era fazer o composer
47:10entregar muita qualidade. E a última
47:12versão dele Spec Driven, eu consegui ele
47:14bater todos todos e os outros frameworks
47:17com o composer. Por quê? porque a gente
47:19botou bastante estrutura para ele. Então
47:21dá para te usar tranquilo, tá? E vou
47:24voltar aqui. Aí ele tá implementando,
47:25vai implementar tesca por tesc. Vou
47:27deixar ele implementando e eu vou voltar
47:29aqui. E outra coisa também que a gente
47:31tá chegando, que tá dificultando
47:32bastante é a coisa do spec driven, é o
47:34seguinte. A gente tem um fluxo de
47:36desenvolvimento a gente, onde a gente
47:38tem um um PRD, um product require
47:40document, normalmente a gente tem um
47:42design doc, que é onde tá, eu vou
47:44mostrar depois, que é onde tá as
47:45decisões de design que tu compartilha
47:46com a empresa, com outras pessoas.
47:48Depois isso vira um projeto e para cada
47:51tesque,
47:53um design, um tesques. Aí vem a primeira
47:54coisa que as pessoas falam que é: "Tá,
47:56mas a spec é para as pessoas validarem?"
47:59Não, spec é pro agente. O design é para
48:01as pessoas validarem. Até dá, mas também
48:04é pro agente, tá? E a tesque do spec
48:07driven vira tesque no board? Não. Aquela
48:09tesque pequeninha é uma tesque pro
48:11agente. Aí o que que vai no board? Aí
48:13cada pessoa faz de um jeito. Quem é mais
48:15avançado aqui, eu tenho quase certeza
48:17que se usa spec driven fez alguma
48:19maneira de juntar o spec driven com o
48:22resto do fluxo. Quiser mandar no chat o
48:23que que fez. Então, se teve uma ideia
48:25inicial, eh, parte disso eu também
48:28acreditei, eu não acreditava na parte de
48:30spec ser a fonte da verdade, mas eu
48:32acreditava que o task tracking gira e
48:34linear ia morrer. Então, o spec driven
48:36inicial se estruturou assim, não, tudo
48:38fica no repo, esquece o resto. Só que na
48:40verdade a indústria tá indo para um lado
48:41onde é o oposto. É, cada vez mais a
48:43gente quer conseguir instrumentar
48:45agentes de qualquer parte. E a melhor
48:47maneira de fazer isso é a partir de um
48:48task tracking, um board, porque tu pode
48:50ter um fluxo totalmente automatizado que
48:52vem lá de um suporte ticket, cai num
48:55numa triagem, um agente faz triagem, ele
48:57joga para outro agente que implementa e
48:59nem chega no teu local. E aí isso
49:00dificulta bastante com o spec driven.
49:03Outra coisa foi eh spec fonte da
49:05verdade, cara, não se consolidou. Por
49:07quê? E assim, se alguém usa spec como
49:09fonte da verdade, funciona, sigam
49:11usando. Mas a realidade é que se tu não
49:13tá num time onde tu consegue controlar
49:14que toda operação vai ser feita com spe
49:17driven, um que já tem o drift. O código
49:20é diferente da spec. O que acontece? A
49:22gente tem modelos extremamente
49:23inteligentes. E aí tu diz para ele,
49:25olha, essa aqui é spec. Aí ele olha o
49:27código é diferente. Aí ele começa a
49:28lupar num reasoning pensando sobre o que
49:31que é o certo. Tu tá atrapalhando o
49:33modelo. Cara, não faz isso. O que a
49:35gente tá fazendo, que eu vou mostrar no
49:36segundo bloco depois do almoço, é usando
49:38mais os os boards como fonte da verdade,
49:40deixando só decisões no repositório,
49:42ADRs e tal, tá? Isso é o caminho que a
49:45gente tá indo e eu vejo que a indústria
49:46tá indo bastante. Ah, mas eu quero
49:48deixar e pack comitado. Pode deixar,
49:49tranquilo, sabe? Mas pensem que tem
49:51esses esses essas limitações e a gente
49:54vai seguir trabalhando aqui, tá? Então,
49:55a gente entendeu spec driven, o momento
49:57que tá spec driven. Eh, como eu quero
50:00garantir que a gente não fique sem
50:01tempo, eu vou já começar a próxima parte
50:03aqui. Vou fazer o seguinte. Vamos lá.
50:05Agora a gente, eu vou dizer o seguinte,
50:07abra uma work, crie uma. Pode falar,
50:10Dom.
50:11Teve uma coisa que gerou bastante
50:13dúvida, mas acho que só para
50:16parar as dúvidas por por hora. Ah, foi
50:18quando tu falou ali de para modelos
50:21melhores não usar TC Spec Driven. Eh, tu
50:24vai explicar isso com mais detalhe
50:25depois.
50:26>> Vou chegar. Não, não vou, gente, eu vou
50:27dar, a gente vai, vocês vão sair daqui
50:29com todas as respostas, tá? De novo, eh,
50:32a TLC Speck Driven, eu tenho certeza,
50:34dos frameworks que eu conheço, ela é
50:36disparada melhor, a gente realmente, eu
50:38gastei uns R$ 30.000 R$ 1000 testando
50:40isso. Então eu confio no benemark.
50:42>> Gastou um quid usado.
50:43>> Mas o modelo de spec driven no geral eu
50:46vejo que ele chegou no limite
50:48principalmente pros modelos atuais e pra
50:50estrutura que a gente tá indo. E eu vou
50:51dar duas opções para vocês, tá? Uma
50:54opção é para não ter uma grande breaking
50:55change para quem usa spec driven e outra
50:57é o meu fluxo, que é o que a gente tá
51:00começando a implementar na TLC, que eu
51:01acho que vai ser o talvez o que faça
51:04sentido. Aí vocês vão evoluindo como
51:06vocês acham que é melhor, tá
51:08>> boa? coisa vou dar uma po fal
51:10>> mandar pro pro pessoal ali. Ã, teve
51:12bastante gente questionando a
51:16metodologia ali usada para avaliação da
51:18Telec Driven e tal. Vou deixar o blog
51:21post aqui que o Valdemar fez lá na
51:22comunidade. E de novo, gente, a gente
51:24não tá querendo vender para vocês, tipo,
51:27é open source aberto assim, tipo, não é,
51:29a gente não tá tentando convencer
51:31ninguém, usem isso e tal, mas tipo, é um
51:33bom trabalho feito pela comunidade, open
51:35source, é gratuito. E nesse arquivo tem
51:38todos os benchmarks ali que a gente fez
51:40mostrando o por que é melhor e tal.
51:42Então, tipo, testem por conta própria,
51:44veja se funciona para vocês, mas é open
51:46source assim, não custa nada para usar.
51:48[risadas]
51:49>> Sim, sim. Eu acho, eu acho isso
51:50engraçado. As pessoas questionam, cara,
51:52o, é, tem todos os resultados abertos.
51:55As pessoas da comunidade, inclusive, já
51:56rodaram esse benchmark. E, gente, é um
51:58monte de MarkD que a maioria das pessoas
52:00fazem nas empresas é elas adaptam spec
52:03driven pro fluxo delas. Então, elas
52:04pegam a Telec Speck Driven, elas pegam
52:06outras que elas gostam, elas mandam pra
52:08agente e diz: "Olha, compara essas e me
52:10diz qual que é melhor usando fundamentos
52:11de LL Mejude sempre vai ser TLC spec
52:13driven, porque a gente implementa vários
52:15fundamentos". Então tu pode pegar todas
52:17essas coisas, mandar para LM e
52:18perguntar, que às vezes parece, ah, tá
52:19vendendo a a skill, a gente não ganha
52:21nada com isso, a gente só compartilha
52:23com vocês o que a gente usa, tá? Mas
52:25beleza. Então, eu falei que o modelo de
52:28spec driven ali tá chegando em limites
52:30por causa de da do caminho que a gente
52:32tá indo dos modelos. E aí, a primeira
52:34coisa que eu vou deixar para vocês é
52:35esse daqui. Cadê TLC? Que eu vou
52:36instalar aqui, ó. Em vez de TLC spec
52:38driven, a gente vai usar TLC spec. Opa,
52:41cadê spec link? Essa em vez de fazer uma
52:43Breaking Change na TC Speck Driven,
52:45porque ela, essa versão nova é mais para
52:48esses modelos melhores ainda, talvez
52:49daqui uns três meses a gente faça uma
52:51breaking change, essa é a versão nova
52:52que eu imagino para Telec Pack Driven,
52:54tá? Que é a TLC Spec. Ah, que vamos lá.
52:57TC6 Packlin. Planeje o próximo item do
53:01Holdmap. Por que que eu abri uma work
53:02tree, gente? Uma work tree é basicamente
53:04não é só uma brand, tá vendo? Fit
53:06inventário. Ela não é só uma brint, ela
53:08é uma brand com uma cópia do código, ou
53:11seja, eu consigo trabalhar em duas
53:12coisas ao mesmo tempo sem elas se
53:13baterem. E como eu uso SK Lite, eu não
53:16tenho nada que interfira um no outro.
53:18Então eu posso deixar essa branch
53:19implementando o que tava implementando,
53:20ó, já tá no na verificação, tá vendo? E
53:22eu abro outra pra gente não gastar muito
53:25tempo e já começar a fazer outra coisa,
53:27tá? Aí depois o merge que se vire. Mas
53:29eu não vou eu não vou entrar muito no
53:30merge aqui porque minha a minha ideia é
53:32mais mostrar para vocês o fluxo. Então a
53:35TLC Specan vocês vão ver que ela é bem
53:38mais le que a gente mudou na TLC Spec
53:41driven para TLC Spec é spec design virar
53:44uma coisa só e a gente não tem mais
53:46tesquagem
53:48final, ou seja, a gente deixa um modelo
53:50que é bom em fazer o trabalho dele de
53:52implementar, fazer a implementação do
53:54jeito que ele acha que é ideal e depois
53:55a gente valida bem. Então isso tem uma
53:57grande diferença, uma grande diferença,
53:59tá? Eu vou mostrar para vocês. A TLC
54:01Speck Driven implementou as coisas todas
54:03e agora ele tá rodando um verifier aqui.
54:06Então é um verifier muito mais rígido do
54:08que aquela skill que a gente fez em
54:09house. Ele bate todos os critérios, ele
54:12bate os testes, ele marca linha por
54:14linha do que foi feito. Então ele não
54:17deixa escapar nada, ele é bem bem bem
54:19seguro e bem bom, tá? Por isso que eu
54:21digo, pô, se vocês usam modelos mais
54:22baratos para implementar, isso aqui é
54:24extremamente necessário. E agora eu vou
54:27voltar para esse cara aqui. Ele tá
54:28explorando o Code Base, tá? Então,
54:30quando tá acontecendo aquilo ali, vamos
54:31seguir um pouco mais pra frente, tá?
54:33Depois é code review, tá? Beleza?
54:35Beleza. Deixa eu tá tá tudo alinhado.
54:38Hum, eu vou, vamos lá, tá? Ele vai criar
54:41o plano aqui. Aqui a gente também,
54:43gente, enquanto ele tá trabalhando, eh,
54:46a gente falou bastante dessa parte aqui
54:47de implementação, né? aqui, aqui dentro.
54:49Basicamente eu não entrei nessa parte
54:51ainda do projeto e tal, eu vou entrar
54:53nisso depois, tá? Que é uma coisa que as
54:54pessoas têm bastante dúvida, tá? Mas
54:56como tu estrutura o fluxo, de onde vem o
54:58projeto, como é que ele vira uma spec? A
54:59gente vai entrar nisso aí também. Eu tô
55:01tentando ir numa linha que seja bem
55:03fácil vocês entenderem como as coisas
55:05vão indo e como a necessidade vai vindo,
55:07tá? Então a gente entendeu que tem a
55:08necessidade da gente montar esse harness
55:10em volta, tá? Que ele é uma combinação
55:12de coisas não determinísticas com coisas
55:14determinísticas e mais os sensores do
55:15nosso COD base que teste, todo esse tipo
55:17de coisa. E a gente também entendeu que
55:19o spec driven atual ainda é uma coisa
55:22que faz sentido, tá? E para muitos
55:25casos, mas a gente tá movendo já para
55:27não fazer. Mas simplesmente não usar
55:29nada não dá, porque os modelos ainda são
55:31não determinísticos e por mais que eles
55:33sejam bons, eles vão deixar alguma coisa
55:35passar. Por que que eles deixam coisas
55:36passar? Porque quando dá uma missão pro
55:38modelo, pensa que a LM ela é uma máquina
55:40de probabilidade, tá calculando sempre a
55:43próxima coisa. E se a missão dela
55:44implementar, ela vai otimizar para
55:46implementar. Ela não vai tentar testar
55:47tanto. Ela vai tentar obviamente, mas
55:50vai deixar a coisa passar. Ela vai
55:51esquecer de rodar coisas. Então, quando
55:53tu abre outro para validar, a missão
55:55dele é aquela ali, pô. Ele vai achar. E
55:57o code review é bem similar, a gente vai
55:59entrar nisso também, tá? Tá ficando. E
56:01ah, outra coisa que a TC Spec Driven
56:03tem, ela tem teste de mutação, tá vendo?
56:05Ela tá fazendo isso aqui agora, tinha
56:06esquecido. Teste de mutação, o quê? Ela
56:08pega alguns casos, ah, uma função,
56:11recebe um, recebe dois números e soma
56:14esses números. Ele vai tentar botar
56:16número negativo, fazer um monte de
56:17coisa, tá? Isso é bem, já vem bulin,
56:19você não tem que se preocupar com isso.
56:20Ó, tá fazendo ali teste de mutação.
56:22Dizem que é uma das coisas mais efetivas
56:24pr para testes com IAS. Ah, beleza,
56:27gente. Então, aqui a gente criou um
56:29plano, lembra? Telec que eu tô usando
56:31aqui. Qual que é a grande diferença do
56:33spec driven normal? Ah, ele criou dentro
56:34da outra fit. Putz, que ele pegou da
56:37brand. Tá, fazer o seguinte, não use a
56:40pasta inventor, crie o como já tava ali
56:43a pasta, ele criou na mesma. Mas o plan
56:45ele é uma fusão da spec e do design. Por
56:49quê? Porque outra coisa que era bem
56:50difícil que eu via é que as pessoas não
56:53sabiam o que que que o que botar na
56:55tesque do board, no gira, sei lá o que
56:58for. E aí botava qualquer coisa, só um
57:00título, qualquer descrição. E aí quando
57:01ia planejar, elas começavam a planejar
57:03tudo de novo, pegando o contexto de um
57:05design doc e tal. e o board não se não
57:07servia para nada. Só que eu tenho visto
57:08que cada vez mais as pessoas usam o
57:10board. Então, a primeira coisa aqui que
57:12a gente fez nessa alteração é tu tem um
57:14plano que tu pode, esse plano pode virar
57:16uma tesque e aí tu pode pegar de lá, por
57:18exemplo, ó, tu pode vir planejar tua
57:20coisa aqui, tu pode planejar tua coisa,
57:23ã, criar uma tesque, essa tesque vai
57:25para cá e aqui tu não vai mais fazer
57:27isso aqui, basicamente. Tu vai só fazer
57:28a implementação aqui, só implementa ela.
57:30Então, a primeira coisa que a gente
57:31mudou aqui foi isso. Ainda dá, essa
57:34estrutura ainda dá para comitar. Eh, se
57:36quiser comentar seus specs, pode
57:38comentar, mas ela também é feita para
57:39integrar melhor com o board, seja o
57:41liner, seja o que for que vocês usarem,
57:42tá? Então aqui só tem um plano. Depois
57:44eu vou deixar ele mover para um
57:46diretório novo para vocês verem qual que
57:48é a diferença. Não, putz. Ah, tá. Ele
57:50continua o próximo item. Vamos lá. Vamos
57:52ver. Ele vai criar um plano agora
57:53direitinho. A gente vai most vai ver
57:54ali, ó. Verificação. Tá terminando. Ele
57:57escreve um validation. Esse aqui é o
57:59outro que tá rodando. Beleza. Então,
58:00deixa eu ver esse plano que ele vai
58:02criar agora para mim. Nada como a work
58:04tre, galera. Word resolve o problema de
58:06vocês. É paralelizar a coisa. A gente tá
58:09tá enquanto a TLC Spec Driven tá
58:11verificando o trabalho dela, eu tô aqui,
58:14ó. TC Speclink criou o plano. Crie o o
58:17checklist. É, ó, agora a gente vai
58:19conseguir ver aqui, ó. Tem uma, a
58:21próxima item do roadmap é procurament,
58:22que é compras e vendas. Explica o
58:24explica o explica o problema, explica o
58:27que tá fora de escopo, explica as coisas
58:29que foram assumidas e não foram
58:30confirmadas. Então, era bom confirmar
58:31elas, eh, as histórias. E aqui tem todo
58:34o contexto de decisões que foram
58:35tomadas, o fluxo da arquitetura. Então,
58:38ah, entra por aquele screen, tem uma
58:40API, chega no post service, bom para
58:42humano revisar, data model para revisar
58:44também. Então agora eu tenho uma coisa
58:46que pode virar uma tesque, isso aqui já
58:47ajuda bastante. Tem uma coisa que pode
58:48virar uma tesque, não preciso depender
58:50só do da coisa no repositório, tá? Essa
58:52foi a primeira mudança que a gente fez.
58:53Mudança grande foi baseado muito nos
58:55usos das pessoas. Agora ele vai criar os
58:58checks. Eh, a Telec Spect Driven tá
59:00rodando e a gente vai ver duas coisas
59:02paraa gente finalizar esse bloco antes
59:04da gente entrar no Não, eu vou uma coisa
59:07principal pra gente finalizar esse bloco
59:09e eu vou compartilhar mais algumas libs
59:12deixar esse cara aqui terminar. Tá
59:13escrevendo check. Deixa eu ver. Show.
59:16Ah, olha aqui que legal. O verifier
59:18falhou. Tá vendo, ó? Viu? Vocês viram ao
59:20vivo, gente? Mesmo numa coisa simples,
59:22ele de 389 acceptas criterias. 38 deram
59:27certo e um falhou. E aí ele mandou de
59:29volta, olha, falhou um. Aí ele vai lá,
59:32arruma e manda rodar de novo. Então isso
59:35aí vocês não precisam se preocupar.
59:36Tipo, o próprio Harness tá fazendo isso.
59:38Hardness da skill. Então o que vocês
59:39fazerem é importante pensar nessas
59:41coisas. Quanto menos eu, humano, me
59:44envolver nesse loop de implementação,
59:45melhor, porque daí eu consigo fazer esse
59:47loop em qualquer lugar, não precisa ser
59:48na minha máquina. Essa é a coisa mais
59:49importante que vocês tm que entender. A
59:51coisa verificando a coisa. Aí esse outro
59:52aqui tá criando o checklist. Vamos
59:53deixar ele criar o checklist. Criou, ó.
59:55Olha a diferença que a gente tinha
59:57antes. Antes a gente tinha uma spec que
59:59tinha tesques, design, spec, um monte de
1:00:01coisa. Agora a gente tem um plano
1:00:03basicamente que é uma tesque e os checks
1:00:06que são extrair desse plano as
1:00:09implementações e fazer um bater com cada
1:00:11um. Olha, get get API suppliers. Numa
1:00:14tabela vazia tem que responder 200 com
1:00:17arrei vazio. Como que tu prova isso?
1:00:19Rodando o teste. Então são vários
1:00:20checklists que ele vai ter que rodar no
1:00:22final. Ou seja, quanto ele ser spec, a
1:00:24gente deixa o modelo implementado do
1:00:27jeito que ele achar melhor, paralelizar
1:00:28a coisa, fazer o que ele quiser e depois
1:00:30a gente roda um checklist forte nele e
1:00:32faz ele provar tudo. Basicamente isso.
1:00:34Então é extremamente mais econômico, é
1:00:36muito mais rápido e usa o modelo da
1:00:39melhor forma possível, tá? Então esse é
1:00:40o é é a grande aposta que eu vejo. Então
1:00:43vamos botar aqui TLC Spec. Vamos deixar
1:00:46ela implementando também. Vamos lá. TC
1:00:48SPC. Ah, não, tem que voltar naquela. Eu
1:00:50vou botar nesse cara aqui mesmo. Qual
1:00:52que é o erre fit inventory? Vamos lá.
1:00:54Hã, aqui spec TLC pack. Cadê? Vamos lá.
1:00:59Quero deixar ele implementando. Ó agora
1:01:02que ele tá terminando de rodar. Deixa eu
1:01:03só ver. Vamos. Ah, ele tá fumado. Vou
1:01:06fazer aqui nesse daqui, depois eu volto
1:01:07nisso. Vai TC pack. Implemento,
1:01:11esse plano aqui. Então, vou deixar ela
1:01:13implementando esse cara aqui. Eh, mais
1:01:16uma coisa que eu quero mostrar para
1:01:18vocês nesse bloco antes da gente
1:01:19finalizar que é o seguinte. Ah, aqui a
1:01:22gente terminou, tá? Esse cara, ó, tá
1:01:24escrevendo validation report. Então, o
1:01:25que que eu faço? Terminei uma feature,
1:01:27tá? Pô, ela ela rodou o meu pipeline,
1:01:30seja TL6 Pack Driven, seja TL6 Pack LAN.
1:01:33Essa aqui é TL6 Pack Driven. Ele
1:01:34verificou que tá tudo feito. Pô, o que
1:01:36que falta agora? Antes de chegar em mim,
1:01:38eu vou andar revisar. Mas antes disso,
1:01:40eu boto mais uma camada de code review.
1:01:42O que que entra nessa camada de code
1:01:44review? Entra revisão de, pô, eh, a
1:01:47arquitetura mudou, entrou algo novo na
1:01:49arquitetura, algum padrão novo, tem
1:01:51alguma regressão, o agente tocou em algo
1:01:54que não era relacionado a essa feature,
1:01:56tudo isso faz parte do review final, que
1:01:58não tem muita relação com a skill em si,
1:02:00tá? Então, como que a gente faz isso? A
1:02:02gente tem uma skill também de de code
1:02:04review. Vamos TLC. Eu vou instalar ela
1:02:06aqui. Tem duas skills, tá? Tem uma, eu
1:02:08vou usar essa daqui que ela é mais
1:02:10rápida de rodar, mas tem, opa, vamos
1:02:11usar essa do essa do Felipe que é nova
1:02:14aqui. Então essa skin uma skill de code
1:02:15review. Vamos botar aqui. Ah, use a
1:02:18skill de dud para validar as alterações
1:02:23feitas aqui. Não faça nenhuma integração
1:02:26com Git. Eh, essa skill aqui é uma skill
1:02:29que vocês vão plugar pipeline de vocês,
1:02:31algo assim. para fazer revisão do P
1:02:33request, tá? Então, como que funciona
1:02:36uma revisão com IA? Pensa o seguinte, a
1:02:39gente viu um pouco ali sobre sub agents,
1:02:41mas qual que é a ideia? A gente sabe que
1:02:42cada sub agent é bom em uma coisa. Então
1:02:45tu inicia, primeira coisa de de code
1:02:47review com, tu inicia um sub agent para
1:02:49cada coisa que é importante paraa tua
1:02:50pro teu code base. No normalmente o que
1:02:52a gente usa nos nossos é um para
1:02:54segurança, um para requirements, um para
1:02:55garantir que tudo foi testado ou que tem
1:02:57testes, um para arquitetura, garantir
1:02:59que os padrões de arquitetura foram
1:03:01seguidos. O que eu gosto de validar
1:03:02também é que não foi adicionado nada na
1:03:04arquitetura que não seja conhecido, se
1:03:07foi me avisar, porque a IA tem muita uma
1:03:09coisa de querer abstrair demais e às
1:03:11vezes elas trazem design patterns que eu
1:03:13nem sei que é, cara. Não bota sem me
1:03:15avisar. Regressão e alucinação. Essa
1:03:17daqui extremamente importante. Porque
1:03:18que acontece? Principalmente modelos eh
1:03:20versões anteriores, às vezes eles
1:03:22estavam passando por um arquivo que não
1:03:23tinha relação nenhuma. Com a mudança
1:03:25deles, eles alteravam algo. Já vi, pô,
1:03:27deletar fila, mexer em estrutura de
1:03:28banco de dados. Então esse é da
1:03:30regressão e alucinação. Ela olha para
1:03:32essas coisas e aponta: "Olha, isso aqui
1:03:33não tem, eu acho que não tem relação com
1:03:35essa, com essa que tu tá fazendo. E
1:03:36performance, esses são os que a gente
1:03:38faz, tá? Eh, essa skill eu vou, eu
1:03:41confesso para vocês, essa skill do
1:03:42Felipe, ela é nova, que eu tô usando K
1:03:43jude. A gente tinha uma que era o pior
1:03:45review, que é o que a gente usa no time
1:03:47também. Eu vou deixar ela para vocês,
1:03:48eh, depois eu dou uma olhada, mas essa
1:03:51daqui é baseada nessa skill de PR review
1:03:53que eu vou deixar para vocês. Essa do
1:03:54Felipe é uma nova que a gente tá
1:03:55testando, que ela tem mais, ela tem um
1:03:58harness melhor, porque tu consegue rodar
1:04:00elas várias vezes e ela não fica
1:04:03apontando coisas infinitamente. Ela
1:04:05aponta uma vez, valida aquelas coisas e
1:04:07tal. Então a gente vai provavelmente
1:04:08mover para essa dedude. Ã, mas o slide
1:04:10que eu tô mostrando da outra que eu vou
1:04:11deixar para vocês também. Vocês podem
1:04:13juntar as duas, ó. Que que ela faz? Essa
1:04:15Deud tem que provar evidência. Vamos
1:04:17ver. Ela marca as coisas como blocker,
1:04:19should fix, nich. Isso é importante
1:04:21também porque às vezes o modelo fica
1:04:22botando um monte de coisa. Ah, ela tem
1:04:24integração com git e aí tem várias e
1:04:27camadas determinísticas também para
1:04:30garantir as coisas. Então vocês podem
1:04:31pegar essa skill, eh, e olhar ela depois
1:04:34como ela funciona. E são bons padrões
1:04:36para vocês botarem no code redw de
1:04:38vocês, tá? Ó, aqui ele tá escrevendo um
1:04:41finds. Depois a gente vai ver o que que
1:04:42ele achou. Então, essa é a camada final.
1:04:44Aí, onde entra o humano? Pô, eu passei
1:04:47por todas essas camadas de review aqui.
1:04:49Ou a gente achou o o aí achou coisas. Eu
1:04:52vou aplicar essas coisas que ela achou.
1:04:53E aí eu vou dar uma olhada o que que eu
1:04:55faço normalmente eu olho as partes que
1:04:57eu sei que são críticas, tem lógica de
1:04:58negócio, decisões críticas de
1:05:00arquitetura, mas vocês vão ver na
1:05:02amanhã, no final da tarde que as coisas
1:05:05no nosso code base, pô, o meu review
1:05:07hoje em dia é muito rápido. Eh, piar de
1:05:1050, mais de 50 linhas, 10, 15 minutos eu
1:05:13já revisei ele, porque a gente tem uma
1:05:15grande automação, tá? Então, ó, ele fez
1:05:17uma revisão e disse que tá safe pr
1:05:19provar. Nesse caso aqui tem duas coisas
1:05:21que são pequenas, ó. Quantidade input
1:05:24allow zero, mas a API não não permite.
1:05:27Ah, error alert sits below the three
1:05:29forms. Não sei o que que é isso, mas
1:05:30coisa simples de front end que ele achou
1:05:32aqui, tá? Então, nesse caso, a gente tá
1:05:35safe aqui nesse nesse caso aqui. Ah,
1:05:37duas skills que eu vou vou deixar para
1:05:39vocês que eu não vou ter tempo de
1:05:41mostrar uma skill em projeto que é essa
1:05:43daqui. Outra coisa, por que que eu vou
1:05:45deixar essas skills para vocês, para
1:05:46vocês testarem? Pensa o seguinte, a
1:05:48gente falou um monte de harness, pmmd,
1:05:50skills, mas o que que a gente faz quando
1:05:52essas coisas ficam velhas? Como a gente
1:05:53sabe que não são mais necessárias? Como
1:05:55eu falei, os os o vou terminar aqui essa
1:05:58essa linha de pensamento, os modelos
1:06:00novos, eles são muito inteligentes, mas
1:06:03eles não precisam de um monte de skills
1:06:04que a gente tem mais, um monte de
1:06:05agentes. Ponmd, mas eles precisam de
1:06:07alguns. Como que a gente sabe quais são
1:06:09esses? Aí vou deixar uma skill para
1:06:10vocês darem uma olhada nisso, mas pode
1:06:12falar da M.
1:06:12>> Atendendo aos pedidos aí, não sei, não
1:06:14precisa ser agora, mas o pessoal pediu,
1:06:16falaram que tem vários JZ com attention
1:06:19spam de 3 minutos aqui, geração TikTok
1:06:21que falaram no chat que eles precisam de
1:06:24um recap rápido antes da gente do para
1:06:26almoço de tudo que foi feito. Sei se já
1:06:28tava planejado, mas se puder fazer esse
1:06:29recap pro para J, o pessoal agradece.
1:06:32>> Boa, boa. Vou d uma repassada. É, então
1:06:36vou deixar pr vocês essa skill aqui,
1:06:39nossa, para vocês validarem aqui.
1:06:41Harness e val. Essa skill vai ficar para
1:06:44vocês validarem a utilidade das coisas
1:06:47que vocês têm. Ah, meu de espant, as
1:06:50coisas estão ali todas fazem sentido,
1:06:51algumas podem ser deletadas. Tipo, ele
1:06:53tem três níveis, tá? O nível A, ele
1:06:55valida que ah, as estruturas ainda
1:06:57existem. Os comandos que ele diz aqui,
1:07:00por exemplo, os comandos que estão aqui
1:07:01nesse agents.md, eles são válidos quando
1:07:04tem comandos. Ah, se ele linka um
1:07:06arquivo, aquele arquivo ainda existe.
1:07:07Então esse é o seguro. Aí depois ele tem
1:07:09outro, dois níveis de validação mais B e
1:07:11C. Aí ele usa um sub agent, ele analisa
1:07:15as skills, ele vê se para aquele modelo
1:07:18que tá validando aquilo ali, aquela
1:07:19instrução é redundante ou não. Então
1:07:21esse é sensível ao modelo, tá? Então
1:07:23peguem, se vocês vão rodar esse, além de
1:07:25gastar tokens, rodem com os modelos que
1:07:27vocês usam no dia a dia para vocês verem
1:07:29o que que nas skills e agm de vocês tá
1:07:32começando a ficar redundante, mas vão
1:07:34tirando devagarzinho, tá? É só para dar
1:07:36uma uma ajuda para vocês. Outro que eu
1:07:38vou deixar para vocês é esse cara aqui,
1:07:40Harness Score, que é do Fernando
1:07:43Paladini da comunidade. Vou deixar o
1:07:44link aqui, já vou até mandar o link para
1:07:46vocês. Esse daqui ele valida, ele valida
1:07:49se a tua estrutura de harness está boa.
1:07:52Tu tem skills, tem guides e tal, ele
1:07:54desce em repositórios. Então comecem pro
1:07:56hardness score, depois vão pro hardness
1:07:58e para avaliar a estrutura de vocês.
1:08:00Beleza? Então pra gente finalizar esse
1:08:02bloco, recapitulação rápida. Eu vou
1:08:05deixar esse pack para vocês também. Tá
1:08:07tudos aqui no nosso aqui. Tá todas aqui,
1:08:09gente. Ã, depois ficar vai todos os
1:08:11links. Vamos lá. Eh, eu uso o cursor
1:08:14aqui, tá, galera? Recapitulação. O que
1:08:16que a gente fez? A gente começou esse
1:08:17sistema que era um RPzinho simples, tá?
1:08:20No roadmap aqui. Como é que ele tá, na
1:08:21verdade? Deixa eu ver. Vamos pegar aqui
1:08:23qual usuário e senha do admin. Eh, a
1:08:27gente pegou, fez um roadmap aqui simples
1:08:29e para cada item desse roadmap de um RP,
1:08:33fazer um house, fazer autenticação,
1:08:34autorização, job, inventário, a gente
1:08:36foi implementando seguindo algum
1:08:38approach. A gente começou sem nada, tá?
1:08:40A gente começou sem nada que foi, cadê?
1:08:42Vamos ver. É, criou o roadmap. Aí nesse
1:08:45item aqui, a gente implementou sem nada,
1:08:47só dis pra gente implementar. A gente
1:08:49entendeu que a limitação aqui é que a
1:08:50gente não sabe o que vai ser feito, a
1:08:52gente não consegue validar. Depois a
1:08:53gente foi pro próximo nível, aonde a
1:08:55gente implementou usando o plan mode,
1:08:59que já nos dá uma previsão de como as
1:09:00coisas vão ser. Depois a gente fez uma
1:09:02skill que ela cria uma spec e ela valida
1:09:05a coisa. A gente viu que, pô, agora a
1:09:07gente consegue prever o que vai
1:09:08acontecer e consegue validar o que vai
1:09:09ser feito, mas a estrutura dela era
1:09:12muito simples. Então, cadê? Se a gente
1:09:13for em spec, em docs, ó, a estrutura
1:09:16dela era simples, não cobria bastante
1:09:18coisa. E aí a gente foi para uma
1:09:19estrutura mais robusta, que é qual? Pô,
1:09:21vamos instalar Speck Driven. A gente
1:09:24instalou a skill de Speck Driven. Cadê?
1:09:26É, tá aqui, ó. Isso aí. A gente foi para
1:09:29spec Driven. A gente entendeu que, pô,
1:09:31Speck Driven dá nos dá toda essa
1:09:33estrutura. A gente tem uma uma spec, a
1:09:35gente tem um design que a gente consegue
1:09:36revisar, a gente consegue ajustar as
1:09:37coisas, a gente consegue mandar
1:09:38implementar. A gente tem um harness
1:09:41muito forte pra gente seguir passo a
1:09:43passo, tá? Pra gente seguir passo a
1:09:45passo com tescs. Só que a gente viu
1:09:47também que isso aqui tá chegando no
1:09:48limite pros modelos atuais. E aí, qual
1:09:49que é o passo depois disso? É a gente
1:09:51parar de fazer babysitting nos modelos e
1:09:54tirar o melhor deles, deixar eles
1:09:55implementar mais validar. Aí a gente
1:09:57entrou na TLC Specan que vai ser a nossa
1:10:01nova versão da skill de spec driven, tá?
1:10:04E por mais que eu esteja falando da
1:10:06skill, o que importa aqui é o fundamento
1:10:08que mudou. Pensa o que que mudou aqui.
1:10:11Em vez da gente ter uma spec, um design
1:10:14e as tesques, agora a gente tem um plano
1:10:16que envolve eh a spec e o design direto
1:10:19ao ponto. E depois a gente tem um
1:10:21checklist que um subente vai lá e roda
1:10:23contra a implementação. Ó, tá vendo? Ele
1:10:24tá fazendo isso aqui agora. Isso que é a
1:10:27coisa. Então se vocês t muita gente que
1:10:29tá aqui já é mais avançado, tem a
1:10:31própria skill da empresa e tal, que que
1:10:33vocês vão fazer com essas coisas que eu
1:10:34trouxe para vocês? Vocês vão usar isso
1:10:37como base para melhorar a estrutura de
1:10:38vocês, melhorar as skills de vocês, usar
1:10:40os fundamentos que até que a TLC Packlin
1:10:43implementa para melhorar a estrutura de
1:10:45vocês. E quando que vocês vão usar essa
1:10:47skill? Só se vocês têm acesso a modelos
1:10:49bons, tá? Porque você botar num modelo,
1:10:51tipo, bota num composer, que é um modelo
1:10:52que não segue bem regra, ele não vai
1:10:54rodar os cheques depois. Aí tu tem um
1:10:56problema, vai implementar de qualquer
1:10:57jeito, não vai rodar os cheques, tu não
1:10:58quer fazer isso, tá? Então tu tem que
1:11:00saber por quais modelos antió. Então é
1:11:02muito mais começar a pensar já no futuro
1:11:04pr onde as coisas estão indo e ajustar
1:11:06as skills de vocês. Então para resumir,
1:11:08spec driven ainda é útil, rodando com os
1:11:11modelos mais baratos, precisa de muito
1:11:13ajuste. TC Pack Lin é é o caminho para
1:11:16rodar com modelos melhores. E aí a gente
1:11:18finaliza esse bloco.

About this transcript

This page contains the full transcript of App do Zero com IA: Harness, Sub Agents, Spec-Driven, Novas Skills e Workflows by Waldemar Neto - Dev Lab, generated from the public captions YouTube serves with the video. The transcript has 15,172 words across 2,097 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to choose a caption track available on the video.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, caption language selection, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.