Agora o Jev decide se o Claude Code pode rodar o comando. É bizarro!

Ver no idioma original →

Autoria: Matheus Battisti - Hora de Codar · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: português

Vídeo original: Agora o Jev decide se o Claude Code pode rodar o comando. É bizarro! · Canal: Matheus Battisti - Hora de Codar · 21:55 · Assistir no YouTube

Tópicos: Agentes de IA, Automação de tarefas e workflows, Claude Code, Engenharia de prompts e contexto, Ferramentas de desenvolvimento com IA

Resumo

Matheus Battisti demonstra como usar o Jev como uma camada de decisão entre os prompts enviados ao Claude Code e sua execução. A aplicação CRIO avalia se cada pedido está claro e completo, com critérios como objetivo, local de alteração e definição de pronto, antes de permitir que o trabalho prossiga ou pedir ajustes. O vídeo mostra a criação da interface, a integração com hooks do Claude Code e a configuração do Jev por meio de uma skill e de uma chave de API. Em seguida, o apresentador testa prompts vagos e bem especificados em um projeto de loja, destacando a rapidez, o baixo custo e a possibilidade de reduzir retrabalho e uso de tokens.

Pontos-chave

• O Jev funciona como um portão de entrada que avalia os prompts antes de o Claude Code executá-los.
• A aplicação CRIO também pode interceptar comandos de terminal e alterações em arquivos, embora a demonstração se concentre na avaliação de prompts.
• Os critérios de avaliação incluem clareza do objetivo, indicação da área do projeto a alterar, definição de pronto e mistura de várias tarefas em um pedido.
• A decisão final é definida no código, usando probabilidades do Jev e um limite configurado pelo desenvolvedor.
• A integração usa hooks do Claude Code, uma skill do Jev e uma chave de API.
• Um playground permite testar e ajustar os critérios conforme o rigor necessário para cada projeto.
• Prompts vagos podem ser barrados rapidamente, enquanto pedidos mais claros podem passar ou gerar perguntas de esclarecimento.
• O apresentador usa o projeto lojinha para demonstrar a criação de relatórios e o fluxo de adição de produtos.

Capítulos

Início	Capítulo	Resumo
00:00	O Jev como filtro para prompts	O apresentador explica como o Jev pode avaliar os pedidos antes de o Claude Code começar a executá-los.
03:36	Criação da aplicação CRIO	É apresentado o projeto lojinha e começa a criação de uma interface com portões de entrada e saída para o Claude Code.
07:17	Integração com o Claude Code	A aplicação é conectada ao Claude Code por hooks, primeiro registrando os prompts e deixando as ações passarem.
09:53	Configuração do Jev e dos critérios	O apresentador instala a skill do Jev, configura a avaliação dos prompts e explica os critérios e o limite de probabilidade.
13:02	Testes com prompts vagos	O playground é usado para testar pedidos incompletos, que são barrados ou recebem apontamentos sobre o que falta esclarecer.
16:12	Testes práticos na lojinha	Prompts para criar relatórios e adicionar produtos são avaliados, executados e refinados com perguntas de esclarecimento.
20:22	Resultados e encerramento	O apresentador mostra o produto criado e encerra destacando a utilidade da integração e os próximos conteúdos sobre o Jev.

Citações

Antes da execução, consigo melhorar o prompt e ser mais assertivo nos projetos que estou criando. — 01:03

A LLM demora muito mais para avaliar um prompt do que o Jev. — 03:05

A decisão fica no código, não no Jev. — 11:27

A gente também se puxa a escrever prompts melhores. — 20:22

Conceitos e entidades

• Jev (ferramenta): IA de decisão usada para avaliar prompts e orientar se o Claude Code pode prosseguir.
• Claude Code (ferramenta): Ferramenta de programação com IA integrada à aplicação demonstrada por meio de hooks.
• CRIO (repo): Aplicação criada no vídeo para acompanhar e filtrar prompts e ações do Claude Code.
• TypeSafe (empresa): Serviço mencionado como local para criar uma conta e obter uma chave de API do Jev.
• hook (conceito): Mecanismo usado para interceptar ações do Claude Code e conectá-las à avaliação da aplicação.
• skill (conceito): Instrução instalável que ensina ao Claude Code como interagir com a API do Jev.
• lojinha (repo): Projeto de loja usado como exemplo para testar a integração e os prompts.
• prompt (conceito): Pedido enviado ao Claude Code, avaliado quanto à clareza e à completude antes da execução.

Tradução completa (pt-BR)

00:00 Galera, hoje eu quero mostrar para vocês, de forma muito detalhada, como estou usando o Jev com o Claude Code. Quando mando um prompt para criar recursos, o que pode acontecer é a funcionalidade não ser executada da forma correta por falta de informação ou porque o Claude tem alguma dúvida. Então, criei um mecanismo com o Jev entre o Claude Code e a execução, para que o nível do prompt fosse avaliado. Com isso, consigo ser mais assertivo, economizar muitos tokens e

00:32 ter meu projeto da forma que quero. Quero mostrar essa solução para vocês passo a passo, para que também possam fazer isso — não só com o Claude Code, mas com qualquer roteador que vocês desenvolvam para os seus projetos. Beleza? Então bora lá, que vou explicar a ideia e mostrar na prática. Galera, olhem só: esta animação mostra exatamente o que acontecia antes e depois da criação do CRIO, que é o projeto em que o Jev está integrado. Sem ele, qualquer prompt é executado. O Claude vai lá, lê o que quero fazer e

01:03 simplesmente executa. Agora, com esse mecanismo, consigo avaliar esse prompt praticamente em tempo real, para ver se ele é bom, se faltou alguma informação e o que posso melhorar. Assim, antes da execução — que levaria muito mais tempo do que fazer um ajuste —, consigo aprimorá-lo e ser mais assertivo nos projetos que estou criando. Então, olhem só: basicamente, pedimos alguma coisa ao Claude Code e, antes de ela ser executada, há uma espécie de portão de entrada que

01:33 vai avaliar esse pedido. Essa avaliação é feita com o Jev, né? O Jev vai intermediar tudo, e ele é uma IA de decisão. Já trouxemos o Jev aqui no canal e explicamos como ele funciona em projetos. Até recomendo que vocês assistam a esses vídeos depois, mas assistam a este primeiro, porque vocês terão uma noção melhor de como implementar o Jev. Depois, os outros vídeos vão somar ao conhecimento de vocês, para que possam usar essa IA com maestria, tá? Então, quando recebo a resposta do Jev, consigo saber se o Claude vai seguir, né?

02:04 Se vai pegar o prompt e conseguir executá-lo ou se preciso melhorar alguma coisa. Basicamente, é isso. Então, galera, estes são os critérios que o Jev vai avaliar no meu prompt, tá? Vocês podem colocar mais critérios ou menos, e isso vai formar o resultado final, porque, com base neles, o prompt será aceito ou não. Então, se fosse um prompt muito simples, o objetivo não seria claro, ele não diria onde mexer e não teria a definição do prompt, o que prejudicaria a qualidade do entendimento da IA. Mas, na maioria dos casos, ela vai fazer, porque foi programada para executar,

02:35 né? Às vezes, uma IA muito boa retorna uma resposta, né? Mas, enfim, aqui estamos trabalhando para ter a melhor solução possível. Essa é a ideia. E um prompt bem elaborado passa por tudo e simplesmente segue em frente, né? O Jev diz que está liberado e que pode seguir. Bom, talvez alguns de vocês estejam se perguntando por que não faço isso com o próprio Claude. Ele também tem a capacidade de julgar esse prompt, né? Podemos criar um hook, conectá-lo a ele e, assim, ter o critério dele para decidir se segue ou não. Bem simples. Ou eu mesmo posso perguntar. Primeiro, posso esquecer de

03:05 perguntar; segundo, a LLM demora muito mais para avaliar um prompt do que o Jev. A diferença será de alguns segundos para quase nada, e também haverá diferença no custo, né? Se eu usar uma IA boa, vou ter um impacto muito maior na minha conta de tokens do que se usar o Jev, cujo custo será ridiculamente baixo. Por isso, colocamos o Jev nessas etapas decisivas do projeto. E o prompt é uma delas, né? É uma metadecisão, por assim dizer, porque não está ligada ao projeto em si. É algo mais generalista. Posso conectar esse CRIO a qualquer projeto meu. Ele vai analisar o prompt, não

03:36 o prompt daquele projeto. Beleza? Então, bora lá fazer isso na prática. Galera, não posso deixar de falar: estou testando bastante o Jev, então uma dessas ideias que estou explicando para vocês surgiu em um desses testes e é algo que uso no meu dia a dia. Quero convidar vocês a se inscreverem para o lançamento do curso de Jev, que está chegando. Vou deixar o link no comentário fixado para que possam acessar esta página e fazer a inscrição. Quando o curso for lançado, aviso vocês por e-mail e também mando o cupom de desconto. Vou avisar aqui no canal também. Então, se não receberem o e-mail diretamente, depois vocês podem simplesmente

04:07 resgatar o cupom no e-mail quando souberem pelo canal. Mas inscrevam-se, porque é por lá que o desconto será enviado. Fechou? Então, deem uma olhada nessa página depois. Explico como vai funcionar o curso e tudo mais, mas a ideia é entender como o Jev funciona, aprender a integrá-lo, criar projetos reais e robustos e fazer deploy, né? Colocar o Jev em produção, porque também é interessante ter essa experiência. Beleza? Bora lá. Então, galera, qual é o cenário aqui? Tenho um projeto que chamei de Lojinha. Ele já está criado, e é nesse projeto que vou integrar o CRIO. Vou criar

04:37 o CRIO junto com vocês, para que vejam o passo a passo, quais seriam as etapas que também poderiam seguir e entendam a lógica dos prompts, tá? A ideia é integrar o CRIO a um projeto. Ele precisa estar sincronizado com o projeto para funcionar. Então, vou usar a Lojinha como exemplo. Vou criar o CRIO do zero. Resumi os prompts — ou melhor, reestruturei-os para ficar mais fácil de vocês entenderem. São exatamente os prompts que usei para criá-lo, mas o resultado final será o mesmo. Então, aqui

05:09 o que estou fazendo? Estou criando o projeto. Ele será basicamente um sistema web, beleza? Então, coloco aqui: o CRIO é um painel com dois portões que filtram o Claude Code enquanto ele trabalha em outro projeto. Essa é a ideia. O portão de entrada avalia cada prompt que envio antes de o Claude ler, e o portão de saída confere cada comando que ele for executar, comparando-o com as regras da casa. Esta primeira etapa é só a interface, com dados fictícios, sem IA e sem conectar nada, só para termos a estrutura básica. Aí, coloco aqui: a tela tem duas colunas lado a

05:39 lado, uma para cada portão, cada uma com um feed ao vivo e os itens mais novos no topo. Assim, ele vai mostrando os logs dos prompts que executo no Claude, para que eu possa ver como o Claude os avaliou. Mas também recebemos isso em tempo real no próprio prompt, né? Não depende só do sistema em si: ele vai funcionar junto com o prompt do projeto que está sendo desenvolvido. Aqui, galera, estou desenhando a estrutura, na parte do placar: quantos prompts passaram, quantos foram bloqueados. Isso vai ficar mais claro quando vocês tiverem a interface.

06:12 E, obviamente, já estou preparando o terreno aqui para a API do TypeSafe, que é o Jev, né? E ele vai criar. Espero que tenha dado para ler o prompt ali; se não, peçam aqui nos comentários que vejo uma maneira de deixá-lo visível. Já vamos ver o CRIO de fato, né? Enquanto isso, o que podemos fazer? Pegar a chave do TypeSafe. Como se faz isso? Vocês vão entrar no site do TypeSafe, que foi incrível com o Jev, criar a conta e receberão 5 para usar. Depois de fazer login, vão até API Keys e criam a chave. É só copiar a chave, beleza?

06:44 Vai voltar lá para a nuvem e vai colocar aqui na pasta de informações. Bom, depois disso é só fechar e, como a gente ainda não iniciou o projeto, ele já vai levar isso em consideração, tá? Não precisa se preocupar com isso. É uma coisa a menos que a gente tem que lembrar de fazer. Bom, com essa interface aqui, vai dar para ver as coisas acontecendo em tempo real, né? Só que ainda nada está conectado ao projeto. É aí que eu vou fazer hooks para criar as interligações entre as ações do Claude, tá? Eu vou

07:17 fazer isso, só vou esperar o projeto iniciar aqui para a gente poder ver. Ó, galera, ele criou o projeto aqui, tá? Então, esse início é bem simples. Vou abrir ele aqui. Pronto, está aqui o Crio. E essa é a ideia, né? A gente vai ter aqui os prompts de entrada, caso eles sejam barrados, né? E talvez também algo que comecei a implementar e gostei: comandos que não são seguros para o Claude editar, lançar, né? Por

07:49 exemplo, remover alguma coisa, né? Então, ele também pode travar nessas etapas. Mas hoje eu queria focar mais na parte de entrada, né, para dar essa ideia para vocês aqui e mostrar como o Jev pode ser útil no Claude Code. Bom, agora a gente vai fazer a interligação dos dois, tá? Ainda aqui no Crio. Então, bota aqui, ó: agora, conecte o Crio ao Claude Code de verdade, sem o app na parte da lojinha, né, que é o projeto que está ali do lado. Então, você vai conectar ao projeto XYZ que tiver. Configure os hooks do Claude só para aquele projeto. Toda

08:20 vez que eu mandar um prompt, antes de o Claude ler, o Crio recebe o prompt e responde. Antes de cada comando de terminal e de cada criação ou edição de arquivo, o Crio. Então, os dois vão trabalhar nas duas pontas, tá? Por enquanto, o Crio só registra e deixa tudo passar. Os dados de mentira somem e as colunas mostram o que chega de verdade. Então, aqui a gente já vai ver o Claude em ação, né? Ali, quando a gente estiver trabalhando em uma nova sessão naquele projeto da lojinha, tá? E depois a gente vai conectar o Jev, que é aí que a brincadeira vai começar a ficar legal. Vou esperar ele terminar aqui, ó,

08:51 galera. Daí, o que ele falou aqui, né? Ele fez as edições ali para conectar ao Claude, né? Aí a gente vai ter acesso a esse projeto em uma nova sessão, tá? Ele criou aqui em Settings, Jon, a interligação, tá? Ó, Crio, Crio, né? Beleza? Aí agora a gente precisa abrir aqui, deixar o C rodando e abrir uma nova sessão com o Claude na lojinha.

09:22 Então, é só abrir aqui o terminal e depois abrir o Claude. Aí, teoricamente, ele já vai computar qualquer prompt nosso aqui, tá? Então, por exemplo: esse projeto é sobre o quê? Aí aqui, ó, eu já tenho a entrada e a saída, tá? Aqui vai passar tudo, né? A não ser que o próprio Claude barre, né? Mas a ideia é a gente ter essa trava mais rápida e que não dependa da IA do Claude.

09:53 Então, eu tenho ali um freio antes disso, muito mais rápido e muito mais barato, tá? Por isso que a gente vai incluir o Jev nesse cenário aqui. E agora eu vou colocar o portão de entrada de fato com o Jeff, tá? A gente volta lá, vem para o Crio e coloca aqui a regra de como ele funciona utilizando o Jeff, tá? Um passo muito importante para que vocês não tenham problema nisso: vocês vão entrar aqui no TypeSafe, beleza? E, em Home, vocês têm como instalar a skill do Jeff. Isso é obrigatório para o Claude,

10:24 qualquer outro agent saber como interagir com a API, tá? Então, mais importante que a chave de API é ter essa skill. É só você copiar o prompt e mandar para o Claude. Pronto. Aí a skill vai estar instalada. É um pré-requisito que eu não tinha mencionado, mas é obrigatório. Aí a gente vem para esta parte aqui, ó: agora o JV entra no portão de entrada. A skill do Jev já está instalada no Claude Code. Então, eu já tinha, né? Vocês vão ter que instalar. Para cada prompt que chegar, envie o prompt e uma breve descrição do projeto para o Jev — uma loja de camisetas com tela de estoque, por exemplo — junto com estas perguntas, em uma única chamada: tamanho do pedido, ajuste pequeno, funcionalidade

10:56 nova ou sistema inteiro. Duas pessoas diferentes entenderiam a mesma coisa a partir desse pedido? Então, é uma pergunta que precisa ser feita para saber se o prompt está claro. Por exemplo, o pedido diz em que tela ou parte do projeto mexer? Isso também tem que estar no prompt para garantir a qualidade, né? O pedido diz como saber se ficou pronto, definindo o que ele quer no final, né? Qual é o objetivo final daquele pedido, né? Do prompt. O pedido mistura várias tarefas diferentes em um só prompt? Então, esse também é um sinal de baixa qualidade.

11:27 Então, esses são alguns dos guard rails que eu quero que o projeto de vocês tenha para ser diferente. Aí eu coloco aqui que a decisão fica no código, não no Jeff. Um critério conta como faltando quando a probabilidade ficar abaixo de 50%. O Jeff trabalha com probabilidades. Cada resposta que ele dá vem com uma probabilidade de estar certa, tá? Então, aqui eu estou trabalhando com um limite abaixo de 50%, tá? E aí explico aqui mais alguns detalhes para que ele funcione da maneira que eu quero, tá? Com base nisso, o Claude vai fazer a integração com o Jeff e alinhar as

12:00 perguntas com base no que eu defini, tá? Vai configurar tudo e agora os próximos prompts já serão adicionados ali e categorizados, né? Já estavam sendo adicionados, né? Mas ainda não eram categorizados, tá? A partir daqui, os prompts ruins já são barrados, né? E eu também pedi para ele criar uma área de teste para a gente poder testar, como um playground mesmo, né? Sem precisar colocar de fato no projeto. Então, é como se eu pudesse ver se as regras estão rígidas demais e tal, né?

12:30 Para poder ajustar isso. É importante ajustar de projeto para projeto, né? Às vezes, é um projeto em que a gente não tem tanto esse problema de algo dar errado e tal; a gente só quer testar rápido. Então, não valeria a pena ter critérios tão rígidos quanto em um projeto muito sério, que eu vou colocar no ar, tem usuários e já está rodando, né? Então, essa diferenciação também precisa ser ajustada. A gente poderia até criar um painel por projeto, seria ainda mais customizado do que o que estou mostrando aqui para vocês. Bom, aí ele terminou

13:02 aqui, tá? Ele também me deu a resposta do que testou, né? Mas a gente vai testar lá para ver. Só que isso aqui é a tradução da resposta do JV. Então, por exemplo, aqui ele deu nota 27, quer dizer que há 27% de chance de o prompt ser uma bomba. E aí a gente tem que fazer alguma alteração, tá? Passou com aviso; o Claude faz perguntas para a gente começar. Então, é isso que eu estou falando. Dependendo do que a gente mandar, ou vai ser totalmente barrado, né, ou vai ser alterado, né, reformulado, ou

13:36 vai passar ou vai pedir algum pequeno ajuste. Então, há esses critérios. Aí, se eu voltar lá, onde está a área de teste? Ó, está aqui. Então: oi, tudo bem? Sei lá, uma coisa assim, ó. Está vendo? Barrado. E isso, galera, também afeta outra parte que eu nem comentei ainda, que é, pelo menos, um problema que eu tenho. Quando mexo em vários projetos, às vezes mando um prompt para o projeto errado, né? Por desatenção. E aí perco tokens, tenho que dar rewind. Então, é um

14:06 trabalho, e ele barraria isso porque está vinculado ao projeto. Apesar de poder funcionar em qualquer projeto, ele está vinculado a um projeto, entende as regras de negócio dele e, por isso, também barra prompts que não têm nada a ver com o projeto que ele está criando, tá? Vou colocar aqui: adicione uma forma de alterar o fornecedor dos pedidos, sei lá, estou improvisando aqui, mas olha só: ele também barrou porque o prompt não diz onde mexer e tal. Então, isso me força a criar entradas melhores, tá? E aí, deixa eu mostrar o

14:39 Lojinha para vocês também. Ó, a lojinha é isso aqui, né? Uma coisa super simples, não tem nada demais, só para aplicar o conceito do Jev, né? Aí vou voltar lá no Claude Code e dizer: “Quero uma tela para poder adicionar produtos no projeto Lojinha”. Vamos ver aqui, ó. Ele vai perguntar, mas pelo menos já estou mais no caminho. Aí não diz onde mexer — ou melhor, não está tão claro, né? Disse como saber quando fica pronto,

15:09 né? Então vamos lá. Hã, estará pronto quando eu conseguir adicionar um produto via formulário, ser redirecionado à lista e o produto estiver lá, ó. Aí ele não diz onde mexer, né? Ele vai perguntar onde mexer. Ele está falando que não diz qual tela ou parte do projeto. Então aqui vou colocar: “Coloque um botão na tela inicial que leve a esta página”.

15:41 Aí ele passa, mas daí falha porque mistura várias tarefas. E aí, galera, a gente vai poder modificar justamente isso, né, para alinhar com o nosso critério aqui e ver o que faz sentido, tá? Estou só digitando prompts aleatórios para a gente poder fazer errado por causa do vídeo, mas vamos ver se já funciona de fato, né? Então vou recarregar aqui, vou voltar ali para o Claude Code, tá? Vou reiniciar a sessão. Pronto, sessão nova aqui na Lojinha. E

16:12 agora vou mandar o prompt: “Crie uma tela de relatórios na Lojinha com um link no topo da lista de produtos. Nela, quero três coisas: o total de peças em estoque, o valor total do estoque em reais e um gráfico de barras com a quantidade de peças por cor. Está pronto quando eu abrir essa tela e os números baterem com a lista de produtos”. Então vamos fazer aqui o prompt. Ele já está, ó, sendo interceptado lá. Passou com nota 78. Posso ver aqui todos os critérios, tá? E aí ele vai começar a executar. Show. Então deu tudo certo.

16:44 Agora vou esperar ele terminar aqui e vou mandar um prompt ruim. Bom, galera, o recurso foi finalizado, né? E agora vou pedir outra coisa, de uma forma malfeita, né? Então: “Coloque autenticação social no sistema”, algo assim. Então, olha só o tempo que levou para eu ser barrado, porque foi o Jev que respondeu, não o Claude Code. Se fosse o Claude Code ali, ele ia ver o projeto, ia ver se tem autenticação social, tarará, tarará.

17:14 E com isso consegui ter uma resposta muito mais barata, praticamente sem gastar tokens. E até por isso, né, esse prompt aqui não faz sentido. Então é uma trava mais para eu pensar: “Putz, mas nem nesse projeto quero mexer”, né? Se fosse esse o caso, né? Mas poderia ser outra coisa. Por exemplo, aqui vamos seguir no projeto da Lojinha, ó, que tem o relatório, né? Vamos fazer aquele de adicionar produtos, tá? Vamos ver se consigo fazer passar de primeira. “Crie um botão na home para levar o usuário a uma página de

17:46 adicionar produtos. Este botão deve seguir o mesmo padrão de layout do sistema. Está pronto quando, ao clicar, eu acessar esta página. Não precisa fazê-la completamente ainda.” Então, algo assim. Estou indo para a próxima funcionalidade. Ó, passou. Acredito que sim. Então vamos ver. O Claude Code passou, ó. Não ficou um objetivo tão claro, né? Perfeitamente claro. Mistura várias

18:17 tarefas, porque estou colocando duas coisas juntas. Até tentei isolar ali, mas ele julgou assim, né? E vamos ver aqui se ele coloca o botão. Tem o botão e eu tenho o formulário, tá? Então vamos lá. Está terminando aqui. Já vou criar o próximo prompt: “Agora crie o formulário de adição de produtos. Insira todos os campos seguindo a tabela que tem na home. Ao adicionar um produto, envie o usuário para a

18:48 home, e o produto mais novo deve estar em primeiro na tabela. Também insira no formulário validações para cada campo.” Então vou tentar fazer assim. Deixa ele terminar ali. Então ele terminou aqui, galera. Vou mandar o prompt e, aparentemente, vai passar. Deixa eu ver aqui. É, passou. Vamos ver, então. Estou mandando prompts claros, né? Bem descritos. Aqui vocês podem ver, né? Ele está

19:20 passando alguns prompts de forma automática porque detectou que isso aqui é do Claude Code, tá? O Claude Code manda esses prompts para o agent automaticamente. E aí o Jev não precisa influenciar nisso, né? Ó, aqui faltou o objetivo. Claro, ele vai perguntar alguma coisa. Vamos ver ali se deu certo. Ó, ele perguntou. Então aqui está perguntando em inglês se a gente deveria colocar instruções para mudar para português, né? Ó, perguntou sobre a ordem e o tamanho da lista. Não, a lista

19:51 do tamanho, né? E aqui outra pergunta: se o fornecedor do produto deve ser obrigatório, né? Então vejam como também para na pergunta, né? O que é bem legal, porque agora consigo ter essa modularidade, essa diferenciação de cada prompt, e não só uma aceitação por querer fazer o que preciso. Isso aqui vai ajudar a gente a economizar bastante e a ter entregas mais precisas. É muito interessante esse tipo de uso, né, com o Jev. Ó, aí ele foi lá e criou para mim,

20:22 galera. Se a gente olhar a tarefa, ela vai estar pronta aqui, né? E eu tenho validações, ó, como a gente pediu. E pronto, está aqui o meu produto, né? E até é interessante que isso nos estimula a escrever prompts melhores também, né? Falando da ferramenta em si, não tem nada a ver com o Jev, né? Mas, galera, sobre essa aplicação, era isso que eu queria mostrar. Torna o Claude Code, ou qualquer outra IA, muito mais eficiente. E agora, com esses prompts, vocês conseguem criar algo muito parecido, praticamente a custo zero, né? Porque só a gente que vai usar e tal. Então, ferramentas pessoais

20:53 tendem a consumir menos, né, nesse cenário aqui, tá? Aí, galera, não se esqueçam de se inscrever no curso de Jev, tá? Se tu gostou do que viu aqui, cara, tem muito mais. Então, o link vai estar aqui no comentário fixado para tu poder acessar essa página e se pré-inscrever para receber esse desconto especial de lançamento, tá? Vou deixar o link do Jev aqui também. Procurem os vídeos de Jev que tem aqui no canal, galera. Vou até criar uma playlist aqui, tá? São vídeos essenciais para vocês aprenderem as bases. Pretendo trazer

21:24 mais alguns conteúdos para complementar o caminho ali, vamos dizer, em ordem, né, com projetos reais e até a aplicação disso em produção, né? Isso também é um desafio e estará no curso, com certeza, bem detalhado, passo a passo, para que todos vocês consigam fazer junto comigo, tá? Então vou ficando por aqui. Espero que vocês tenham curtido. Deixem suas opiniões aí, deixem casos de uso que vocês já estão aplicando com o Jev, porque quero entender melhor como estão usando a ferramenta ou se estão só aprendendo. Deem uma olhada que

21:55 realmente vale a pena. É algo bem diferente do que a gente já tem, né? Não é uma daquelas soluções miraculosas, e sim uma nova ferramenta que vai apoiar os nossos projetos ou até o desenvolvimento deles, né? Como fiz aqui hoje para vocês. Então é isso. Um abraço, até mais. Valeu,

Transcrição original

[00:00] Galera, hoje eu quero mostrar para vocês uma das maneiras de forma muito detalhada de como eu tô utilizando o JV com cloud code. O que acontece quando eu mando promptou para criar recursos, o que pode acontecer é a funcionalidade não ser executada da forma correta por falta de informação, por o cloud ter alguma dúvida. E eu criei o mecanismo com o Jeff entre o cloud code e a execução para que fosse avaliado o nível do propt e com isso eu consigo ser mais assertivo, economizar muitos tokens e

[00:32] ter o meu projeto da forma que eu quero. Eu quero te mostrar essa solução aqui passo a passo para que tu possa fazer aí também não só cloud code, né, qualquer rotar que tu desenvolva teus projetos. Beleza? Então bora lá que eu vou explicar a tese e te mostrar na prática. Então, galera, olha só, essa animação aqui, ela mostra exatamente o que acontecia antes e depois ali do crio, que é o projeto que o JV está inserido, tá? Sem ele, qualquer prompt roda. O Cloud vai lá, lê o que eu quero fazer e

[01:03] simplesmente executa. Agora, com esse mecanismo, eu consigo ter ali uma avaliação desse prompt praticamente em tempo real para ver se ele é bom, para ver se faltou alguma informação, o que eu posso melhorar e aí eu consigo antes da execução, que levaria muito mais tempo do que fazer um ajuste, melhorar ele e ser mais assertivo nos projetos que eu tô criando. Então, olha só, basicamente o que a gente tem aqui é a gente pedindo alguma coisa pro cloud code e antes de ela ser executada, ela tem uma espécie de portão de entrada que

[01:33] vai avaliar esse pedido. Essa avaliação é feita com o JV, né? a gente vai ter o JEV ali intermediando tudo e ele é uma IA de decisão. A gente já trouxe o JEV aqui no canal e explicamos ele em projetos, como ele funciona, até inclusive recomendo que tu assista esses vídeos depois, mas assiste esse aqui primeiro que tu vai ter noções melhores de como implementar o JV e depois é que eles vão lá vão somar pro teu conhecimento para que tu possas usar essa IA com maestria, tá? Então quando eu recebo a resposta do JV ali, eu consigo saber se o Cloud vai seguir, né?

[02:04] vai pegar o prompt, vai conseguir executar ou se eu preciso melhorar alguma coisa. Basicamente é isso. Então aqui, galera, são os critérios que o JEV vai avaliar lá no meu prompt, tá? Tu pode colocar mais critérios, menos, e isso vai formar, né, o resultado final, porque baseado neles o prompt vai ser aceito ou não, tá? Então aqui se fosse um prompt muito simples, o objetivo não é claro, ele não diz onde mexer, não tem a definição de prompt e isso prejudica a qualidade ali de entendimento da IA, mas na maioria dos casos ela vai fazer porque ela é programada para executar,

[02:35] né? Às vezes uma IA muito boa retorna, né? Mas enfim, aqui a gente tá trabalhando com que eu quero ter a melhor solução possível. Essa é a ideia. E aí um prompt bem elaborado, ele passa em tudo e simplesmente segue reto, né? O Jeff diz que tá liberado, ele pode seguir. Bom, e talvez alguns de vocês devam estar se perguntando, né, porque eu não faço isso com o próprio Cláudio. Ele também tem a habilidade de julgar esse prompt, né? A gente pode fazer um hook, plugar isso nele e aí ter o critério dele se segue ou não segue, né? Bem simples. Ou eu mesmo posso perguntar. Um é que eu posso esquecer de

[03:05] perguntar e dois é que a LLM demora muito mais para avaliar um prompt do que o Jeff. Vai ter uma diferença de segundos para quase nada e também de custo, né? Se eu tiar um uma IA boa, né? vou ter muito mais impacto na minha conta de tokens do que se eu usar o JV ali, que vai ser ridiculamente baixo o custo. Então, por isso que a gente coloca ele nessas etapas decisivas do projeto. E o prompt é uma delas, né? É uma metaadecisão, vamos dizer assim, porque não tá ligada ao projeto de fato, né? Ele é mais generalista. Eu posso plugar esse crio em qualquer projeto meu. Ele vai analisar o prompt, ele não

[03:36] vai analisar o prompt daquele projeto. Beleza? Então, bora lá fazer isso na prática. Galera, não posso deixar de falar, né? Eu tô aqui testando bastante o JV, então uma essas ideias aqui que eu tô explicando para vocês saiu de um desses testes e é algo que eu tô usando no meu dia a dia. E eu quero convidar vocês a se inscreverem pro nosso lançamento do curso de JV, né, que tá chegando aí. Eu vou deixar o link aqui no comentário fixado para que tu possa acessar essa página aqui, fazer tua prescrição. Quando lançar eu te aviso via e-mail e também te mando o cupom de desconto. Vou avisar aqui no canal também, então se tu não receber o e-mail diretamente, né? Depois tu pode lá só

[04:07] resgatar o cupom no teu e-mail quanto souber aqui no canal. Mas se inscreve que é de lá que vai ser o desconto. Fechou? Então dá uma ali nessa página depois, né? Eu explico como é que vai rolar ali o o curso e tudo mais, mas é para entender como é que o J funciona e aprender a integrar ele, criar projetos reais, robustos e fazer deploy, né? Colocar o JV em produção, que também é interessante ter essa prática. Beleza? Bora lá. Então, bom, galera, aqui qual que é o cenário? Eu tenho um projeto que eu chamei de lojinha, né? Ele já tá criado aqui e é esse o projeto que eu vou plugar o crio nele, né? Eu vou criar

[04:37] o crio junto com vocês para que vocês vejam o passo a passo qual que seriam as etapas que vocês poderiam fazer aí também e entendam a lógica dos prompts, tá? Mas a ideia é que aqui a gente vai plugar o crio num projeto, né? Ele precisa estcronizado com o projeto para rodar. Então eu vou usar esse lojinha como exemplo, tá? Vou criar aqui o crio do zero. Eu, né, resumi os prompts assim, né? Eu, ou melhor, reestruturei os prompts para ficar mais fácil de vocês entenderem, né? Então foi os prompts exatamente que eu usei para criar ele, mas vai dar o mesmo resultado final, tá? Então aqui

[05:09] que eu tô fazendo? Eu tô criando o projeto, tá? Então ele vai ser aqui eh basicamente um sistema web, beleza? Então bota aqui o crio, é um painel que com dois portões que filtram o cloud code enquanto ele trabalha em outro projeto. Essa é a ideia. Portão de entrada avalia cada prop que eu mando antes do cloud ler e portão de saída confere cada comando que ele for rodar contra as regras da casa. Essa primeira etapa é só a interface com os dados de mentira, sem ai sem ligar nada, só pra gente poder ter a casca mesmo. Aí eu boto aqui a tela tem duas colunas lado a

[05:39] lado, uma para cada portão, cada uma com feed ao vivo e o mais novo em cima. Então ele vai mostrando com os log dos prompts, né, que eu vou executando no cloud para poder lá ver como que o cloud avaliou. Mas a gente recebe aqui também em tempo real no próprio prompt, né? não depende só do sistema em si, ele vai est funcionando junto com o prompt do projeto que ele tá desenvolvendo. É aqui, galera, tô desenhando a estrutura, né, na parte de placar, quantos prompts passaram, quantos prompts foram travados, isso vai ficar mais claro que

[06:12] quando tiver interface para vocês. E óbvio, já tô preparando aqui o terreno para type API aqui, que é o JV, né? E ele vai criar. Eh, espero que tenha dado para ler ler o prompt ali, senão peço aqui nos comentários, eu vejo uma maneira de deixar. a gente já vai ver o crio de fato, né? Enquanto isso, o que a gente pode fazer lá? Pegar a chave do Typeesafi como é que faz isso? Tu vai entrar no site da Type Safe, né, que é foi incrível o JV, fazer tua conta e tu vai receber ali 5 para usar. Depois do sign in, tu vai em API Kiss e cria a tua chave. Tu vai copiar a chave, beleza?

[06:44] Vai voltar lá pro cloud e vai colocar aqui na inf. Bom, depois disso é só fechar e como a gente não iniciou o projeto ainda, ele vai já levar em consideração ela, tá? Não precisa ficar preocupado com isso. É uma coisa menos que a gente tem que lembrar de fazer. Bom, com essa interface aqui vai poder ver as coisas acontecendo em tempo real, né? Só que ainda nada está conectado ao projeto. E aí que eu vou fazer hooks para poder fazer as interligações que vão entre as ações do cloud, tá? Eu vou

[07:17] fazer isso, só vou esperar o projeto iniciar aqui paraa gente poder ver. Ó, galera, ele criou o projeto aqui, tá? Então é bem simples esse início. Vou abrir ele aqui. Pronto, tá aqui o crio. E essa é a ideia, né? A gente vai ter aqui os prompts de entrada, se eles forem barrados, né? E talvez aqui também algo que eu comecei a implementar e gostei são comandos que não são seguros pro cloud editar, eh, lançar, né, por

[07:49] exemplo, remoção de alguma coisa, né? Então, ele pode travar nessas etapas também. Mas hoje eu queria focar mais na parte de entrada, né, para dar essa ideia para vocês aqui e mostrar como o JV pode ser útil no cloud Code. Bom, agora a gente vai fazer a interligação dos dois, tá? Ainda aqui no crio. Então bota aqui, ó. Agora liga o cri no cloud code de verdade sem app na parte da lojinha, né, que é o projeto que tá ali do lado. Então tu vai ligar no projeto X, YZ que tu tiver. configura os hooks do cloud só para aquele projeto. Toda

[08:20] vez que eu mandar um prompt, antes o cloud de ler, o crio, recebe o prompt e responde. Antes de cada comando terminal e de cada criação edição de arquivo, o crie. Então o vai trabalhando as duas pontas, tá? Por enquanto [limpando a garganta] o crio só registra e deixa tudo passar. Os dados de mentira somem e as colunas mostram que chega de verdade. Então aqui a gente já vai ver o cloud em ação, né? Ali quando a gente tá trabalhando uma nova sessão naquele projeto lojinha, tá? E depois a gente vai conectar o JV, que aí que a brincadeira vai começar a ficar legal. Vou esperar ele terminar aqui, ó,

[08:51] galera. Daí que que ele falou aqui, né? Ele fez as edições ali para ligar com o cloud, né? Aí a gente vai ter acesso, né, a esse projeto numa nova sessão, tá? Ele criou aqui em settings, Jon a interligação, tá? Ó, crivo, crivo, né? Beleza? Aí agora a gente precisa abrir aqui, deixar o C rodando e abrir uma nova sessão com o Cloud na lojinha.

[09:22] Então só abrir aqui o terminal e aí abrir o cloud. Aí teoricamente aqui ele já vai computar qualquer prompt nosso aqui, tá? Então, por exemplo, esse projeto é sobre o quê? Aí aqui, ó, eu já tenho a entrada e a saída, tá? Aqui vai passar tudo, né? A não ser que o cloud mesmo barre, né? Mas a ideia é a gente ter essa trava mais rápida e que não dependa da IA do Cloud.

[09:53] Então eu tenho ali um freio antes disso muito mais rápido e muito mais barato, tá? Por isso que a gente vai incluir o JEV nesse cenário aqui. E agora eu vou colocar o portão de entrada de fato com o Jeff, tá? A gente volta lá, vem pro crio e coloca aqui a regra, como ele funciona utilizando o Jeff, tá? Passo muito importante para que vocês não tenham problema nisso, vocês vão entrar no type safe aqui, beleza? E em home vocês t como instalar skill do Jeff. Isso aqui é obrigatório pro cloud,

[10:24] qualquer outra agente saber como interagir com a API, tá? Então o mais importante que a chave de API é ter essa skill. Então é só tu copiar o prompt e mandar ela pro cloud. Pronto. Aí a skill vai estar instalada. É o pré-requisito que tu não tinha falado, mas é obrigatório. Aí a gente vem para essa parte aqui, ó. Agora o JV entra no portão de entrada. Os skill do jev que já está instalado no cloud code. Então eu já tinha, né? Vocês vão ter que instalar. Para cada prompt chegar, mande pro Jeev o prompt e uma descrição curta do projeto, uma loja de camisetas com tela de estoque, por exemplo, com essas perguntas numa chamada só. Tamanho do pedido, ajuste pequeno, funcionalidade

[10:56] nova ou sistema inteiro. Duas pessoas diferentes entenderiam a mesma coisa al desse pedido? Então, uma dúvida que tem que ter para saber se o prompt é claro, por exemplo, o pedido diz em que tela ou parte do projeto mexer. Então, isso também tem que tá no prompt para ter qualidade, né? O pedido disz como saber se ficou pronto definition ofer o que que ele quer no final, né? Qual é o objetivo final daquele pedido, né? Do prompt. O pedido mistura várias tarefas diferentes no prompt só. Então esse aqui também é um sinal ruim de qualidade.

[11:27] Então esse aqui são alguns dos guard rails que eu quero que o projeto tenha de vocês para ser diferente. Aí eu boto aqui que a decisão fica no código, não no Jeff. Um critério conta como faltando quando a chance ficar abaixo de 50%. O Jeff trabalha com probabilidades. Cada resposta que ele te dá, ele te dá uma probabilidade daquela resposta estar certa, tá? Então aqui eu tô trabalhando abaixo de 50%, tá? E aí eu explico aqui mais alguns detalhes para que ele funcione da maneira que eu quero, tá? E baseado nisso, o Cloud vai fazer a integração com o Jeff, vai alinhar as

[12:00] perguntas baseado na no que eu defini, tá? Vai configurar tudo e agora os próximos prompts já estarão, né, sendo adicionados ali e categorizados, né? Adicionados já estavam, né? Mas categorizados ainda não, tá? Aí a partir daqui os promps ruins já estão barrados, né? E eu também pedi para ele criar uma área de teste pra gente poder testar, tipo um playground mesmo, né? sem precisar de fato colocar no projeto. Então, é como se eu pudesse ver se as regras estão muito rígidas e tal, né?

[12:30] Para poder alinhar isso. É importante que a gente ajuste de projeto para projeto, né? Às vezes é um projeto que a gente não tem tanto esse problema de algo acontecer meio errado e tal, a gente só quer testar rápido. Então não valeria ter critérios tão rígidos quanto num projeto que é super sério e eu vou colocar no ar e tem usuários e já tá rodando, né? Então tem essa diferenciação também que precisa ser ajustada. A gente poderia criar até um painel por projeto, seria mais customizado ainda que eu tô mostrando aqui para vocês. Bom, aí ele terminou

[13:02] aqui, tá? Ele me deu a resposta que testou também, né? Mas a gente vai testar lá para ver. Só que isso aqui é a tradução da resposta do JV. Então, por exemplo, aqui ele deu uma nota 27, quer dizer que tem 27% do prompt ser bomba. E aí a gente tem que fazer alguma alteração, tá? Eh, passou com com aviso, o Cloud faz perguntas a gente começar. Então é isso que eu tô falando. Dependendo da coisa que a gente manda, ou vai ser totalmente barrado, né, ou vai ser eh alterado, né, relapidado, ou

[13:36] vai passar ou vai pedir algum ajuste pequeno. Então tem esses critérios. Aí se eu vou lá de novo, cadê a área de teste? Ó, tá aqui. Então, oi, tudo bem? Sei lá, uma coisa assim, ó. Tá vendo? Barrado. E isso, galera, até afeta uma outra parte que eu nem comentei ainda, que pelo menos é um problema que eu tenho. Quando eu mexo em vários projetos, às vezes eu mando prompt pro projeto errado, né? Desatenção. E aí eu perco tokens, eu tenho que dar rewind. Então é um

[14:06] trabalho e ele barraria nisso porque ele tá ligado ao projeto. Apesar dele poder funcionar em qualquer projeto, ele está ligado a um projeto, ele entende a regra do negócio do projeto e isso faz com que ele barre também prompts que não tem nada a ver com o projeto que ele tá criando, tá? botar aqui, adicione uma forma de alterar o fornecedor de pedidos, sei lá, que eu tô imitando a minha cabeça, mas aí olha só, ele barrou também porque ele não diz onde mexer e tal, então me força a criar entradas melhores, tá? E aí, deixa eu mostrar o

[14:39] loginha para vocês também, ó, o loginha é isso aqui, né? Uma coisa super simples, não tem nada demais, só para te aplicar o conceito do JV, né? Aí eu vou voltar lá no cri e vou dizer: “Quero uma tela para poder adicionar produtos no projeto lojinha”. Vamos ver aqui, ó. Vai perguntar, mas pelo menos já estou mais no caminho. Aí não diz onde mexer, eh, ou melhor, não tá tão claro, né? Disse como saber que ficou que fica pronto,

[15:09] né? Então vamos lá. H, estará pronto quando eu consigo adicionar um produto via formulário e ser redirecionado à lista e o produto estar lá, ó. Aí ele não diz onde mexer, né? Ele vai perguntar onde mexer. Ele tá falando não diz qual tela o parte de projeto. Então aqui eu vou botar aqui, coloque um botão na tela inicial que leva a esta página.

[15:41] Aí, eh, ele passa, mas daí falha no mistura várias tarefas. E aí, galera, a gente vai poder modificar justamente isso, né, para poder alinhar com a nossa o nosso critério aqui e ver o que faz sentido, tá? Que eu tô só digitando promps aleatórios pra gente poder fazer errado por causa do vídeo, mas vamos ver se já funciona lá de fato, né? Então, vou recarregar aqui, vou voltar ali pro pro cloud, tá? Vou reiniciar a sessão. Pronto, sessão nova aqui na lojinha. E

[16:12] agora vou mandar o prompt. Crio uma tela de relatórios na lojinha com um link no topo da lista de produtos. Nela quero três coisas: o total de peças em estoque, o valor total do estoque em reais e um gráfico de barras quantidade de peças por cor. Está pronto? Quando eu abrir essa tela e os números se baterem com a lista de produtos, tá? Então vamos fazer aqui o prompt. Ele já tá, ó, sendo interceptado lá. Ele passou com nota 78. Posso ver tudo aqui o que tem de critério, tá? E aí ele vai começar a executar. Show. Então, deu tudo certo.

[16:44] Agora vou esperar ele terminar aqui e vou com prompt ruim. Bom, galera, aí o o recurso foi finalizado, né? E eu vou agora pedir outra coisa, uma coisa de uma forma mal feita, né? Então, ah, coloque autenticação social no sistema, algo assim. Então, olha só o tempo que levou para eu ser barrado, porque foi o Jeff que respondeu, não o Clud. Se fosse o Cloud ali, ele ia ver o projeto, ia ver se tem uma autenticação social, tarará, tarará.

[17:14] E com isso eu consegui ter uma resposta muito mais barata sem praticamente gastar token. E até por isso, né, o prompt aqui não faz sentido. Então é uma trava mais para mim tentar, putz, mas nem esse projeto quero mexer, né? Se fosse esse o caso, né? Mas poderia ser outra coisa. Por exemplo, aqui vamos seguir no projeto da lojinha, ó, que tem o relatório, né? Vamos fazer aquele lá de adicionar produtos, tá? Vamos ver se consigo fazer passar aqui da de primeira. Crie um botão na home para levar o usuário a uma página de

[17:46] adicionar produtos. Este botão deve ter o mesmo padrão de layout do sistema e está pronto quando eu ao clicar acessar esta página. Não precisa fazer ela completamente ainda. Então algo assim. Tô indo pra próxima funcionalidade. Ó, ele passou. Eu acredito que sim. Então vamos lá ver. O crio passou, ó. Não ficou um objetivo tão claro, né? Perfeitamente. Claro. Mistura várias

[18:17] tarefas porque eu tô colocando duas coisas juntas. Até tentei isolar ali, mas ele julgou assim, né? E vamos ver aqui se ele bota o botão. Tem o botão e eu tenho formulário, tá? Então vamos lá. Tá terminando aqui. Eu já vou criar o próximo prompt. Agora crie o formulário de adição de produtos. Insira todos os campos seguindo a tabela tem na home. Ao adicionar um produto, envie o usuário na

[18:48] home e o produto mais novo deve estar em primeiro na tabela. Também insira no forme validações para cada campo. Então vou tentar fazer assim. Deixa ele terminar ali. Então ele terminou aqui, galera. Vou mandar o prompt e aqui aparentemente vai passar. Deixa eu ver aqui. É, passou. Vamos lá ver então que eu tô mandando prompt. Claro, né? Bem descritos. Aqui vocês podem ver, né? Ele tá

[19:20] passando alguns prompts de forma automática porque ele detectou que isso aqui é do cloud, tá? O cloud manda esses prompts eh pro agente automaticamente. E aí o JV não precisa influenciar nisso, né? Ó, aqui faltou o objetivo. Claro, ele vai perguntar alguma coisa. Vamos ver ali se deu certo. Ó, ele perguntou. Então aqui ele tá perguntando em inglês se a gente deveria colocar instruções para mudar português, né? Ó, perguntou da ordem, tamanho da lista, não, a lista

[19:51] do tamanho, né? E aqui outra pergunta, se o fornecedor deve ser required, né? Fornecedor do produto. Então, vejam como também trava na pergunta, né? que é bem legal, porque eu consigo agora ter essa modularidade, né, essa diferenciação de cada prompt e não só uma aceitação por a querer fazer o que eu preciso. Isso aqui vai ajudar a gente economizar bastante, a ter as entregas mais precisas. É muito interessante esse tipo de uso, né, com o Jeff. Ó, aí ele foi lá, criou para mim,

[20:22] galera. Se a gente for ver a tarefa, a gente vai ter ela aqui pronta, né? E eu tenho validações, ó, como a gente pediu. E pronto, tá aqui o meu produto, né? E até interessante que a gente se puxa a escrever prompt melhores também, né? Falando da ferramenta em si, não nada a ver com o Jav, né? Mas galera, sobre essa aplicação, é isso que queria mostrar. Torna o cloud code, qualquer outra IA muito mais eficiente. E vocês agora com esses prometos conseguem criar algo muito parecido a praticamente custo zero, né? Porque só a gente que vai usar e tal. Então, ferramentas pessoais

[20:53] tendem a consumir menos, né, nesse cenário aqui, tá? Aí galera, não esqueçam de se inscreverem pro curso de JV, tá? Se tu gostou do que tu viu aqui, cara, tem muito mais. Então, o link vai tá aqui no comentário fixado para tu poder acessar esse essa página aqui e se pré-inscrever para receber esse desconto especial de lançamento, tá? Vou deixar o link do JV aqui também. Eh, procurem os vídeos de Jev que tem aqui no canal, galera. Vou até criar uma playlist aqui, tá? Eh, são vídeos essenciais para vocês aprenderem as bases. Eu pretendo trazer

[21:24] mais alguns conteúdos aí para complementar mais eh o caminho ali, vamos dizer em ordem, né, com projetos reais e até a aplicação disso em produção, né, que é um desafio também, estará no curso com certeza bem detalhado, passo a passo para que todos vocês consigam fazer junto comigo, tá? Então vou ficando por aqui. Espero que vocês tenham curtido. Deixem suas opiniões aí, deixem casos de uso que vocês estão aí já aplicando com o Jeff, que eu quero entender melhor como se estão usando a ferramenta ou se vocês estão só aprendendo. Deem uma olhada que

[21:55] realmente vale a pena. É algo que é bem diferente do que a gente já tem, né? Não é aquelas soluções miraculosas e sim uma nova ferramenta que vai apoiar os nossos projetos ou até o desenvolvimento dos mesmos, né? Como eu fiz aqui hoje para vocês. Então é isso, um abraço, até mais. Valeu,