Como acompanho as novidades de IA sem me afogar nelas (skill grátis)

Ver no idioma original →

Autoria: Cole Medin · 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: inglês

Vídeo original: How I Keep Up with AI Without Drowning in It (Free Skill) · Canal: Cole Medin · 13:45 · Assistir no YouTube

Tópicos: Agentes de IA, Automação de tarefas e workflows, Engenharia de prompts e contexto, RAG, busca e recuperação de informação

Resumo

Cole Medin apresenta seu AI content engine, um sistema que acompanha centenas de fontes e filtra as novidades de IA de acordo com seus interesses para gerar um resumo diário conciso. Ele explica a coleta de dados, a deduplicação e os filtros determinísticos antes de encaminhar itens selecionados para Jev e um LLM. Em seguida, demonstra como a skill Build Signal Engine entrevista o usuário e constrói um sistema personalizado em etapas, com testes e espaço para ajustes. O objetivo é reduzir o tempo gasto acompanhando notícias e destacar apenas informações relevantes para cada pessoa.

Pontos-chave

• O sistema acompanha fontes como Reddit, YouTube, RSS, Hacker News, repositórios do GitHub e changelogs.
• Uma configuração central em JSON facilita gerenciar e ampliar as fontes monitoradas.
• A deduplicação e os filtros determinísticos removem itens repetidos, antigos ou com pouco engajamento antes do uso de modelos.
• Jev atua como primeira camada de triagem, encaminhando ao LLM os itens que exigem análise mais cuidadosa.
• O sistema avalia se cada publicação é relevante, se Cole se interessaria por ela e se traz algo novo e concreto.
• Apify é apresentado como uma opção para conectar agents a diversas fontes e obter conteúdo em Markdown.
• A skill personaliza o sistema por meio de uma entrevista sobre interesses, fontes e métodos de coleta.
• A implementação é dividida em seis etapas, com testes ao longo do processo, e gera um perfil que pode ser ajustado depois.

Capítulos

Início	Capítulo	Resumo
00:00	O desafio de acompanhar as novidades de IA	Cole Medin apresenta o problema do excesso de lançamentos e explica como seu AI content engine seleciona as novidades que lhe interessam.
02:37	Fontes, coleta e filtros iniciais	O sistema reúne conteúdo de várias plataformas, elimina duplicatas e aplica filtros determinísticos antes de usar modelos.
05:15	Triagem com Jev e análise por LLM	Jev descarta ou aprova itens evidentes, enquanto os casos mais sutis seguem para um LLM, com critérios de relevância e controle de custos.
09:29	Instalação e personalização da skill	O autor mostra como iniciar Build Signal Engine e responder à entrevista que define fontes, interesses e requisitos do sistema.
11:40	Construção em etapas e ajustes	A skill implementa e testa o sistema em seis etapas, gera um perfil de configuração e permite iterar com o agent.

Citações

Como acompanhamos tudo isso? E como descobrimos o que é só espuma e o que realmente vale nosso tempo? — 00:00

É só o que me interessa. — 01:02

Antes de usar qualquer modelo, queremos fazer o máximo possível de filtragem determinística e deduplicação. — 04:12

Invista tempo nisso no começo, porque assim ele consegue avançar rapidamente por toda a implementação. — 11:40

Conceitos e entidades

• AI content engine (conceito): Sistema que coleta e filtra conteúdo de várias fontes para produzir um resumo diário personalizado.
• Build Signal Engine (ferramenta): Skill que entrevista o usuário e orienta um coding agent na criação de um AI content engine personalizado.
• Jev (ferramenta): Ferramenta usada como primeira camada de triagem para descartar itens óbvios ou selecionar aqueles que precisam de análise adicional.
• Apify (empresa): Plataforma citada para conectar agents a fontes como YouTube e Reddit e retornar conteúdo em Markdown.
• Claude Code (ferramenta): Coding agent para o qual o autor disponibiliza um plugin para instalar a skill.
• Hacker News (ferramenta): Fonte de notícias e publicações que o sistema pode acompanhar e filtrar.
• RSS (conceito): Formato de feed que pode ser incluído entre as fontes monitoradas pelo sistema.
• LLM (conceito): Modelo usado após a triagem inicial para analisar itens mais ambíguos e preparar o conteúdo do resumo.

Tradução completa (pt-BR)

00:00 Se você nunca se sentiu sobrecarregado com todas as notícias do universo da IA, então deveria criar seu próprio canal no YouTube e nos ensinar como você faz isso. Porque posso garantir que não é o caso. Pelo menos em alguns momentos, talvez até agora, você está se sentindo sobrecarregado com a enxurrada de novos modelos e lançamentos de produtos, tweets virais e repos do GitHub que precisa conferir. Quer dizer, toda semana parece que surgem várias coisas que mudam tudo. E isso acaba sendo esmagador. E a grande pergunta que precisamos fazer a nós mesmos é: como acompanhamos tudo isso? E como descobrimos o que é bobagem e o que realmente vale nosso tempo para investigar

00:31 e talvez incorporar ao nosso próprio trabalho? Essa é a grande pergunta que venho respondendo para mim mesmo ao longo deste ano, criando o que chamo de meu mecanismo de conteúdo de IA dentro do meu segundo cérebro. Neste vídeo, vou mostrar como esse sistema funciona e, melhor ainda, como você pode criá-lo por conta própria com bastante facilidade, usando uma skill que preparei para você. Estou animado com isso porque esse sistema é um salva-vidas para mim. Ele acompanha centenas de fontes em meu nome. E, entre todos os anúncios, posts de blog e artigos — tudo o que passa pelo sistema —, filtra o conteúdo com base no que sabe que me interessa

01:02 no meu conteúdo. Então, tudo o que recebo todos os dias é um resumo diário conciso e fácil de ler, que cobre tudo com que eu deveria me importar. Ele não me ajuda a acompanhar todas as notícias sobre IA, porque mesmo um resumo disso seria muita coisa para ler. Ele traz apenas as coisas que me interessam. E, com o tempo, deixei esse sistema muito preciso. Esse filtro realmente elimina a bobagem para mim e me ajuda a focar no que vai melhorar meu conteúdo, meus workflows de programação com IA e as coisas que são pessoais. No meu principal repo de skills no GitHub, temos a skill de hoje, Build Signal Engine, Signal Content. Eu chamo meu sistema de…

01:35 Esse workflow orienta seu coding agent na criação exatamente do mesmo sistema que me poupa horas e horas por semana de acompanhar todas as notícias sobre IA. E a razão de eu ter criado uma skill, em vez de simplesmente entregar o sistema como um repo open source para você configurar de imediato, é que quero que você consiga personalizar as coisas enquanto o constrói do zero. Então, logo no início do processo, ele faz várias perguntas. Descobre quais fontes você quer acompanhar, como quer buscá-las, que tipo de filtragem quer fazer — ou seja, o que realmente importa para você — e então

02:05 constrói o sistema. Mas o valor dessa skill está em todas as melhores práticas que aprendi, nas lições que aprendi do jeito mais difícil e nos refinamentos que fiz ao usar meu mecanismo de conteúdo por mais de seis meses. Tudo isso está integrado a essa skill. Mas, antes de passarmos por essa skill juntos, quero mostrar como o sistema funciona, porque acredito firmemente que, para qualquer coisa que configuramos ou executamos por conta própria, devemos realmente entender como funciona. Então, a primeira coisa que precisamos descobrir, antes de configurar qualquer filtragem ou ensinar ao sistema com o que nos importamos, é como construir a camada de dados: as conexões com as diferentes plataformas e o que vamos buscar para incluir no mecanismo de conteúdo

02:37 em primeiro lugar. Todos os dias, busco conteúdo de muitas fontes: Reddit, YouTube, feeds RSS, Hacker News, repos do GitHub e registros de alterações das minhas plataformas favoritas, como Cloud Code. Todos os dias, envio centenas de posts para o meu mecanismo de conteúdo, mas ele também consegue processar tudo muito, muito rápido. São muitas fontes, mas deixei o sistema muito eficiente. E, claro, a skill também vai ajudar você a construir essa parte. A skill vai perguntar a quais fontes diferentes você quer se conectar e também como quer fazer isso. Porque, para cada plataforma, há muitas maneiras diferentes

03:11 de se conectar: diretamente por uma API, por uma ferramenta CLI ou por um servidor MCP. Já fiz bastante disso para, sabe, GitHub, archive e Hacker News. Mas algo que comecei a usar recentemente é o Appify. É uma única plataforma que me permite conectar com muita facilidade meus agents a milhares de fontes diferentes, como YouTube e Reddit. Também fontes do tipo cujas APIs costumam ser mais restritas. Então, de novo, você não precisa usar as mesmas soluções que eu uso, mas elas estão funcionando muito bem para o meu mecanismo de conteúdo, e a skill vai ajudar você a personalizá-lo. Assim, você define

03:41 sua camada de dados e a que fontes quer se conectar. Depois, passamos ao restante do processo, em que configuramos a filtragem e chegamos ao resumo diário. A primeira coisa que fazemos ao executar o mecanismo de conteúdo é buscar todas as nossas fontes. Eu executo meu mecanismo de conteúdo todos os dias. Mas a primeira coisa que precisamos fazer, antes de qualquer processamento ou filtragem, é remover duplicatas. Ou seja, armazenar tudo em um banco de dados central e acompanhar os anúncios, posts de blog e outras coisas que já vimos. Porque não queremos que Jev e nosso LLM processem o mesmo post de blog, anúncio ou qualquer outra coisa duas vezes.

04:12 Isso seria apenas um desperdício dos nossos tokens. Então, antes de usar qualquer modelo, queremos fazer o máximo possível de filtragem determinística e remoção de duplicatas. Isso é parte do que torna esse sistema todo muito rápido e eficiente no uso de tokens. Então, removemos as duplicatas. Também incluí alguns filtros de código, alguns filtros determinísticos. Se houver posts muito antigos, que provavelmente já estão desatualizados, simplesmente os descarto logo de cara. Ou, se um post tiver pouco engajamento. Por exemplo, se for um artigo do Hacker News ou um vídeo do YouTube que encontrei e que tenha apenas algumas centenas de visualizações. Quer dizer, talvez seja uma boa informação, mas uma boa regra geral que percebi é que, geralmente, posso passar adiante.

04:43 Assim, consigo verificar isso antes de usar meus tokens para determinar se o conteúdo é importante para mim. Então, tudo o que passa pelos filtros determinísticos e pela remoção de duplicatas é enviado para a primeira chamada de modelo, usando Jev. Falei sobre isso no meu último vídeo, Casos de uso do Jev no Second Brain. Vou colocar o link aqui. Mas adoro usar Jev como primeira linha de defesa para os modelos fazerem a filtragem

05:15 Então, Jev não existe há muito tempo. Antes de Jev, eu usava LLMs para filtrar tudo. Mas isso significava fazer uma chamada ao LLM para cada fonte que passava pelas primeiras etapas. E você pode usar um modelo mais barato para isso. Como o Haiku; especialmente com o novo Haiku 5.5, você consegue bastante capacidade de raciocínio por um preço muito baixo. Mas ainda assim, não quero usar um LLM mais do que for possível evitar. Por isso uso Jev como primeira linha de defesa. Eu experimentei uma versão deste

05:46 sistema em que não usava nenhum LLM e Jev era a última linha de defesa. Na verdade, minha precisão caiu bastante. Muitas coisas que não me interessavam passaram pelo filtro, e muitas coisas que me interessavam foram filtradas, mas descobri que este é o ponto ideal. Então, uso Jev para tomar as decisões mais óbvias. Qualquer coisa que seja claramente bobagem ou claramente algo que me interessa, ele decide primeiro, certo? Então, se for algo como: “Sim, definitivamente devemos descartar isto”, o processo termina e nunca preciso fazer uma chamada ao LLM. Mas, para qualquer coisa sobre a qual ele não tenha certeza ou…

06:17 sabe que definitivamente preciso manter, é quando enviamos isso para um LLM para deixar tudo pronto para o resumo e fazer qualquer filtragem adicional de que eu precise. E, para dar alguns números concretos, nesta execução que fiz com 864 publicações, custou apenas 3 centavos por todas as chamadas que fiz ao Jev; depois, para o que passou pelo filtro e chegou ao Claude Haiku, custou apenas 42 centavos. Então, fica abaixo de meio dólar por dia. Nada mal pelo tempo que isso me economiza; definitivamente vale a pena. Agora, obviamente, o preço para você vai

06:48 mudar dependendo de quantas fontes você consulta e de quanto texto recebe de cada fonte. E também há algo a que você deve prestar bastante atenção: para cada fonte que consulta, em geral, não convém simplesmente despejar a saída bruta da chamada ao servidor MCP ou à API no Jev ou no seu LLM. Quase sempre há coisas que você pode remover de forma determinística, como cabeçalhos e rodapés, espaços extras e outros elementos de que o agent realmente não precisa. Essa é uma das razões pelas quais gosto de usar o Apify, porque, em todas as execuções que tenho aqui, enquanto coleta dados das minhas diferentes fontes, ele retorna automaticamente markdown otimizado para o agent, com apenas as

07:21 informações de que ele precisa. Então, usando algo como o Apify, você precisa se preocupar menos com isso; mas, se tiver uma configuração personalizada, lembre-se de que é muito importante definir isso desde o início. E, claro, essa é uma das coisas com que minha skill ajuda você. Também montei esta pequena demonstração para deixar tudo bem concreto. Este não é meu mecanismo de conteúdo completo. Ele apenas consulta alguns subreddits, mas é uma boa visualização para ver como é filtrar algumas coisas com o Jev e enviar outras para o LLM. Para cada fonte que chega ao Jev, ele vai avaliar três

07:55 critérios. Isso também está integrado à skill. Ela vai determinar: isto é relevante para o tema? É algo com que Cole se importaria? É realmente novo e concreto ou é só uma demonstração de brincadeira? Uma coisa que encontro bastante em posts de blog e, especialmente, em subreddits é que as pessoas só compartilham pequenas coisas que criaram para tentar comparar modelos, e isso não me interessa muito. Essa é uma das lições que aprendi: vejo muitas dessas demonstrações de brincadeira, como gosto de chamá-las, e quero filtrá-las logo de cara. Então, qualquer coisa que receba uma pontuação razoavelmente alta nisso, como 0,7, vou simplesmente

08:25 filtrar. Vou descartar. Não vou enviar isso para o LLM. E há algumas coisas que são óbvias o bastante, como: isto é tão bom. Por exemplo, o anúncio do Sonnet 5.5 ou o lançamento da versão 1.0 oficial do Pi. Sim, definitivamente quero manter isso. Nem preciso do LLM para decidir. E há outras coisas mais sutis, em que talvez eu queira que o LLM consulte um pouco mais meu sistema de memória, porque o Jev não consegue fazer isso muito bem. Nesses casos, envio o conteúdo ao LLM para que ele analise melhor e decida se devo mesmo mantê-lo. O sistema continua leve. Ainda vai ser barato quando

08:56 chegar ao LLM, só não tão barato. E, para cada uma dessas fontes que quero incluir no mecanismo de conteúdo, gerencio tudo com um único arquivo JSON de configuração. Não poderia ser mais fácil gerenciar e ampliar isso. Aqui estão todos os feeds RSS que quero acompanhar, todos os novos posts de blog desses sites, canais do YouTube, repositórios do GitHub, as categorias de artigos de pesquisa do arXiv; para o Appify, tenho as pesquisas que quero executar sempre no Reddit, na busca na web e no YouTube. Assim, também capturo coisas mais gerais, além dos canais individuais. Tudo

09:29 isso junto me dá a sensação de que tenho uma visão realmente ampla e abrangente de toda a internet à medida que surgem novidades. Ótimo. Agora que você entende o sistema em linhas gerais, podemos começar a usar a skill para criar seu próprio mecanismo pessoal de conteúdo. Vou mostrar como começar, porque a skill realmente acompanha você durante todo o processo. A maneira mais fácil de instalar essa skill é seguir as instruções no README do meu repositório de skills. Vou deixar o link na descrição. Se você estiver usando o Claude Code, tenho um plugin do Claude Code que torna muito fácil integrar isso ao seu sistema.

10:00 E, se estiver usando outro coding agent, você pode simplesmente indicar a URL desse repositório e pedir que ele configure as skills, ou apenas baixar a skill específica que estamos usando agora. Depois de configurar tudo, recomendo executar a skill em um repo novo, em uma pasta nova e vazia onde você queira criar o mecanismo de conteúdo. Opcionalmente, você pode especificar o caminho para um repo separado. Por exemplo, se estiver criando isso no seu segundo cérebro, mas quiser que seja criado em outro lugar. Só queria deixar essa opção disponível, mas, em geral, ao criar isso, basta executar /build signal engine e pronto. Você nem

10:34 precisa especificar nenhum argumento. Vou enviar o comando e, como mencionei antes, a primeira coisa que ela vai fazer é bombardeá-lo com várias perguntas para personalizar tudo para você. Ela começa perguntando onde devemos criar isso. Por padrão, vai recomendar o local em que estamos. Vou escolher essa opção, porque criei uma pasta nova para isso. Em seguida, vai começar a perguntar do que você realmente precisa se manter atualizado, certo? São perguntas mais gerais, para que ela possa até recomendar diferentes fontes. Então, quero acompanhar ferramentas de IA que uso, por exemplo, ou talvez você queira acompanhar plataformas específicas que quer destacar. A maneira de responder a essas perguntas e se comunicar com ela fica totalmente a seu critério.

11:07 Conte-me sobre algo nas suas ferramentas de IA que você descobriu tarde ou deixou passar completamente. Certo? Qual é, em termos mais específicos, o problema que estamos tentando resolver? Talvez seja algo como descobrir mais tarde uma informação no registro de alterações que gostaríamos de ter conhecido uma semana antes, ou ficar sabendo por um vídeo do YouTube. Algo como: “Poxa, isso foi lançado há alguns dias e só fiquei sabendo por este vídeo do YouTube. Queria muito ter descoberto logo que saiu.” Depois, ela entra em mais detalhes sobre as fontes e tudo mais. Não vou responder a todas as perguntas aqui, porque quero que você personalize as respostas de acordo com o que é importante para você, mas vou mostrar o resultado final. Então, eu

11:40 já passei por esse processo e respondi a todas as perguntas. Ela realmente faz muitas perguntas. É preciso ter um pouco de paciência, mas recomendo investir tempo nisso desde o início, porque assim ela consegue executar toda a implementação rapidamente. Você passa, digamos, de 10 a 15 minutos respondendo às perguntas dela; depois, ela constrói tudo e faz isso em etapas, de modo que o resultado seja bem abrangente, e até testa coisas para o seu mecanismo pessoal enquanto o constrói. Voltando ao diagrama, depois da entrevista, a skill vai percorrer autonomamente um processo de seis etapas para construir

12:12 tudo. Então, não estamos tentando fazer tudo de uma só vez. Estamos dividindo o trabalho em partes menores, e ele vai testar cada uma delas. Com certeza, daria muito errado se tentasse fazer tudo de uma só vez. Então, começa de forma bem simples: uma única fonte, que você definiu na entrevista, construída de ponta a ponta e testada. Depois, passa a construir todas as outras fontes, estabelecendo completamente essa camada de dados e fazendo isso de acordo com as plataformas e os métodos que você especificou. No meu caso, por exemplo, nesta demonstração, eu disse que queria usar Appify para tudo, então

12:43 é com isso que ele vai se integrar enquanto constrói a camada de dados. Mas, seja o que for que você tenha decidido, sejam quais forem as personalizações que tiver, ele vai trabalhar com isso. Se quiser usar APIs diretamente, por exemplo, ele vai construir essa parte e, em seguida, vai criar os filtros de código, os determinísticos, e testá-los; vai criar as etapas de decisão com Jev e o LLM, definir o formato do resumo e também ajudar você a configurar a frequência com que quer executar isso. E tudo isso junto vai fazer esse trabalho rapidinho. Então, se voltarmos à minha conversa e formos até o final, pronto: temos o mecanismo completo construído. Talvez não fique perfeito logo de cara, então você

13:14 com certeza pode iterar com o agent aqui, mas ele será um ótimo ponto de partida. Outra coisa que incluí na skill é a geração de um perfil ao final. Assim, você tem uma visão rápida das fontes que está usando, dos filtros e das perguntas de decisão que definiu. Se alguma coisa não parecer perfeita ou exatamente como você quer, basta ajustá-la e depois pedir ao agent que a analise e dizer algo como: “Olha, aqui está um novo perfil. Quero que você implemente as diferenças.” E essa é uma forma de ajustar as coisas continuamente. Então, lembre-se: o mecanismo de conteúdo não lê esse perfil toda vez que é executado, mas, quando quiser mudar

13:45 alguma coisa, basta atualizá-lo aqui em linguagem natural e depois pedir ao agent que implemente essas mudanças. Pronto. É assim que meu mecanismo de conteúdo funciona e é assim que você pode construí-lo por conta própria com a skill. E, mesmo que você não o construa do zero aqui e só queira aproveitar algumas ideias valiosas deste vídeo e incorporá-las ao seu próprio processo, espero que isso seja realmente útil. E, se você gostou deste vídeo e está esperando mais conteúdo sobre programação agêntica e sobre como construir seu segundo cérebro, eu agradeceria muito se deixasse um like e se inscrevesse no canal. E, com isso, nos vemos no próximo vídeo.

Transcrição original

[00:00] If you’ve never felt overwhelmed with all the news in the AI space, then you should just go start your own YouTube channel and teach us your ways. Cuz I can guarantee that’s not the case. At least some of the time, maybe even right now, you’re feeling overwhelmed with the onslaught of new models and product releases, viral tweets, and GitHub repositories that you have to check out. I mean, every single week it feels like there are multiple things that come out that change everything. And so it becomes overwhelming. And the big question we have to ask ourselves is, how do we keep up with it all? And how do we figure out what’s fluff versus what is actually worth our time looking

[00:31] into and maybe incorporating for ourselves. And that’s the big question I’ve been answering for myself this entire year, building what I call my AI content engine within my second brain. And so in this video, I’ll show you how this whole system works and even better, how you can build it yourself pretty easily using a skill that I have for you. And I’m excited for this because this system is a lifesaver for me. It tracks hundreds of sources on my behalf. And then for all of the announcements and blog posts and articles, everything that goes through the system, it filters based on what it knows I care about in

[01:02] my content. So all I get every single day is a concise and easy-to-read daily digest that covers everything I should care about. So it’s not helping me track all the AI news, because even for a digest, that would be a lot to read. But it’s just the things that I care about. And I’ve made this system very accurate over time. So this filter truly is taking out the fluff for me and helping me hone in on what’s going to make my content better, my AI coding workflows better, just the things that are personal. So within my main skills GitHub repository, I have our skill for today, build signal engine, signal

[01:35] content. I call my system either. This workflow guides your coding agent through building the exact same system that I have that’s saving me hours and hours a week of going through all the AI news. And the reason why I have a skill instead of just giving you the system as an open-source repo you set up right away, is I want you to be able to customize things as you build it from the ground up. And so as a part of this process at the very beginning, it grills you. It figures out what sources you want to track, how you want to fetch them, the filtering you want to do, like what you actually care about, and then

[02:05] it builds the system. But, the value in this skill is that all of the best practices I’ve learned, you know, lessons I’ve learned the hard way, refinements that I’ve made as I’ve been using my content engine for over 6 months now, that is all built into this skill. But, before we go through this skill together, I want to show you how the system works, because I’m a firm believer for anything we set up or run ourselves, we should truly understand how it’s working. So, the first thing we have to figure out before we set up any of the filtering or teaching of what we care about, is we need to build the data layer, the connections to the different platforms, and figuring out what we’re

[02:37] going to pull into the content engine in the first place. There are so many sources that I’m pulling in every single day. Reddit, YouTube, RSS feeds, Hacker News, GitHub repositories, change logs from my favorite platforms like Cloud Code. There are hundreds of posts that I’m feeding into my content engine every day, but it’s also able to work through everything very, very quickly. So, a ton of sources, but I made it very efficient. And of course, that’s part of what the skill will help you build as well. So, the skill is going to ask you the different sources you want to connect to, and then also how you want to do so. Because for every single platform, there are many different ways

[03:11] we can connect, directly with an API or a CLI tool or MCP server. And so, I’ve done a lot of that for, you know, like GitHub and archive and Hacker News. But, something that I’ve started to use recently is Appify. It is a single platform that allows me to very easily connect my agents to thousands of different sources, like YouTube and Reddit. Also, the kinds of things where usually the APIs are more restricted. And so, again, it’s not like you have to use the same solutions that I’m using, but this is what’s working really well for my content engine, and the skill will help you customize. So, you figure

[03:41] out your data layer and what you want to connect to, and then we move on to the rest of the process where we’re actually setting up the filtering and getting to that daily digest. So, first thing we do when we run the content engine is we pull all of our sources. And I run my content engine every single day. But, the very first thing we have to do before we do any kind of processing or filtering is deduplicate. So, storing everything in a central database and keeping track of the announcements and blog posts and things that we have already seen. Because we don’t want to have Jev and our large language model

[04:12] process the same blog post or announcement or whatever twice. Cuz that’s just a waste of our tokens. And so, before we get into any of the model usage, we want to do a deterministic filtering and deduplicating as much as we possibly can. It’s part of what makes this whole system very fast and token efficient. And so, we deduplicate. And then I also have some code filters, some deterministic filters that I’ve built in. And so, if there are really old posts that are likely stale, I’m just going to scrap that right away. Or if there’s a lack of engagement on a post. Like if there’s, you know, for example,

[04:43] a Hacker News article or a YouTube video I pulled in that only has a couple of hundred views. I mean, maybe that’s good information, but a good general rule of thumb that I’ve seen is usually I can skip past that thing. And so, being able to track that before I’m actually using my tokens to determine if it’s important to me. And then for whatever gets past the deterministic filters and deduplication, I send that into the first model call using Jev. So, this is something I covered in my last Second Brain Jev Use Cases video. I’ll link to that right here. But, I love using Jev as the first line of defense for models

[05:15] doing the filtering. And so, Jev hasn’t been around for super long. Before Jev, I was using LLMs to filter everything. But, that meant making an LM call for every single source that made it past the first couple of stages. And you can use a cheaper model for this. Like Haiku, especially with the new Haiku 5.5, you can have a lot of reasoning capability for super cheap. But, I still don’t want to use an LLM as much as I possibly can avoid it. And so, that’s why I’m using Jev as the first line of defense. Now, I did try a version of

[05:46] this system where I didn’t have an LLM at all and Jev was the last line of defense. My accuracy actually went down a lot. I had a lot of things slip through that I didn’t care about, a lot of things filtered out that I actually did, but I found this to be the sweet spot here. So, I use Jev to make more of the obvious decisions. Anything that is very obviously fluff or very obviously something I care about, it’s going to make that decision first, right? So, if it’s like, “Yes, we definitely should drop this.” then it exits and I never have to make an LLM call. But for anything where it’s unsure or it

[06:17] knows that I need to definitely keep, that’s when we send it to an LLM to just get everything ready for the digest and do any further filtering that I need. And so, to give you some concrete numbers here, for this run that I did with 864 posts, it only costed 3 cents for all the calls I made to Jev and then for what survived to Claude Haiku, it only costed 42 cents. And so, it’s less than half a dollar every single day. Not that bad for how much time it saves me, it is definitely worth it. Now, obviously, the price for you is going to

[06:48] change depending on how many sources you’re pulling from and how much text you get per source. And so, also something you want to be very aware of here is for every source you pull through, generally, you don’t want to just dump the raw output of the MCP server call or API call into Jev or your LLM. There’s almost always going to be some things you can deterministically strip like headers and footers, just extra spacing and things that the agent doesn’t really need. That’s one of the reasons I like using Apify because for all the runs that I have here, as it’s pulling from my different sources, it automatically returns markdown that is optimized for the agent, like just the

[07:21] information that it needs. And so, using something like Apify, you have to worry about it less, but if you do have a custom setup, just keep in mind it’s very important for you to establish up front and of course, that’s one of the things that my scale helps you with. And I also put together this little demo here just to make things really concrete. So, this is not my full content engine. This is just from pulling through a couple of subreddits, but it’s a nice visualization to see what it looks like to filter some things with Jev and then send other things to the LLM. And so, for every single source that makes its way to Jev, it’s going to evaluate based on three pieces of

[07:55] criteria. This is built into the skill as well. It’s going to figure out, is this on topic? Is this something Cole would care about? Is this actually new and concrete or is it just a toy demo? A lot of things that I find with blog posts and especially subreddits is people are just sharing little things that they built to try to benchmark models that I don’t really care about. And so, this is one of those lessons I learned where I see these like toy demos that I like to call them a lot. And I just want to filter that out right away. So, anything that scores even reasonably high with this like a 0.7, I’m just

[08:25] going to filter it out. I’m just going to drop it. I’m not going to send that to the LLM. And so, there’s some things that are obvious enough where like this is so good. Like the announcement for Sonnet 5.5 or the release of the official 1.0 of Pi. Like yes, I definitely want to keep that. I don’t even need the LLM to decide. And then other things where it’s more nuanced and maybe I want the LLM to dive a little bit more into my memory system cuz Jev can’t really do that. That’s when I send it off to the LLM to reason more, do I actually keep it? The system is still light. It’s still going to be cheap when

[08:56] it goes to the LLM, but just not quite as much. And then for every single one of these sources that I want to bring through the content engine, I just manage them all with a single configuration JSON file. It could not be easier for me to manage and extend this. Like here are all of the RSS feeds I want to follow, all the new blog posts from this, YouTube channels, GitHub repositories, the categories for archive research papers, for Appify, I have the searches I want to perform every time with Reddit and web search and YouTube. So, catching more general things outside of the individual channels as well. All

[09:29] of this together makes it so I feel like I have a really good comprehensive grasp on the whole internet as new things are coming out. Awesome. So, now that you understand the system at a high level, we can get into using the skill to build your own personal content engine. I’ll just walk you through getting started cuz the skill really does go through the entire thing with you. And so, the easiest way to install this skill is to follow the instructions in the readme in my skills repository. I’ll link to this in the description. If you’re using Claude Code, I have a Claude Code plugin to make it so incredibly easy to bring

[10:00] this into your system. And if you’re using a different coding agent, you can just point it at the URL for this repository and ask it to set up the skills or just download the single skill that we’re using right now. And so, once you have this set up, I would recommend running the skill in a new repo, a new fresh folder where you want to build the content engine. You can optionally specify the path to a separate repository. Like if you’re building it in your second brain, but you want it to actually be created somewhere else. I just wanted to leave that as an option, but generally when you build this, you’re simply going to do /build signal engine and that is it. You don’t even

[10:34] have to specify any arguments. So, I’m going to send this in and the first thing it’s going to do, like I mentioned earlier, is grill you with a bunch of questions so it can really be custom to you. So, it starts by asking where should we actually build this? It’s going to default to recommending where we currently are. So, I’m just going to go with that because I created a fresh folder for this. And then it’ll start getting into asking, you know, what do you actually need to keep up with, right? So, the higher level questions so it can even maybe recommend different sources. So, I want to keep up with, you know, AI tools that I use or maybe you want to keep up with specific platforms you want to call out. It’s entirely up to you how you answer these questions

[11:07] and communicate with it. Tell me about something in your AI tools that you found out about late or missed entirely. Right? Like what is the actual problem if we get more granular here that we’re trying to solve. Right? So, maybe it’s like later we found out about something in the change log that we wish we knew about a week earlier or we found out from a YouTube video. Like, “Oh man, this thing came out a couple days ago and I didn’t find out until this YouTube video. Like I really wish I knew about it right away.” And then getting more into the sources and everything, I’m not going to go through and answer every single question here cuz I want you to do that very custom to what you care about, but I’ll show you the final output. So, I went

[11:40] through this process already where I answered every single one of the questions. It really does grill you. You have to be a little bit patient here, but I I recommend really investing the time into this up front because it’s going to make it so that I can just rip through the entire implementation. So, you spend, you know, 10-15 minutes answering its questions and then it builds out the entire thing and it actually does it in phases so that it’s very comprehensive and even testing things for your personal engine as it’s building it. So, going back to the diagram here, after the interview, the skill going to walk itself autonomously through a six-stage process to build out

[12:12] everything. So, we’re not just trying to one shot it. We’re having it split up into bite-size pieces of work and it’s going to test after every single one of them. It would definitely fall flat on its face if it just tried to one shot everything. So, it starts very simple, just one source that you agreed upon in the interview, building that end-to-end and testing it. Then, moving on to building every other source and fully establishing this data layer here and doing it according to the platforms and methods that you specified. Like for myself for this demo here, I said that I want to use Appify for everything and so

[12:43] that’s what it’s going to be integrating with as it builds out the data layer. But, whatever you decided, whatever customizations you have, it’s going to work with that. If you want to use APIs directly, whatever, it’s going to build that out and then it’s going to build the code filters, the deterministic ones and test that, the decision steps with Jev and the LLM, building the format for the digest, and then also helping you set the schedule for the frequency you want to run this on. And so, all that together is just going to rip through this. And so, if we go back to my conversation here to the very end, boom, we have the full engine built. Now, this might not be perfect right away, so you

[13:14] can definitely iterate with the agent here, but it is going to be a very good starting point. The other thing that I built into the skill is it produces a profile at the end. So, you have an at-a-glance view for the sources you’re pulling from, the filters and decision questions that you have. So, if there’s something that doesn’t look perfect here or exactly what you want, you can just adjust it and then point the agent at it and say that like, you know, here’s a new profile. I want you to implement the differences. And so, this is kind of your way to just constantly adjust things. So, keep in mind, the content engine is not reading this every time it runs, but whenever you want to change

[13:45] something, you can just update it here in natural language and then tell the agent to implement those changes. So, there you go. That is how my content engine works and how you can build it yourself with the skill. And even if you don’t build it from scratch here and you just want to take a couple of golden nuggets from this video and incorporate into your own process, I hope that you find that really useful. And so, if you appreciated this video, you’re looking forward to more things on agentic coding and building up your second brain, I would really appreciate a like and a subscribe. And with that, I will see you in the next video.