Episódio e59 "Vibe Code MAKE" — tutorial sobre como criar um Gem…

INEMA

assisti o video e ja passei para vcs

youtube.com/watch ↗

Hacks para Automatizar Cenários com Gemini + Make⌗

1. Prompt engineering⌗

Few-shot inteligente: sempre inclua 2–3 exemplos curtos (entrada → saída JSON) no início.
System prompt fixo: defina regras claras (“Saída apenas JSON”, “notes dentro do módulo”).
Template de prompt: crie um padrão com placeholders ({{INPUT}}, {{LANG}}, {{EXTRAS}}).
Pedir mínimo funcional: peça um blueprint simples primeiro, depois vá enriquecendo.

2. Base de conhecimento e Top Nodes⌗

Top Nodes vivo: trate como código (Git + revisão periódica).
Auto-enriquecimento: sempre que faltar módulo → criar exemplo → adicionar ao Top Nodes.
Dicionário de sinônimos: normalize nomes (ex.: “mailer” → “Gmail Send”).

3. Entrada longa (transcrições / blueprints)⌗

Chunking: divida em blocos de 3–5 min ou 3–5k tokens.
Checkpoint: valide cada parte como JSON antes de juntar.
Resumo prévio: peça um resumo técnico antes de gerar o JSON completo.

4. JSON e formatação⌗

Validador automático: use jq ou jsonlint para detectar vírgulas sobrando.
Regex para notes: mova notes para dentro do módulo se estiver fora.
Placeholders padrão: ex.: {{GMAIL_CRED}}, {{TELEGRAM_CHAT_ID}}.

5. Mapeamento lógico⌗

Loop → Router/Wait: substitua loops do N8N por waits/routers no Make.
Fallbacks: se não existe módulo, gerar HTTP + parser.
Normalização: transforme formulários proprietários em objetos de evento genéricos.

6. Testes e deploy⌗

Sandbox import: tenha um workspace de testes.
Test runner: injete dados falsos e valide saída.
Rollback: mantenha versões no Git para voltar rápido.

7. Automação do fluxo⌗

Pipeline: Input → Gem → Validar JSON → Importar no sandbox → Testar.
Notificações: erros mandados para Slack/Telegram.

8. Performance e custo⌗

Modelos diferentes: use Gemini grande só para fluxos longos; use modelos menores para ajustes.
Cache de prompts: guarde saídas repetidas e reaproveite.

9. Qualidade de saída⌗

Pós-processamento LLM: rode um modelo menor só para limpar notes.
Notes padronizadas: formato fixo: Objetivo | Inputs | Outputs.

10. Equipes e documentação⌗

README automático: sempre gerar junto um guia de uso.
Checklist humano: antes do deploy, revisar credenciais, limites e logs.

Exemplos rápidos⌗

Prompt few-shot⌗

Exemplo 1 Input: "ler inbox 24h" Exemplo 1 Output: { "modules": [ { "id": 1, "name": "Gmail Watch", "notes": "Lê e-mails da última 24h" } ] }

Correção de notes fora do módulo⌗

Antes:

"modules": [...], "notes": "Lê emails" Depois:

"m```odules": [ { "id":1, "name":"Gmail Watch", "notes":"Lê emails" } ]

```---

Checklist rápido antes de importar⌗

[ ] Arquivo salvo como .js`on
`[ ] Todos os módulos têm notes curtas e claras
[ ] Nenhuma vírgula sobrando
[ ] Credenciais apenas como placeholders
[ ] Loops convertidos para waits/routers
[ ] Testado em sandbox

Save. – Abra cada módulo e ajuste: credenciais, pastas, planilhas, prompts. – Rode em modo step-by-step, valide entradas/saídas, revise logs.

Aprimore continuamente – Se algum módulo não for reconhecido, acrescente um exemplo desse módulo ao top_nodes.json e reenvie à base de conhecimento. – Se um padrão sempre se repete (ex.: envio de resumo), crie um exemplo didático com notas excelentes e adicione à base. – Atualize as Instruções do Gem quando surgir um novo tipo de input ou regra interna da sua equipe.

Exemplos prontos de entrada

Texto simples Ler e-mails do Gmail, resumir via IA, enviar resumo no Telegram e gerar rascunho de resposta no Gmail citando os pontos principais.
Transcrição [cole aqui a transcrição completa do vídeo]. Objetivo: gerar blueprint Make equivalente ao fluxo do vídeo, com notes explicando cada etapa.
Blueprint N8N [cole aqui o JSON do N8N]. Converta para Make, usando waits/routers quando necessário, mantendo a lógica geral e adicionando notes.

Checklist de qualidade antes de importar – O arquivo termina com .json. – Todos os módulos têm notes curtas e claras. – Não há trailing comma. – Campos de credencial estão como placeholders, sem chaves reais. – Se o fluxo original tinha loop, o Make recebeu abordagem equivalente (waits/routers/aggregators). – O tamanho do JSON está dentro do limite de upload do Make.

Erros comuns e correções – Notes fora do módulo: mover o campo notes para dentro do objeto do módulo. – Módulo inexistente no Make: troque por HTTP, Iterator/Aggregator, Router ou por integração equivalente. Atualize o top_nodes.json. – A importação falha por formatação: valide o JSON em um validador online e corrija chaves/vírgulas. – Transcrição enorme corta o output: fatie a transcrição e gere em partes; depois una manualmente no editor. – Campos não mapeados: abra o módulo e mapeie manualmente a saída do passo anterior; aproveite as notes para guiar.

Perguntas rápidas com respostas – Posso usar só texto sem transcrição? Sim. Descreva claramente entradas, saídas e regras; o Gem gera o blueprint.

– Como reduzir erros de módulos não reconhecidos? Inclua esses módulos no top_nodes.json e reenvie à base de conhecimento.

– Dá para converter de Make para N8N? O fluxo deste guia é Make-first. Converter Make→N8N não está no escopo, mas você pode instruir o Gem para tentar gerar um N8N JSON análogo (resultados variam).

– Onde ficam as chaves? Nunca no JSON do blueprint. Configure as credenciais dentro do Make após importar.

– E se o Gem não adicionar notes? Reforce a regra nas Instruções e mantenha na base exemplos que já contenham notes. Se ainda falhar, adicione manualmente.

Segue o passo a passo direto para você montar o “automatizador de cenários” no Make usando Gemini, com resumo, exemplos e uma seção de perguntas rápidas no final.

Resumo rápido

Você cria um Gem no Google AI Studio.
Carrega uma base de conhecimento com blueprints funcionais do Make e um cenário Top Nodes com os módulos que você usa.
Dá ao Gem um prompt (texto), uma transcrição de vídeo ou um blueprint do N8N.
O Gem retorna um JSON de blueprint do Make com notas.
Você ajusta pequenos detalhes do JSON, importa no Make e testa.

Passo a passo

Pré-requisitos – Conta no Make. – Acesso ao Google AI Studio com Gemini 1.5/2.0 (janela de contexto grande). – Editor de texto (VS Code, Cursor, Notepad++). – 3 a 5 blueprints do Make que já funcionem, de preferência com notas nos módulos.
Prepare seus exemplos do Make – Abra cada cenário no Make e exporte como JSON. – Se ainda não houver notas, edite rapidamente e adicione uma explicação curta em cada módulo (o que entra, o que sai, por quê). – Salve como: exemplo_faturas.json, exemplo_rrss.json, exemplo_bot_telegram.json etc.
Crie o cenário Top Nodes – No Make, crie um cenário vazio só para “catálogo de módulos”. – Insira ao menos um módulo de cada integração que você usa com frequência: Gmail, Telegram, Instagram, LinkedIn, Google Drive/Docs/Sheets, Facebook, Apify, OpenAI/Gemini, Perplexity (se usar), HTTP, Routers, Aggregators/Iterators, Webhooks, Markdown, Notion, Twilio, Calendly etc. – Não precisa ligar tudo; a ideia é mostrar ao Gemini a “forma” correta de cada módulo. – Exporte este cenário como top_nodes.json.
Crie o Gem no Google AI Studio – Acesse Gems → New Gem. – Nome: Automatizador de Cenários Make. – Instruções (cole o texto abaixo e adapte termos/nomes que você usa):

Aceito três tipos de entrada:

descrição em linguagem natural do cenário desejado
transcrição de vídeo técnico
blueprint JSON do N8N Tarefa: gerar exclusivamente um blueprint JSON válido do Make, pronto para importar, mantendo a lógica, adicionando notas em cada módulo. Regras: – Se entrada for N8N, converter a estrutura para Make, substituindo constructs não existentes (ex.: loops) por equivalentes (ex.: waits/routers). – Mapear campos e conexões como placeholders e sugerir prompts nos módulos de IA. – Inserir “notes” diretamente no objeto de cada módulo. – Usar somente módulos que existam no Make; se faltar, propor alternativa comum. – Saída final: apenas JSON de blueprint do Make.

– Base de conhecimento: faça upload dos seus 3 a 5 exemplos funcionais + top_nodes.json. – Salve o Gem.

Gere seu primeiro blueprint com texto – Prompt exemplo curto: Quero um cenário que leia meus e-mails no Gmail, gere um resumo por IA e envie no Telegram. Também criar um rascunho de resposta no Gmail com base no resumo. – Cole no Gem e aguarde a saída JSON.
Gere a partir de transcrição de vídeo – Cole a transcrição completa no Gem. – Dica: se for muito longa, quebre em blocos e peça “continue do ponto X mantendo o mesmo formato de saída”.
Gere a partir de blueprint do N8N – Exporte o workflow do N8N em JSON. – Cole o JSON no Gem com a instrução: Converta este blueprint do N8N para Make. Preserve a lógica, substitua constructs incompatíveis e adicione notes em cada módulo.
Valide e ajuste o JSON antes de importar – Salve o retorno como arquivo .json. – Verifique se a propriedade notes está dentro de cada módulo. Exemplo mínimo correto:

{ "modules": [ { "id": 1, "name": "Gmail: Watch emails", "type": "gmail", "params": { "query": "in\:inbox newer_than:1d" }, "notes": "Lê e-mails recentes na caixa de entrada" } ] }

– Corrija vírgulas sobrando, chaves fechando e qualquer notes fora do objeto do módulo. – Se o Gem criou um campo separado só para notes, mova-o para dentro de cada módulo correspondente.

Importe no Make e teste – Make → Scenarios → Import blueprint → selecione seu .json →

Apresenta como construir um automatizador de cenários para Make usando Gemini (Google AI). A ideia surgiu de um desafio da comunidade para facilitar a criação e migração de automações entre N8N e Make.

Pontos principais⌗

Objetivo: Criar cenários em Make a partir de prompts, transcrições de vídeos ou blueprints do N8N.
Tecnologia usada: Gemini, devido à sua grande janela de contexto, ideal para processar blueprints extensos.
Formato: O Gemini gera o blueprint em JSON, com notas explicativas em cada módulo para facilitar a compreensão.
Importação: O JSON gerado é salvo, ajustado (para corrigir eventuais erros de formatação em “notes”) e importado no Make.

Casos de uso demonstrados⌗

Prompt simples: Criar automação que lê e-mails, resume e envia pelo Telegram, além de gerar rascunho no Gmail.
Transcrição de vídeo: A partir de um vídeo em inglês sobre automação, Gemini gera o cenário completo em Make, com pequenas falhas em módulos menos comuns.
Blueprint de N8N: Um fluxo complexo do N8N é convertido para Make, mantendo a lógica, mas exigindo ajustes (ex.: loops substituídos por waits).
Transcrição de N8N: A partir de um vídeo sobre anúncios, gera-se um cenário no Make com formulários, Drive, IA e integrações — muito próximo ao fluxo original.

Construção do Gem⌗

Criar um novo Gem em Gemini.
Inserir instruções detalhadas (explicando entradas possíveis: prompt, transcrição, blueprint, etc.).
Carregar exemplos de automações funcionais no Make com notas.
Criar um cenário “Top Nodes”, contendo todos os módulos mais usados (Gmail, Telegram, Instagram, LinkedIn, Facebook, Apify, Twilio, etc.), para evitar erros em nós não reconhecidos.
Adicionar esse cenário à base de conhecimento do Gem, garantindo que Gemini saiba como gerar os módulos corretamente.

Conclusão⌗

O método permite converter fluxos entre N8N e Make ou criar novos apenas com descrições.
Ganho enorme em velocidade de prototipagem e redução de erros.
O projeto é fruto da colaboração da comunidade e foi ajustado para ser replicável.
Reforço da importância de carregar todos os nós usados no “Top Nodes” para resultados consistentes.
O autor encerra agradecendo a José Serra pela ideia e reforça que esse tipo de desafio comunitário melhora os recursos de todos.

e59. Automatize cenários no Make com IA

🌟 Objetivo Aprender a criar seu próprio automatizador de cenários no Make utilizando inteligência artificial. Um sistema capaz de gerar automaticamente blueprints funcionais a partir de descrições, transcrições de vídeos ou até mesmo blueprints do N8N.

Nasceu de um desafio proposto pela comunidade e resolve um problema muito específico: acelerar e simplificar a criação de cenários complexos no Make sem começar do zero.

🛠️ O que conseguimos com essa automação?

Gerar cenários completos no Make a partir de prompts, transcrições ou blueprints do N8N.
Adaptar automações existentes do N8N para que funcionem no Make.
Incluir notas explicativas em cada módulo para facilitar o entendimento do fluxo.
Evitar erros frequentes na geração de nós graças ao uso de uma base de conhecimento personalizada.
Acelerar a fase de prototipagem e validação de ideias no Make.

🧩 Estrutura do fluxo automatizado

Entrada no sistema: O usuário pode inserir um prompt, uma transcrição de vídeo, um blueprint do N8N ou uma combinação deles.
Gemini como motor principal: Utiliza-se o Gemini pela sua grande janela de contexto, ideal para trabalhar com blueprints extensos do Make.
Processamento: O Gemini gera o blueprint em formato JSON, incluindo notas explicativas.
Validação e ajuste do JSON: O arquivo gerado é modificado para garantir que as "notes" estejam bem integradas (evitando erros de formato).
Importação no Make: O arquivo JSON é importado no Make para verificar seu funcionamento.
Debug e melhorias: São revisados possíveis nós não reconhecidos ou erros, que são minimizados graças à base de conhecimento.

🛠️ Ferramentas utilizadas

Gemini (via Google AI Studio)
Make
Blueprints do N8N
JSON como formato intermediário

🧠 Dicas-chave que aprendemos

A chave está no prompt: Quanto melhor você estruturar o prompt ou a transcrição, melhor será o resultado.
Inclua seus nós frequentes: Adicione todos os módulos que você usa habitualmente em um cenário “Top Notes” para que o Gemini saiba como gerá-los corretamente.
Aproveite as notas: As notas nos blueprints são fundamentais para entender e documentar o funcionamento do cenário.
Evite erros de importação: Certifique-se de que as “notes” estejam bem posicionadas no JSON. Se falharem, ajuste manualmente.
Sistema replicável: Você pode criar seu próprio Gem com essas instruções e ter seu próprio gerador personalizado para o Make.

📂 Recursos

Instruções Gem
TOP NODES
Exemplo faturas
Exemplo setter
Exemplo redes sociais (RRSS)
Exemplo bot Telegram
Exemplo Apify

Crie cenários no Make só com texto ou vídeos 🤯

Literalmente vocês vão poder gerar cenários completos no Make sem tocar em um único módulo manualmente. Nenhum. Só com texto ou com um vídeo. Sim, você leu certo.

Imagine isso: ➡️ Você dá uma ideia escrita ("quero ler meus e-mails, resumi-los e enviar pelo Telegram") ➡️ Você fornece a transcrição de um vídeo ➡️ Você passa até mesmo um blueprint do N8N

🎩 E automaticamente… pum! Se converte em um cenário funcional no Make, pronto para importar, com notas em cada módulo e perfeitamente documentado.

🧠 O que montamos exatamente? Criamos nosso próprio Gem personalizado no Gemini que é capaz de: ✅ Interpretar prompts caóticos (sim, até mal escritos) ✅ Entender transcrições de vídeos técnicos ✅ Traduzir automações completas do N8N para o Make ✅ Gerar JSON prontos para importar no Make ✅ Adicionar notas explicativas em cada módulo para que você saiba o que cada parte faz

🎯 Isso não é um simples tutorial, é uma ferramenta real que você pode replicar hoje mesmo para multiplicar sua velocidade de desenvolvimento. E o melhor: Funciona de forma brutal!

🔥 Já usamos em projetos reais:

Para construir cenários complexos a partir de vídeos do YouTube.
Para converter sistemas antigos do N8N em estruturas mais visuais com o Make.
Para compartilhar automações entre equipes sem precisar explicá-las passo a passo.
Para gerar testes rápidos quando um cliente lança uma ideia em uma chamada.

💥 Por que isso é um divisor de águas? Porque você deixa de pensar em nós e começa a pensar em lógica. O Gemini cuida do resto.

Além disso, você aprende a montar o sistema completo do zero: 📌 Como criar o Gem passo a passo 📌 Que instruções colocar 📌 Que base de conhecimento carregar 📌 Como evitar erros com nós que não reconhece 📌 E como adaptar ao que você usa (Instagram, GDocs, Telegram, etc.)

Não é magia. É IA bem aplicada. E vai te economizar horas e horas de trabalho toda semana.

💣 Não exagero ao dizer que é uma das aulas mais poderosas de todo o ano.

e59 - Vibe Code MAKE

chatgpt.com ↗