Blog

The Anthropic Double Leak: Source Code, Mythos, and the Architecture of Trust

Sunday, April 5, 2026

Hello, this weekly digest processes the most important new videos from around 45 curated AI and coding YouTube channels — with substance, no superficial top-5. One complete summary per video, plus a weekly overview of dominant topics. Read at your leisure — or copy a summary into your LLM of choice and dive deeper. Click the link under each summary to see the original video.

Model Releases & Benchmarks

Google Gemma 4 was the most discussed open-source release of the week, covered by TheAIGRID, Tim Carambat, WorldofAI, and AI with Arnie. The family includes four variants: the ultralight E2B and E4B (optimized for smartphones and Raspberry Pi), a 26-billion mixture-of-experts model with only ~3.8 billion active parameters, and a 31-billion dense model ranking third on LM Arena. All models ship under Apache 2.0 license, support over 140 languages, context windows up to 256,000 tokens, and are natively multimodal (text, image, audio, video). Efficiency is the real differentiator: the 31B model outperforms Qwen 3.5 with 397 billion parameters on benchmarks. Qwen 3.6 Plus also stepped into the spotlight: a 1-million-token context window, 78.88 on SWE-Bench, superiority over Claude Opus 4.5 on frontend generation, and 50 cents per million input tokens make it the new open-source favorite. Datapizza and WorldofAI also reported that OpenAI removed the Sora app from stores — computational costs, missing monetization model, and copyright issues cited as reasons — instead concentrating all resources on the AI super-app and the upcoming GPT-5.5/Spud model. GPT-5.4 Thinking received an update allowing interruption of the thinking chain phase, which the Datapizza team attributes to extensive human feedback training.

Local & Open-Source AI

Tim Carambat focused on 1-bit LLMs from Prism ML (Bonsai models): 14x smaller than full-precision models, ~1 GB RAM for the 8B model, 114–130 tokens/second on a MacBook Pro M4 Max — and still capable of multi-step tool calling including web search, PDF generation, and PowerPoint creation with sub-agents. Google’s TurboQuant algorithm compresses the KV cache to 3 bits with 184,000x setup acceleration and 8x speed boost on Nvidia H100 — which according to TheAIGRID immediately hit memory chip manufacturers like Micron and Western Digital at the stock exchange. Nate Herk showed concretely how to integrate Gemma 4 and Qwen models via Ollama into Claude Code to bypass Anthropic’s rate limits or drastically cut costs. Sebastien Dubois released two Obsidian plugins: one for syncing reMarkable notes into the vault and one (Transcriber) that converts handwritten notes to Markdown via local Ollama vision models — demonstrated with GLM OCR — without leaving your computer.

Claude Code & Anthropic Tooling

The leak week was accompanied by a dozen detailed tutorial videos exhausting Claude Code’s actual possibilities. Leon van Zyl delivered a two-hour end-to-end tutorial including PRD workflow, design system generation, sub-agent parallelization, and /loop cron jobs. Mark Kashef introduced two overlooked slash commands: /powerup as an interactive learning companion and /insights, which generates an HTML report on last 30 days usage patterns and chains with Obsidian and automated email summaries. WorldofAI catalogued hidden configuration options including the cloud_code_no_flicker flag and hooks firing at session start, before and after tool use, and after edits. Nate Herk dedicated two separate videos to token management: 18 hacks for context hygiene (including separating MCP servers costing up to 18,000 tokens per message and keeping Cloud.md under 200 lines) plus a guide to running Claude Code with local Ollama models or free OpenRouter models — effectively 50–100x cost reduction on low-stakes tasks. OpenAI’s Codex plugin for Claude Code was also tested in practice by Nate Herk: GPT-5.4 leads on most coding benchmarks by 10–13 points, is cheaper, and Codex’s “Adversarial Review” skill found actual logic errors in Opus-generated code during direct testing.

Coding Agents (non-Claude)

Hermes Agent and OpenClaw dominated comparison discussions across multiple channels this week. Alex Finn tested both over weeks and reached a nuanced verdict: Hermes is faster, more transparent (shows every tool call in real-time), and automatically builds reusable skills after each task — but its fatal weakness is memory compaction, where the agent loses orientation and aborts tasks. OpenClaw remains more stable, benefits from massive developer resources and daily updates. The optimal recommendation: run both in parallel, connected via the Agent Communication Protocol (ACP), so OpenClaw acts as orchestrator activating Hermes for specialized tasks — and one can repair the other in emergencies. Melvynx meanwhile showed that Anthropic blocks OpenClaw token usage via Claude subscriptions, while local CLI configurations and alternative providers like Glm (from $10/month) still work. NeuralNine presented OpenCode as an open-source terminal agent with superior UI: granular permission system per opencode.json, diff view with LSP integration, undo/redo, reasoning-level switching, and Ollama integration for local models.

Software Engineering & Dev Culture

Brian Casel argued that “restraint” — the discipline of choosing focus over capability — is the only skill AI cannot replicate: all major coding tools have established Plan Mode as standard, but the strategic shaping conversation before planning remains human work. Sebastien Dubois presented eight stages of AI usage (from simple chat to 100+ agent orchestration) and added a second often-ignored dimension: context management through structured knowledge base in tools like Obsidian. Theo criticized closed AI projects fundamentally: with AI-accelerated development, closed applications can fail a hundred times faster; Gemini CLI, OpenCode, and Codex CLI have disclosed their server components, but Anthropic sends DMCA takedowns. Fireship uncovered a real supply chain attack on Axios (100 million weekly npm downloads): two infected versions contained a remote access trojan that deleted itself after execution and passed npm audit without warning. Pretext, a new pure-TypeScript tool from former React Core member Changlu, solves browser layout reflows on dynamic text through canvas-based width measurement — relevant for virtualized lists and masonry layouts.

Personal AI OS & Agent Frameworks

The week was also marked by Paperclip, an open-source orchestration tool organizing AI agents into hierarchical corporate structures. Four channels — AI with Arnie, Julian Ivanov, Leon van Zyl, and Tech With Tim — each presented tutorials with practical demos: CEO agent hires an engineer, researcher, script agent, and SEO strategist work on daily routines, GitHub commits and Vercel deployments run fully automated. Technically, Paperclip runs via Docker on a VPS (Hostinger template from ~$7/month); API keys from Claude, OpenAI or Gemini or existing subscriptions can be configured via device-code authentication. Nick Saraev played the skeptic: Paperclip reproduces classic corporate hierarchies even though AI systems are fundamentally more parallelizable — 50 simultaneous agents synthesizing the same result would be more efficient than delegation by org chart. Nate Jones analyzed five additional agent platforms (Cowork, Lindy, Wordware/Sauna, Google Opal, Obvious) by three quality criteria: persistent memory, editable artifacts, growing context. Even Cowork only met 1.5 of 3 — and still justified $285 billion in SaaS equity sales. Cole Medin introduced Archon, an unreleased workflow engine with deterministic and non-deterministic nodes for reproducible coding processes — by its own measurement about 100x speed increase over manual programming.

AI Automation & Workflows

Cole Medin demonstrated “Adversarial Dev” as a new technique for more reliable coding agents: a generator agent writes code, a separate evaluator agent (in a fresh session without confirmation bias) scores it against pre-negotiated criteria and provides up to three rounds of feedback on failure — implemented in ~4 hours with Claude Sonnet 3.5, repository publicly available. Nate Jones extracted 12 architecture primitives for robust agent systems from the leaked Claude Code codebase, ordered into day-one fundamentals (tool registry with metadata, permission systems, session persistence, token budgeting, structured streaming events) and operational maturity (dynamic tool pool assemblies, transcript compaction, agent type systems). His core point: agentic systems are 80 percent backend architecture and 20 percent AI. Nate Herk listed the five most profitable automation workflows for enterprise customers: speed-to-lead (5-minute response to leads multiplies conversion sevenfold), document processing, follow-up sequences, database reactivation, and internal reporting — with concrete ROI figures from real customer projects. Dave Ebeler from the n8n channel presented seven phases for enterprise automation with the counterintuitive core: as little AI as possible when rule-based logic suffices.

AI Business, Marketing & Freelancing

Zubair Trabzada demonstrated a reputation analysis tool built with Claude Code for local businesses: five parallel agents generate a PDF report with reputation score, sentiment distribution, competitor benchmarking and copy-ready response suggestions for negative reviews — business model: audit free, ongoing management for $500–2,000/month. Stefan Glötzl, YC founder of Superglue, explained why 39 percent of developer time goes into undocumented glue code and how agentic integration platforms with self-healing capabilities (automatic diagnosis and Slack notification on API changes) solve this — his stance: agents are production-ready now, the main challenge is enterprise integration, not technology. Melvynx reflected on his AI thumbnail generator Subfast, which was copied twice: the decisive differentiator isn’t design but genuine domain expertise as a YouTuber with 700+ videos.

PKM & Knowledge Management

Julian Ivanov showed how Obsidian works as a persistent context basis for Claude Code: a Cloud.md file with onboarding prompts that Claude interviews on first start and automatically generates vault structure plus system prompt solves the session-reset problem. Cole Medin’s “Second Brain” on Claude Code basis — with memory layer (soul.md, user.md, memory.md), skills, heartbeat cron job, and zero-trust integrations for Gmail, Asana, and GitHub — saves him an estimated dozen hours weekly. He argues against pre-built solutions like OpenClaw with the “Lethal Trifecta” principle: private data plus untrusted content plus exfiltration vector are always simultaneously active in Second Brains. Kyle Balmer’s NotebookLM videos showed how Google’s free tool works as a hallucination-free RAG system for lead magnets, slide decks, and automated email list building (200+ subscribers daily via ManyChat and Claude Code automation) — including an unofficial Python API for full automation. MoureDev provided a fundamentals tutorial on Obsidian with focus on links, canvas, database plugin, and templates.

AI Industry & Strategy

Nate Jones extensively addressed the Anthropic-Microsoft-OpenAI convergence moment: skills are no longer personal configurations but organization-wide infrastructure — a skill.markdown text file with metadata that Anthropic and Microsoft are bringing to Copilot and OpenAI adopted as an open standard. Effective skill description as a routing signal for agents, output as an API-like contract, and quantitative testing with test suites are the three critical design principles. Apple stands at a strategic pivot moment at WWDC according to Nate Jones: Siri as a standalone app with ChatGPT-like interface, App Intents for agent developers, and MCP integration at system level could secure iPhone’s position in the agents era — though Apple’s real strength is controlling the entire stack for 1.5 billion users, not owning a frontier model. The IA et Stratégie channel analyzed Mistral AI’s $830 million funding from seven European banks, the first time Nvidia Blackwell GPUs were accepted as bankable securities — a paradigm shift making compute capacity a strategic asset. In parallel, Nate Jones analyzed the helium supply crisis: Qatar produced 33 percent of world supply; after rocket damage to the facility, helium spot prices immediately doubled, HBM memory was already sold out, and TSMC holds only 11 days of liquid natural gas reserves.

AI & Society / Future of Work

TheAIGRID analyzed Dario Amodei’s prediction that AI could eliminate up to 50 percent of entry-level white-collar jobs and drive unemployment to 10–20 percent — supported by Stanford’s Canaries study (13 percent employment decline for 22–25-year-olds in AI-exposed roles) and Anthropic’s own research (job-finding rate for 22–25-year-olds minus 14 percent). Tim Carambat confronted AGI claims by Sam Altman, Jensen Huang, and Mark Gubras with ARC AGI 3 benchmarks where a simple CNN by a single researcher beat modern LLMs — his conclusion: the GPT paradigm has reached its limit, AGI requires fundamentally different architecture. David Shapiro developed his AIL concept (Assumption of the Indispensability of Labor) arguing the AI crisis isn’t economic but existential: the cultural doxa linking human dignity to productivity collapses simultaneously in Western achievement paradigm and Eastern collectivist model. Everlast AI spoke with Dr. Jost Bach from the California Institute for Machine Consciousness about consciousness as biological algorithm, cyberenimism, and whether LLMs possess functional understanding.

Brief Notes

Liam Fedus, co-creator of ChatGPT and former OpenAI VP, is launching Periodic Labs with an AI foundation model for materials science combining language models with symmetry-aware neural networks for atomic systems. Manus AI offers scheduled tasks, document creation, and custom skills — TheAIGRID’s tutorial shows daily Reddit/X research automation and presentation creation with Nano Banana. Google Stitch received a Vibe design update; Simone Rizzo demonstrated export to Claude Code via MCP, generating a complete React app from a text prompt in 15 minutes. Tech With Tim replaced Lovable with Mocha, an AI app builder with integrated auth, database, and email without external configuration. DeepSeek Version 4 will natively run on Huawei Ascend chips — strategically significant as the first frontier AI on native Chinese hardware, prompting massive orders from Alibaba, ByteDance, and Tencent.

AI Explained

No new videos in this period.

AI Foundations

No new videos in this period.

AI with Arnie (2 new videos)

• Local AI is finally good (Gemma 4 Tutorial)
  3.4.2026, 14:06:28

  Gemma 4 – Local AI finally practical

  Google has released Gemma 4, a multimodal model under the Apache 2.0 license that—contrary to recent trends—allows true commercial use and fine-tuning. There are four variants: two extremely small edge models (2 and 4 billion active parameters via Mixture of Experts, optimized for smartphones and Raspberry Pi) and two larger workstation models with 26 and 31 billion parameters. Particularly impressive is the efficiency: the 31-billion model outperforms Qwen 3.5 with 397 billion parameters in benchmarks, while models like GLM-4 or Kimi 2.5 rank only marginally higher but require 700+ billion parameters.

  The models support native function calling, structured outputs, test-time computing (thinking mode), vision, audio, and understand over 140 languages with context windows up to 256,000 tokens. They are specifically optimized for agent-based workflows and coding frameworks (OpenClaw, Claude Code).

  Practical use: Gemma 4 can be run locally via Ollama and LM Studio—for example, the E2B model with a simple terminal command. After downloading, the model loads automatically. The app offers a GUI alternative and integration with coding tools. Behavior can be configured in the Modelfile: enable/disable thinking mode, adjust token window, change system prompts. Create a custom model with ollama create and switch between variants.

  Tests: For image analysis, the model reliably estimated nutrients (proteins, macros, calories) in about 20 seconds. For coding, it created a browser-based OS in HTML/CSS/JavaScript with games and features—but required several iterations to fully meet more complex requirements.

  The video is a tutorial with a demo of Gemma 4 on Google and with local Ollama; structured clearly enough for beginners new to local AI.

• Claude Code and Paperclip change everything!
  1.4.2026, 12:29:54

  Paperclip and Claude Code – Autonomous AI agent systems

  The video demonstrates Paperclip, an open-source orchestration tool for AI agents that simulates companies where AI-driven roles (CEO, CTO, content creator, video editor) automatically collaborate. The idea: define a company goal, build an agent team, and the AI handles the rest autonomously.

  Who’s behind it: Project co-founders include former Slack and Figma employees; the public face is a figure named Dotter, who comes from the crypto and NFT space. The creator recommends installing the tool on a virtual server rather than locally first, to minimize security risks.

  Core features: Paperclip orchestrates multiple agents via a dashboard. Each agent receives instructions (system prompt), routines (heartbeats for recurring tasks every X minutes/hours), skills (abilities like web search, Remotion for video generation) and can be connected to various LLM providers (Claude, OpenAI, etc.). The system tracks costs, logs activities, and enables issue management. Business templates are available (e.g., Y Combinator CEO template with 5 agents and 27 skills).

  Practical setup: After installation and email/password login, you define a company name and goal, add a CEO agent (with Claude Code or other LLMs), and give it initial tasks like “hire an engineer.” The CEO then works automatically: in the demo scenario, it hired an engineer, later hired a content creator and video editor, automatically generated YouTube scripts, deployed a landing page on Vercel, pushed the repo to GitHub, and researched AI news based on daily routines—including auto-generating a short video about a current news item.

  Creator’s realistic assessment: Currently a fascinating toy more for tinkerers than a production tool. The creator warns against dreaming of autonomous profit generation—small use cases (e.g., automatically marketing a training plan as a PDF via BlockPost) could work, but similar features already exist in Claude Code and OpenAI Agents. The tool is too early to say whether this specific approach will prevail or if major AI players will integrate the features directly. Recommendation: try it if you have time, but it’s not essential.

  The video covers Paperclip and Claude Code as AI agent orchestration platforms; the format is a demo with detailed walkthrough and critical analysis.

AI News & Strategy Daily | Nate B Jones (7 new videos)

• Wall Street Just Bet $285 Billion on AI Agents. The Best One Barely Works.
  4.4.2026, 15:00:17

  Wall Street Bet $285 Billion on AI Agents. The Best One Barely Works.

  Wall Street has massively invested in AI agents after Anthropic introduced Cowork in early 2025 – an autonomous agent that runs on your own computer, opens apps, and completes tasks without coding knowledge. Microsoft quickly responded with Copilot Cowork. Investors saw it as a tool that could replace expensive SaaS licenses, leading to over $285 billion in stock sales by SaaS companies. However, Cowork still has significant issues: it only works when the laptop is powered on, memory management is flawed, and contextual learning capability doesn’t really exist.

  To evaluate good agents, the author proposes three central questions:

  1. Does the agent have persistent memory, or does every session start from zero?
  2. Does the agent produce verifiable, editable artifacts?
  3. Does context grow over time; does the agent get smarter?

  Four other agents compared:

  Lindy – The most well-known outcome agent outside the tech giants. Users describe desired outcomes in language, Lindy builds and operates the automation. Problem: 2.4 out of 5 TrustPilot rating, credits burn without transparency, artifacts are less editable than in Cowork, debugging interface is weak. Lindy successfully occupies a niche between Zapier and Cowork.

  Wordware/Sauna – Wordware raised $30 million for an AI agent IDE but pivoted to the Sauna platform after realizing people don’t want to “build automation” but rather “have too much to do.” Sauna positions itself as “Cursor for Knowledge Work” with memory as a fundamental principle rather than a feature, persistent browser login, and context amplification. However, the project is very early and heavily demo-focused – practical productivity still needs to be proven.

  Google Opal – Free, a Google Lab project using Gemini 3.5 Flash that understands goals, selects tools, self-corrects, and remembers across sessions. People actually build with it (not just demos) – meeting agents, remixable workflows. Advantage: free, low barrier to entry. Disadvantage: typical Google (privacy, history of abandoned products), memory function is just a simple table without persistence for true agent-driven outcomes.

  Obvious – A complete AI workspace with SQL workbooks, live charts, presentations, custom apps, and Kanban boards. Artifacts are first-class citizens with cross-referencing. Problem: Very new and quiet – hard to evaluate, potential visible, but not yet proven in production.

  Three principles for functional agents:

  1. Memory must be anchored in architecture, not just a feature
  2. Outcomes need editable surfaces – hidden black-box operations don’t work
  3. Context must become denser – tasks should get easier as the agent learns

  A three-layer architecture for DIY agents consists of: Knowledge Store (memory via database + MCP connections), Agent Recipes (predefined workflows like calendar, meeting, documents), and Scheduling Loop (iterative learning over time). The author is working this out in the Open Brain project.

  Conclusion: The space shows that true outcome agents are extremely hard to build – even Cowork only meets 1.5 of 3 quality criteria. Hype dynamics drive adoption anyway. What matters is asking hard questions instead of falling for demos, and understanding that memory, editable artifacts, and context amplification are the differentiators.

  Systems discussed: Cowork (Anthropic), Copilot Cowork (Microsoft/OpenAI), Lindy, Wordware/Sauna, Google Opal, Obvious, Open Brain. Format: opinion/deep dive with product evaluation.

• I Broke Down Anthropic’s $2.5 Billion Leak. Your Agent Is Missing 12 Critical Pieces.
  3.4.2026, 14:00:32

  The author analyzes leaked internals of Anthropic’s Claude Code and extracts 12 critical architecture primitives for successful agent systems. The analysis is organized into two levels: Day-One Foundations (tool registry with metadata, permission systems with security levels, session persistence across crashes, workflow state separated from conversation history, token budgeting with hard limits, structured streaming events, system event logging) and operational maturity (dynamic tool pool assemblies, transcript compaction, permission audit trails as first-class objects, agent type system with defined roles like Explore, Plan, Verify, etc.).

  The central insight: agentic systems are 80% unglamorous backend architecture (error handling, security, recovery, logging) and only 20% AI. Claude Code treats critical scenarios like the shell execution tool (bash) with an 18-module security architecture; streaming events convey not just thoughts but also structured status information; verification runs on two levels: successful agent runs AND validation of harness changes against guardrails.

  The author also criticizes the pattern of a second Anthropic leak within a week and questions whether development speed is overrunning operational discipline. The context: at Anthropic, AI writes 90% of code, engineers ship up to five releases per day per person.

  For operationalization, the author releases a Skill tool with two modes: Design Mode for structured architecture definition before implementation (with harness shape recommendations and phasing) and Evaluation Mode to assess existing codebases against identified primitives with prioritized fixes and verification tests. The skill exists for both Claude Code and OpenAI’s Codebase with identical logic to position primitives as universally applicable. The author warns against over-engineering (most common mistake is too much multi-agent coordination instead of fundamentals like permissions or crash recovery) and emphasizes simplicity as a survival trait.

  Explicitly discussed: Claude Code / Anthropic, OpenAI’s Codebase, open source agents; Format: deep dive with reflection and practical skill release; Level: advanced, directed at agentic system designers.

• Your Claude Limit Burns In 90 Minutes Because Of One ChatGPT Habit.
  2.4.2026, 14:00:06

  Summary: Your Claude Limit Burns In 90 Minutes Because Of One ChatGPT Habit

  The video argues that inefficient token usage – not the models themselves – causes AI application costs to explode. The creator identifies concrete habits that waste tokens:

  Beginner mistakes:

  • Feeding raw PDFs: 4,500 words can cost over 100,000 tokens instead of ~5,000 because formatting, fonts, and metadata are included. Solution: convert to Markdown (e.g., via free web tools or directly from Claude).
  • Conversation sprawl: 20–40 turns in a conversation waste tokens. Better: research selectively in separate chats, then work in one clean session with all the information.

  Intermediate:

  • Too many plugins: Each enabled plugin loads ~1,000–2,000 tokens at startup. If you have 50+ plugins, you start with 50,000+ token overhead – before you type a word.

  Advanced (highest leverage):

  • Unpruned system prompts: Don’t remove old instructions from Claude 3.5 era even though newer models don’t need them.
  • Loading entire repos in context without reason.

  Concrete cost savings (example):

  Sloppy workflow (raw PDFs, 30 turns, Opus only): ~800K–1M input tokens, 150K–200K output → $8–10 compute.

  Optimized workflow (Markdown, fresh sessions every 10–15 turns, Opus for reasoning, Sonnet for execution, Haiku for polish): ~100K–150K input, 50K–80K output → $1 compute.

  Result: 8–10x cost reduction, same work.

  For teams: $2,000/month (sloppy) vs. $250/month (efficient) on API.

  Additional tips:

  • Model routing: Don’t use the most expensive model everywhere (e.g., Haiku for formatting instead of Opus).
  • Prompt caching: Cache hits cost 90% less (50¢ instead of $5 per million tokens for stable contexts like system prompts or tool definitions).
  • Web search: Use Perplexity via MCP or similar instead of Claude’s native search; saves 10–50K tokens per search.

  For agents – five rules:

  1. Index references (don’t dump raw documents).
  2. Pre-process context, pre-summarize, pre-chunk.
  3. Cache stable contexts.
  4. Feed each agent only the scope it needs.
  5. Measure and instrument token costs per call.

  The creator built a tool (“Stupid Button”): a prompt that audits existing conversations and identifies concrete waste; plus a skill for overhead measurement, and guardrails for the Open Brain community (automatic Markdown conversion, index-first retrieval, context scoping).

  Core thesis: Next model generation (Claude Mythos, GPT-next, Gemini-next) will be orders of magnitude more expensive. Those wasteful today will pay multiples later. Intelligent token usage will become a critical job skill. The goal isn’t reducing token consumption but making it efficient – so teams can work boldly and creatively with models without throwing money away.

  Claude and GPT explicitly mentioned; also Gemini, Llama, Qwen, Perplexity, Grok, Open Brain ecosystem. – Opinion/reflection with practical action items.

• Your AI Stack Isn’t Ready for Claude Mythos
  1.4.2026, 14:00:50

  Summary: Your AI Stack Isn’t Ready for Claude Mythos

  Claude Mythos – a massive model trained on Nvidia’s new GB chips – was leaked and, according to Anthropic, is the largest and most powerful model in the world. Security researchers report that Mythos is exceptionally good at finding security holes (like zero-day vulnerabilities in established repos like Ghost with 50,000 stars), showing that the first task on release is testing the model against your own infrastructure.

  The video’s central point is the “bitter lesson”: with more powerful models, you must simplify, not complexify. The speaker names four concrete audit points:

  1. Prompt scaffolding: Review every line of your system prompt – is it needed because the model needs it, or because you think the model needs it? With stronger models, 30–50% of procedural instructions can be deleted. The trend: tell the model what and why you want something, not how.

  2. Retrieval architecture and memory: Instead of specifying retrieval logic yourself, with large context windows the model should increasingly decide what data it needs – trust it to find the right files from a well-organized repo.

  3. Hardcoded domain knowledge: Ask yourself which business rules are truly necessary or whether the model can infer them from context. With better models, many explicit rules can disappear.

  4. Evaluation and verification: For software you need a comprehensive eval gate at the end (not multiple intermediate checks) that tests all functional and non-functional requirements. Humans increasingly become the bottleneck – automation is needed.

  Beyond this, the speaker names four elements of a Mythos-ready architecture: clear outcome specifications (not process steps), explicit constraints/guardrails (e.g., “don’t expose customer data”), well-defined tools, and for agentic software, multi-agent coordination where the model acts as planner.

  Mythos is expected to be very expensive and available only on premium plans, meaning: those who invest in future intelligence (Pro plan vs. $200/month Max plan) will have a significant productivity advantage. The speaker warns that human talent can’t compensate for missing model power – the better the models, the more important it is to get out of the way rather than compensate.

  This new era starts in weeks, not months. Simplify now or later under pressure – that’s the choice.

  Discussed: Claude/Anthropic, OpenAI (mentioned), plus agentic software patterns from Factory.ai and Cursor. Format: opinion/reflection with clearly practical auditing elements and architecture guidance.

• Your iPhone Is About to Control Every AI App You Use. Here’s What This Means For You.
  31.3.2026, 14:01:08

  Apple could build a strong AI position at the upcoming WWDC through strategic Siri redesign and integration of agent-friendly features into its ecosystem, despite past delays. The speaker identifies four core developments: First, Siri as a standalone app gets a ChatGPT-like interface with access across all other apps thanks to Apple’s control of the full stack – not just an isolated app but as “ambient intelligence” everywhere on the phone. Second, Apple introduces agent-oriented interfaces (called “app intents”) for developers to enable remote app interactions (e.g., Siri-controlled photo editing during Amazon price comparisons). Third, Apple integrates MCPs (Model Context Protocol) at the system level, simplifying tool calling and agent integration. Fourth, Apple forgoes its own large language model and instead uses a small private model for local data and Google models for complex queries.

  The strategic intent is three-fold: control of user interface (Siri as the default AI entry point for 1.5 billion users), opening the app ecosystem for AI agents through developer frameworks (with clear bounds against “vibe coding”), and protecting the iPhone brand in an agent-dominated future. The problem: Apple is late – major promises were made at WWDC24 but not delivered, leading to a lawsuit over false advertising. The speaker also criticizes Apple’s approach (integration rather than vision-based automation like Google) as defensive and slower, though possibly more robust.

  For Google, the deal with Apple isn’t primarily about the alleged billion dollars but about signals from phone inferences and learning from usage patterns that only Apple users provide. Samsung could face pressure from Apple’s potentially cheaper mid-range phones with agent features. For developers: build agent-oriented apps, explore MCPs and app intents. For everyone else: train delegation to agents – first ask if an agent can do it, then act yourself.

  The speaker warns: media will probably report “Siri is now a chatbot,” but the real story is “Apple is opening the ecosystem for agents across the entire phone” – a long-term protection of iPhone’s position in the agent era.

  Explicitly discussed: Apple, Siri, Google/Gemini, OpenAI (ChatGPT, Jon IV), Anthropic, Claude, Mac Minis, MCPs, App Intents, Samsung, Meta – opinion/reflection on upcoming WWDC strategy.

• Anthropic, OpenAI, and Microsoft Just Agreed on One File Format. It Changes Everything.
  30.3.2026, 14:00:04

  Summary: Skills as new standard infrastructure for AI agents

  The landscape around AI Skills has fundamentally shifted since Anthropic’s launch in October: Skills are no longer personal configurations but organization-wide infrastructure, version-controlled by admins and deployed across Excel, PowerPoint, Claude, and Copilot. The most important turning point is that not humans but agents are now the primary callers of Skills – an agent can make hundreds of skill calls per run while humans only used individual prompts.

  Skills are technically a text file called skill.markdown with metadata and instructions – a simple but powerful primitive. A skill encodes English-language instructions that give an LLM consistent context to achieve something predictable. Practical examples range from the “Specialist Stack” in software development (one skill transforms vague requirements into PRDs, another breaks these into GitHub Issues) to real estate, where an operator uses 50+ repositories with 50,000+ lines of skills for lease standardization, comparative analysis, and protocols – simultaneously functioning as an onboarding layer for new employees.

  Four critical insights for effective skills: (1) Description is critical – it must be specific, fit on one line, and contain trigger phrases (e.g., “who are the players in this market”), not vague like “helps with competitive analysis.” (2) The methodology body needs five things: reasoning frameworks rather than just linear steps, explicit output format, documented edge cases (don’t rely on common sense), examples for pattern matching, and brevity (typically 100–150 lines, no more). (3) For agent-first design, the description must work as a routing signal, the output must be thought of as a contract (clear API-like SLAs), and composability should be the core idea – every output must be usable for the next process step or sub-agent. (4) Quantitative testing is essential: skills must be battle-tested for agent pipelines, with test suites to measure performance and refine versions – agent errors without a recovery loop are costly.

  Skills differ from prompts in that they compound through iterative refinement – those who continuously optimize their skills win against those who just copy prompts. A team framework works in three tiers: Standard Skills (brand guidelines, formatted templates, org-wide), Methodology Skills (how senior practitioners work, expert knowledge that saves new hires months of learning), Personal Workflow Skills (personal processes, but should still be version-controlled and shared, not just local).

  Anthropic and Microsoft are collaborating to bring Skills into Copilot; OpenAI has adopted Skills as an open standard – making Skills cross-industry infrastructure where open collaboration leads to best practices faster than proprietary approaches. The speaker plans a community Skills repository (part of OpenBrain on GitHub), organized by workflow type with consistent agent-readability bar, to collect domain-specific skills like competitive analysis, financial review, deal memo drafting, research synthesis.

  Practical first steps: transform recurring tasks (1–3x per week) into skills by having your preferred LLM build a skill.markdown from past conversations; for advanced users: rethink handoff points and contract structure; for teams: apply the tier model. The core: skills persist beyond conversations and become shared knowledge for agents and humans – freeing teams from copy-paste hell.

  Discussed: Anthropic, OpenAI, Microsoft, Claude, Copilot, ChatGPT (specific tool names in examples); Format: opinion/reflection with practical deep-dive elements.

• 48 Days. That’s How Long Before the Helium Runs Out for AI Chips.
  29.3.2026, 18:00:28

  Summary: The helium crisis and its impact on AI infrastructure

  The video addresses a critical weakness in the global AI supply chain: dependence on helium for chipmaking. The central claim is that specialized ISO containers can transport liquid helium for only 35–48 days before it evaporates – and the primary supplier, a helium and liquefied natural gas facility (Ross Leafon) in Qatar, was damaged by rocket strikes and is currently offline.

  The physical significance of helium:

  Helium is essential for advanced chipmaking because it’s used in plasma etching as a heat transfer medium to maintain temperature uniformity on wafers, and for leak testing of vacuum chambers. It’s the only element with a sufficiently small particle diameter for this – there’s no substitute. Purity requirements are 6N (99.9999%), which only a few production facilities can meet. Helium consumption increases with each new chip generation: modern 300-mm EUV fabs need between 5,000 and 20,000 cubic meters of helium monthly.

  The supply crisis:

  Qatar produced about 33% of global helium supply (2.4 billion standard cubic feet annually). Qatar Energy has admitted that 14% of helium capacity is permanently damaged, with recovery timelines up to 5 years. The planned new helium-4 facility (1.5 billion standard cubic feet annually) is now delayed until 2027. South Korea imports two-thirds of its helium from Qatar and is massively at risk – the same goes for memory makers SK Hynix and Samsung Electronics, which produce high-bandwidth memory (HBM) for every Nvidia GPU and AMD accelerator. TSMC in Taiwan imports 97% of its energy as liquefied natural gas and holds only 11 days of inventory.

  Helium spot prices have doubled, contract sourcing costs have risen 30%.

  The liquefied natural gas component:

  Helium is produced as a byproduct in the cryogenic distillation of liquefied natural gas – both are bound to the same facilities. A Ross Leafon shutdown affects both helium and energy prices in East Asia, which in turn raises operating costs for chipfabs.

  Geopolitical implications:

  China is aggressively investing in domestic helium production (Guangdong facility with 6N certification) and negotiating the Power of Siberia-2 pipeline for liquefied natural gas supply from Russia. If China achieves this independence while the West – especially South Korea and Taiwan – remains dependent on Qatar, this could give China a geopolitical advantage in chipmaking and AI inference cost structures. The US Federal Helium Reserve stopped sales in 2023; Russia can’t ramp helium reserves due to the Ukraine crisis.

  Practical consequences:

  — Memory costs will rise through at least mid-2027; HBM was already sold out, DRAM prices up 70%

  — Energy costs for Asian chipmaking won’t decline and ultimately impact cost-per-chip and cost-per-inference operation

  — US data centers are not directly affected but entirely dependent on chips from Taiwan and South Korea – the Arizona fab is microscopic compared to global demand

  — With continued high AI demand (currently at most 0.1% of world population as heavy AI users) and planned 10x to 100x growth, an ongoing supply crisis could create real capacity bottlenecks

  — Recommendation: IT procurement teams should buy chips and computing hardware early in the year, not later, to avoid price increases and longer lead times

  The video closes with a clear statement that this affects everyone – from laptop to data center buyers – and likely leads to higher prices for all AI-dependent devices.

  Format and context: News update/deep dive on physical supply chain; no specific AI tool or vendor mentioned, but rather infrastructure system risks for the entire industry.

Alejandro AO

No new videos in this period.

Alex Finn (4 new videos)

• LIVE: MASSIVE Claude Code leak fallout. + Hermes agent workflows
  1.4.2026, 20:28:53

  The stream covers two main topics: Claude Code leak fallout and Hermes Agent Workflows.

  Claude Code leak and Anthropic strategy:

  The leaked source code revealed that Anthropic is working on “autonomous proactive agents” – Claude instances that don’t just respond to commands but autonomously suggest improvements (e.g., automatically adding calendar integration and dark mode to a to-do app). The speaker suspects a business strategy behind this: Anthropic artificially reduced usage limits for existing plans and will launch a $1,000–$2,000 plan in the next four weeks alongside the new model “Mythos” (codename “Capybara”). Mythos is supposed to become “the most powerful AI of all time” and will only be available via API – potentially creating an economic divide between those who can afford it (permanent underclass theme). Sonnet 4.8 and Opus 4.7 were also mentioned as intermediate models before the long-awaited Opus 5 and Sonnet 5 versions. Dream Mode is a feature where Claude autonomously consumes tokens at night and works on improvements.

  Hermes Agent setup and local models:

  The speaker runs multiple agents in parallel: Henry (OpenClaw-based, his main instance), Hermes (first setup with this framework), and Ruben (second Hermes agent, running locally on Mac Studio with Qwen 3.5 397B). He emphasizes that Hermes now makes it easier to spin up multiple verifiable separate agents with their own workspaces and memories. OpenClaw and Hermes communicate via an Agent Communication Protocol (ACP). He prefers OpenClaw as orchestrator due to memory reliability and integrates Hermes as a specialized worker. For direct conversations, he appreciates GPT-4 for novel ideas – but for agentic workflows, Opus is clearly superior since GPT simply doesn’t complete tasks.

  Additional leaks: Buddy feature (playful companion for Claude Code with rarity tiers like Pokémon), plus hints at Paperclip AI as a newly integrated tool.

  Hardware discussion:

  Mac Studio vs. DJX Spark – the speaker considers both valid, personally owns two Mac Studios and one DJX Spark, plans another. He emphasizes that investing in local compute is emotionally fulfilling to him compared to making money.

  Glasses integration:

  Even Reality G2 Smart Glasses ($600, Ring $200) with green text display, Bluetooth-connected to OpenClaw – enables hands-free agent control. Reddit demo showed: voice command via glasses → Henry executes on desktop.

  Monday announcement:

  Repeatedly mentioned that Monday brings “the biggest announcement of my life” – regarding a new project/product he’s working on. Hints that it’s about an entirely new business idea (not just another vibe-coding tool), not niche iterations of existing categories, but completely untapped “racetracks” with trillion-dollar potential.

  Custom memory system:

  Mentions that a custom Obsidian memory system for OpenClaw/Hermes integration was already shown in the Vibe Coding Academy; YouTube video coming soon (second priority after already-published workflows).

  Explicit tools/models: Claude (Opus, Sonnet, Haiku, Mythos/Capybara), GPT-4.5, Hermes, OpenClaw, Qwen 3.5, DJX Spark, Mac Studio, Even Reality G2, Obsidian, Paperclip AI, Cursor, n8n mentioned as implicit context.

  Format: Live Q&A with demo elements and news update – difficulty level typical for advanced AI tooling practitioners.

• MASSIVE CLAUDE CODE LEAK! THIS CHANGES EVERYTHING!
  31.3.2026, 19:32:23

  Summary: MASSIVE CLAUDE CODE LEAK

  The video discusses an alleged Claude Code source code leak with announcements of new features and models. Important: The transcript contains several futuristic and somewhat speculative announcements whose factual status remains unclear.

  The key leaked features are:

  Proactive autonomous agents: Claude Code should be able to independently generate and expand tasks – for example, augmenting a requested to-do app with calendar, project management, and sharing features without explicit instruction.

  New models: Capybara (also called “Mythos”, supposedly larger than Opus), Sonnet 4.8 and Opus 4.7 were mentioned in the code.

  Dream Mode: A mode where the agent autonomously thinks about possible improvements and new features at night and generates ideas.

  Auto Mode: An intelligent hybrid between “YOLO-mode” (no approval needed) and full approval – the agent decides itself via machine learning whether it needs permission or can act autonomously. Integration with messaging services (Telegram, iMessage) for requests.

  Agentic Payments: The X42 protocol enables agents to autonomously make payments with stablecoins (e.g., USDC) and purchase online services without manual intervention.

  Buddy Mode: 20 different animals as digital/physical representations of the agent on the desktop (comparable to Tamagotchi-style gameplay) that change based on activities.

  The speaker argues that the leak could harm Anthropic long-term (competitors know the roadmap, open-source versions emerge), but also brings benefits through attention. The core moat remains the quality of the models themselves, not their wrapper.

  Claude Code and Anthropic – opinion/reflection with emphasis on planned features whose implementation status is not confirmed in the transcript.

• Did Hermes Agent just kill OpenClaw? (full guide)
  31.3.2026, 13:15:10

  Summary:

  The video compares Hermes Agent with OpenClaw, two autonomous AI agents that can control your computer. Hermes is significantly faster and lighter (even with the same model like Opus), but its core strength lies in self-improvement: it learns from tasks, automatically creates reusable skills, and gets better with each use. The demo shows how Hermes automates a complex daily task (fetching Hacker News stories, summarizing, rating, generating audio briefing, and delivering via Telegram) while developing new skills in real-time. Hermes is tailored for tinkerers (with ML and reinforcement learning tools) and supports open models (e.g., Qwen 3.5), whereas OpenClaw doesn’t officially recommend this. OpenClaw has advantages though: massive developer resources (OpenAI, Nvidia), daily updates, larger community, and somewhat higher stability.

  The central recommendation: don’t replace OpenClaw, but rather use both together. The optimal workflow uses OpenClaw as the main orchestrator, activating Hermes for specific tasks when needed, or runs both in parallel (e.g., Hermes in CLI for frontend code with GPT, OpenClaw/Hermes for backend with Claude). For this, you only need to set up ACP (Agent Communication Protocol). An additional benefit: if one fails, the other can fix it, serving as “insurance”.

  Explicitly covered models/tools: Claude (Opus), ChatGPT, Qwen 3.5, Minimax, Obsidian, Excalidraw; providers: OpenAI, Anthropic, Nvidia — demo/comparison with practical workflows.

• LIVE: Hermes vs OpenClaw live tests
  30.3.2026, 20:12:08

  Summary: LIVE Hermes vs OpenClaw Live Tests

  The streamer compares two AI agent systems: Hermes Agent (new and hyped) and OpenClaw (established). He deliberately waits several weeks after Hermes’ release before commenting, rather than rushing out superficial 20-minute videos like other creators – this technology is too complex for shortcuts.

  Hermes strengths:

  • Complete transparency: displays every tool call, every memory update in real-time
  • Self-improving skills: automatically creates and updates its own abilities after each task
  • Security: security checks on every skill creation
  • Better performance: doesn’t slow down over time like OpenClaw
  • Trusts the audience more: explicitly built for local open-source models (unlike OpenClaw’s more restrictive approach)

  Hermes weaknesses:

  • Memory compactions catastrophic: When memory gets compacted, the agent forgets everything, becomes disoriented, and can abort tasks
  • Had to build a custom memory system for this
  • Can’t edit itself well: when instructed to modify its own files, it makes errors

  Overall verdict: Not yet mature enough to recommend because stability issues are too frustrating – OpenClaw remains better, despite Hermes’ interesting approaches.

  The streamer plans a detailed video later today with concrete workflows and a final recommendation. He also critiques other creators for publishing content too early without deep testing, reflecting content incentives (quick clicks with extreme statements).

  Demo, early impressions on Hermes Agent and OpenClaw (two open-source AI agent frameworks) – no other specific models/providers centrally discussed.

Andrej Karpathy

No new videos in this period.

Bart Slodyczka

No new videos in this period.

Ben AI (1 new video)

• CLAUDE COWORK FULL COURSE (2+ Hours)
  4.4.2026, 15:12:51

  Summary: Claude Cowork Full Course

  The complete course takes you from absolute beginner to expert in Claude Cowork – an AI-agent tool for non-technical users to automate tasks in marketing, sales, operations, and beyond.

  Core course topics:

  Setup & Basics: After installation (requirements: Pro account or higher, desktop app only), you access the Cowork function, which under the hood is a true AI agent – not just a chat.

  File access & Projects: You can grant Cowork access to computer folders so Claude maintains persistent context (e.g., business documents, YouTube transcripts). The new “Projects” feature bundles files, chats, and specific instructions into one unit, allowing Claude to automatically use the right context.

  Connectors & Integration: Cowork connects to external tools via built-in connectors (Google, Notion, Slack, etc.), MCP servers (standardized API packages), browser access, or computer control. Native connectors are most efficient, followed by MCP servers; browser and computer control are token-intensive and slow.

  Skills (central concept): Skills are folders containing instructions, code, and reference files that teach AI agents to execute specific processes precisely – like system prompts for specialized tasks. A skill consists of a skill.md file (SOP) plus optional reference files (examples, style guides, code scripts, assets). The course emphasizes: good skills emerge through iterative improvement, not one-shot prompts. Evals and A/B tests enable automated skill testing and optimization (e.g., for copywriting style, speed, token usage).

  Plugins: Bundled packages of skills, commands, agents, and connectors (e.g., Sales Plugin, Marketing Plugin). They enable workflow automation across multiple skills and are easy to share within teams. The course predicts plugins could transform the SaaS business model – with Cloud Cowork becoming the central interface for all workflows.

  Practical use cases:

  • Marketing automation (copywriting, research, ideation, visual assets)
  • Sales automation (prospecting, outreach, call prep, follow-ups)
  • “AI Operating System”: A shared knowledge pool (hundreds of files) as memory for the entire team

  Key insights: Skills and plugins are the future of agent-based work. Anyone can create them through prompting – but best practices (clear process steps, high-quality reference files, human-in-the-loop checkpoints, progressive updates) distinguish good skills from mediocre ones. The course emphasizes context engineering as a critical success factor.

  Tools explicitly covered: Claude Cowork, Claude Code (mentioned as similar, but for engineering), MCP servers, Ampify (scraping connector for social media), Notion, Google, Slack, Airtable; also mentioned: Salesforce, ServiceNow, Adobe — Tutorial (in-depth with extensive practical focus on skill-building and evals).

Brian Casel (1 new video)

• The Skill AI Can’t Replace
  31.3.2026, 12:01:03

  Summary: The Skill AI Can’t Replace

  The core thesis of the video is that Restraint – the discipline of choosing focus over capability – is the critical skill that AI cannot replace. With the speed that AI-powered development enables, the old bottleneck (slow execution) has disappeared. This leads teams to build everything they can instead of everything they should – drowning products in feature bloat.

  The problem in practice: An example shows a focused client portal tool that gets bloated by enterprise requirements (invoicing, time tracking, project management). Each feature can be built over the weekend with AI, but attracts the wrong customer segments and dilutes the original identity. The solution: Say no or use integrations instead of features – restraint preserves product focus.

  The technical layer: All major coding tools (Claude Code, Cursor, Codeex) have standardized “Plan Mode” as a first-class feature – mostly accessible via Shift+Tab. This shows that spec-driven development has become the industry standard. The speaker demonstrates how the same PRD gets converted into technical implementation plans in all three tools.

  What’s missing: Before starting Plan Mode, the strategic phase needs to happen – the shaping conversation. The proposal is a template prompt for Claude: brain-dump the raw idea, target customer segment, core problem, and actual customer feedback. Claude should then act as a critical strategic partner, ask clarifying questions, challenge assumptions, and uncover scope-creep risks. Goal: extract artifacts like problem statement, scope boundaries, and core user flows.

  The conclusion: This is the work AI doesn’t do – strategic judgment, feeling the voice of the customer, saying no to good ideas when they’re not right. AI can pressure-test thinking and surface trade-offs, but cannot decide what the product should be.

  Spec-driven development, opinion/reflection, with Claude Code, Cursor, Codeex, Nimbleist and strategic product development.

Coding with Lewis

No new videos in this period.

Cole Medin (3 new videos)

• I Taught My Second Brain to Run Multi-Agent Coding Workflows (Live Session)
  2.4.2026, 16:41:55

  I Taught My Second Brain to Run Multi-Agent Coding Workflows (Live Session)

  The host presents Archon, a workflow engine for deterministic and repeatable AI-driven coding processes — essentially an orchestration tool similar to n8n, but for software development. Archon combines deterministic nodes (Bash commands, guaranteed validation steps) with non-deterministic nodes (agent prompts) to make complex development workflows automatable.

  Core features:

  • Workflows consist of deterministic and non-deterministic steps; this solves the problem that coding agents regularly forget to execute configured steps
  • Pre-built workflows for fixing GitHub issues, code reviews, PRD creation, and PIV-loops (Plan-Implement-Validate)
  • Support for parallel workflows, work trees, and isolation
  • Configurable models and providers per node (e.g., Haiku for research, Opus for implementation)
  • Integration with “Adversarial Dev” philosophy: separate agent sessions for implementation and evaluation to avoid bias

  Integration with “Second Brain”:

  The host uses his AI-powered command center (a Claude Code setup called “Dynamis Engine”) to orchestrate Archon workflows. He can simply say “Fix these GitHub issues” or “Run 4 issue fixes in parallel” from the second brain, and the system handles the complexity.

  Workflow example (built live):

  The host demonstrates building an “Adversarial Dev” workflow from scratch: a planner expands a user request into a spec, followed by a loop that defines sprints, then a generator (implementation), contract negotiation (evaluation criteria), and a separate evaluator (in a new session, no bias). On misevaluation, the evaluator feeds back to the generator (max 3 iterations per sprint).

  Performance gains:

  The host reports that his AI-powered coding with Archon is about 100× faster than manual programming from 3 years ago (10× through Claude Code, another 10× through Archon). Parallel workflows mean dozens of issues can be processed simultaneously.

  Release:

  Publicly available next Wednesday; a tutorial-focused live stream on getting it running next Saturday.

  Explicit technologies: Archon (unreleased main topic), Claude Code, Codex, Claude Agent SDK, Anthropic Subscription, GitHub API; Format: Live Q&A with live demonstration and workflow building; Difficulty: designed for advanced developers.

• Full Guide – Build Your Own AI Second Brain with Claude Code
  2.4.2026, 00:00:03

  Summary: Full Guide – Build Your Own AI Second Brain with Claude Code

  The creator showcases his “Second Brain” system developed over three months using Claude Code, which saves him about a dozen hours of work per week. The system consists of three core components: the memory layer (inspired by Open Claw with soul.md, user.md, memory.md), skills for specific tasks, and a heartbeat for proactive automation.

  Memory layer: Markdown documents are automatically loaded via session hooks in Claude Code. A daily reflection process (via Claude Agent SDK and Cron job) extracts important decisions and facts from the raw daily log, promoting them to memory.md. In parallel, all daily logs are indexed into a SQLite database for RAG access. Obsidian integration enables visual overview and manual corrections of the evolving knowledge graph.

  Skills & Integrations: The creator uses Claude Code exclusively with skills — no separate MCP servers or other apps. His skills are highly personalized through the memory layer (e.g., Excalidraw diagram skill). For integrations with Gmail, Asana, Circle, Slack, etc., he follows a zero-trust model: read-only by default, then selectively grant write permissions (e.g., create Gmail drafts, but not send). These API-layer integrations follow a reusable pattern that allows the agent itself to plan and build new integrations.

  Heartbeat: A cron job deterministically collects API data (emails, tasks, GitHub PRs, etc.), sends the context to Claude Code for reasoning, and notifies the creator via Slack of completed actions. This saves the most time — automation without manual prompts.

  The “Lethal Trifecta” problem: The creator argues against pre-built solutions like Open Claw by explaining the security risks of agents with (1) private data access, (2) untrusted content, and (3) exfiltration vectors. All three apply to second brains; a self-built system provides control over permissions and simplicity rather than a large, hard-to-understand codebase.

  Template & PRD process: Instead of complete source code, the creator provides a requirements markdown and a skill (“create second brain PRD”) that generates a phased requirements document. You fill in information about integration platforms, proactivity level (observer/advisor/partner), security boundaries, and priorities, feed it into Claude Code, and get a PRD with phases from the memory layer through skills and heartbeat. Each phase can then be implemented sequentially.

  Focus on simple, composable patterns rather than complexity — the creator emphasizes that you can build a system equally powerful as Open Claw in just a few days, but significantly more maintainable and secure.

  References: Claude Code, Obsidian, Claude Agent SDK, Open Claw (as inspiration), integrations with Gmail, Asana, Circle, Slack, GitHub — opinion/reflection with practical tutorial element.

• Coding Agent Reliability EXPLODES When They Argue (New Adversarial Dev Technique)
  30.3.2026, 16:30:05

  Summary: Coding Agent Reliability through Adversarial Methods

  The central problem with AI coding is “sycophancy” (confirmation bias): coding agents agree too readily with their own assessments and miss their own errors — like a student grading their own homework. The solution lies in a multi-agent architecture with adversarial design: a generator agent writes code while a separate evaluator agent acts as a “nitpicky QA engineer” to critically review and question its implementation.

  Inspired by Generative Adversarial Networks (GANs), a three-stage process is established: (1) A planner converts the user request into a detailed product specification, (2) generator and evaluator negotiate a contract upfront — how the spec is divided into sprints and what evaluation criteria apply — (3) The sprint loop iterates: the generator implements, the evaluator scores (1–10 points per criterion with thresholds), the generator revises up to three times. Only when all criteria are met does the next sprint proceed.

  The speaker demonstrates this with a fully generated RAG application (YouTube content ingestion with frontend and backend) created with Claude Sonnet 3.5 in about 4 hours — without manual intermediate steps. The implementation is available as an open repository with Claude and Codex versions; locally only a prompt is needed, the rest runs automated. The overhead consists of higher token consumption but is offset by increased reliability and the ability to use weaker models.

  Tools/Models covered: Claude (Sonnet 3.5), Codex, Anthropic research, generic GAN concept — Format: Tutorial/demo with productive architecture guidance.

Datapizza (2 new videos)

• Cos’è Claude Mythos e perché tutti ne parlano
  31.3.2026, 15:00:00

  Summary: “Cos’è Claude Mythos e perché tutti ne parlano”

  The podcast covers three major topics from the AI industry:

  Claude Mythos – Anthropic’s new super-model:

  A data leak revealed documents showing the existence of a new, not yet released Anthropic model called Mythos (also called Capibara or Cloud Mythos). It’s supposed to be more powerful than the current Opus 4.6 and would have approximately 10 trillion parameters (for comparison: Sonnet has 100–300 billion). Mythos is said to excel particularly in multi-step logic, code, and cybersecurity – but can identify security vulnerabilities so quickly that it’s considered a dual-use risk. Anthropic is pursuing a controlled release strategy, initially giving access only to security organizations to map out potential misuse cases in advance. Model size and compute power are so enormous that Anthropic is asking users to exercise restraint.

  Google’s Turbo Quant – Saving computational power:

  Google has released an optimization method that makes the inference phase (queries to models) easier. It works through query caching (pre-caching system prompts) and vector optimization in RAG applications – in both cases achieving approximately 25% reduction in memory requirements.

  Sora’s discontinuation – The end of OpenAI’s video app:

  OpenAI has unexpectedly discontinued Sora, its video generation model, and removed it from app stores. Reasons: computational resources don’t justify the returns, there was no functioning monetization model, copyright issues were significant, and OpenAI is strategically focusing on enterprise solutions rather than social media features. A planned multi-billion dollar deal with Disney for Sora integration has fallen through.

  Overarching theme: The AI market is in a consolidation phase – companies are still experimenting widely, but will soon specialize and reprioritize resources.

  Mentioned tools/models: Claude (Anthropic) with Mythos as new model, Google, OpenAI with Sora, also mentioned: Gemini, Sonnet, Haiku, Veo, Kling, Sider. – Format: News update/roundup.

• OpenAI vs Alibaba, chi sta vincendo la corsa all’AI?
  30.3.2026, 15:04:30

  Summary: OpenAI vs Alibaba – Who’s winning the AI race?

  The transcript is not a comparison between OpenAI and Alibaba as the title suggests, but rather a live discussion episode (Caffè) of the Datapizza team on current AI news.

  Main topics:

  GPT-5.4 Thinking – OpenAI has released an update that allows interrupting and adjusting the thinking chain phase of a reasoning model during the process. The team discusses why this feature comes now – over eighteen months after the introduction of reasoning models. Speculation: this required extensive human feedback training (Human Frontier) to create datasets where real people intervene and correct the model while it’s thinking.

  DeepSeek R1 & Reasoning Mechanics – Detailed deep-dive into a DeepSeek paper on reasoning: the model learns through few-shot prompting to structure its thoughts in special tags. However, there are academic indications that this “thinking” doesn’t always correlate with actual output – a kind of simulated thinking.

  GPT-5.2 Pro in physics – An OpenAI paper shows how GPT-5.2 (internally optimized) reasoned for 12 hours on complex gluon amplitude formulas and thus helped solve a physics problem requiring hundreds of pages of formulas. The team remains skeptical about whether this is a real breakthrough or “hard-coded” for this specific case.

  Gemini Embedding 2 – Google has released a new multi-modal embedding model that processes text, images, video, and audio together and can even embed entire PDFs (up to 6 pages) – practical for RAG applications. In parallel, Cohere Embed v4 exists.

  Anthropic vs. Alibaba drama – Mention of a “gossip” moment around Anthropic and Alibaba; details are missing from the transcript.

  Akathon 2 – The team reports on their second hackathon edition (Feb–March) with ~120–130 participants and plans expansion to Rome.

  Data Pizza Release 0.1.0 – Mention that they released a new version of their internal tools/frameworks focusing on agents; details on “agent evaluation” remain secret for future episodes.

  The format is more of a roundup and live discussion with speculative analysis of AI companies’ business priorities; Alibaba is hardly treated concretely. The team philosophically debates whether transformers are “the way” and what an agent really is.

  Applications: GPT-5.4, DeepSeek R1, Claude/Anthropic, Google Gemini Embedding 2, Cohere Embed v4, Perplexity – Format: Roundup/live discussion, opinion/deep-dive on product development by OpenAI, Anthropic, and Google.

Greg Baugues

No new videos in this period.

AI and Strategy | Le SamourAI (2 new videos)

• Claude Mythos: the secret model and the tragic mistake that makes Anthropic tremble
  2.4.2026, 11:36:42

  Summary: Claude Mythos – Anthropic’s critical missteps

  The video analyzes a series of security breaches at Anthropic spanning five days in March 2025. On March 26th, researchers discover an open database containing the company’s blog content, where they find a document about Claude Mythos (internal name: Capibara), Anthropic’s most powerful model to date with cybersecurity capabilities that the company itself considers unprecedentedly risky, and whose deployment it deliberately delays.

  The paradox: while Anthropic blocks the launch, detailed plans lie unprotected in public storage—the result of a simple configuration error without password protection. Five days later (March 31st), the second catastrophe follows: a cloud code update accidentally contains a massive debug file with half a million lines of code—the entire product’s source code archive. An intern immediately notices the anomaly; the code gets pulled to GitHub before Anthropic can respond. Developers discover “undercover,” a secret system instructing Claude to hide its artificial nature, along with details about internal anti-competition traps.

  The same day, Axios, a software component of Claude Code, gets infiltrated by North Korean hackers—malware runs on the download platform for three hours. A South Korean developer then uses OpenAI AI to translate the leaked code into Python and publishes the project as “Clocode” on GitHub. The project reaches 50,000 stars in two hours—a GitHub speed record.

  The bigger context: Anthropic signed a 200-million-dollar contract with the U.S. Department of Defense in July 2025. When the Pentagon later demands unlimited access for all legal purposes, Anthropic draws two red lines: no lethal autonomous weapons, no mass surveillance on U.S. soil. The conflict escalates—on February 24th, Defense Secretary Pete Hegseth issues an ultimatum until February 27th. Anthropic CEO Dario Amodei refuses. The President orders all federal agencies to halt Anthropic technology and classifies the company as a “supply chain risk”—a designation previously reserved only for foreign intelligence agencies or terrorist organizations. On March 26th, a judge blocks this measure in a 43-page decision as illegal retaliation.

  Core argument: The author identifies a “structural clarity threshold”—the point at which an organization produces faster than it thinks about itself. At Anthropic, this happens through massive deployment of Cloud Code (AI-powered code generation), which increases speed but bypasses critical control steps. The core problem isn’t malicious intent but game theory dynamics: if one lab breaks the security pact and accelerates, competitors can’t afford to slow down—everyone loses their position. The result: universal defection, everyone steps on the gas. The author calls this “cognitive exit costs”—the point where organizations become so dependent on an AI tool they can’t shut it down even after massive leaks.

  Practical warning: The author formulates a “pilot test” for users: First—do you know what your AI tool does in the background? Second—how do you know that (manufacturer documentation or independent technical verification)? Third—how long would it take you to be operationally autonomous if the provider fails tomorrow? Anyone who can’t answer these questions isn’t a pilot but a passenger. The absence of customer reaction to the Anthropic crisis proves not acceptance of risk but blind dependency—and this inaction validates the provider’s risk appetite in turn, increasing pressure to accelerate.

  Additional points from the data: Exploits now account for 40% of AI security incidents; AI can forge malware in 15 minutes for pocket change. The British CLTR has registered ~700 cases of intentional “deception” in 180,000 conversations—numbers recently multiplied. Gartner predicts 40% of autonomous AI projects will be canceled by 2027. An internal Anthropic report documents eight absolute catastrophe scenarios where security systems are regularly bypassed by performance systems—paralleling the 2008 financial crisis when overly complex products exceeded their overseers.

  The author ends with personal reflection: to explain this video, he himself had to reproduce the same pattern—working through the night, sacrificing nuance to obey an algorithm rewarding speed. That’s Silicon Valley’s structural dominance—not just software, but an entire philosophy of urgency has been exported.

  Explicitly covered: Anthropic and Claude, OpenAI, Cloud Code, the U.S. Department of Defense, GitHub, Palantir, Gartner, and various security research groups—opinion/reflection with deep-dive elements.

• What they won’t tell you about Mistral AI’s 830 million
  1.4.2026, 14:30:20

  Summary: “What they won’t tell you about Mistral AI’s 830 million”

  The video critically analyzes what really stands behind the French AI startup Mistral’s financing announcement—not venture capital but debt financing against physical collateral.

  The real story

  On March 30th, 2026, seven banks (including BNP Paribas, Crédit Agricole, HSBC) structured 830 million dollars in debt. The special part: they accepted 13,800 Nvidia GPUs (Blackwell series) as collateral—not real estate, but chips. This is the first time traditional European banks have treated processors as bankable assets.

  Why it works: physical scarcity

  The author reveals three central market factors:

  1. HBM memory (High Bandwidth Memory) is sold out for 2025; already allocated for 2026. SK Hynix confirms “vendor-driven market”—the seller sets the terms.
  1. Price explosion: HBM memory has become 90–95% more expensive within a year (quarterly, not annually). The memory technology feeding the chips has tripled.
  1. Geopolitical shockwave: On March 18th, 2026, Iranian airstrikes hit the Ras Laffan complex in Qatar—the world’s largest LNG production facility and critical helium supplier (1/3 of global supply). Qatar Energy declared Force Majeure. Helium is essential for semiconductor production (cooling during UV lithography). Spot prices doubled immediately.

  Result: supply is constrained, demand continues (hyperscalers like Google, Microsoft, Amazon, Meta are investing 600+ billion dollars in 2026 alone). The chips become a store of value—their resale value exceeds the purchase price during the loan term.

  Mistral strategy: four revenue streams build on each other

  1. Chat API inference: token-based pricing (10 cents to 2 dollars per million tokens)
  2. Mistral Code: enterprise IDE integration for European teams
  3. Open Models (Mistral 7B, Ministral): free to download → developer lock-in
  4. Forge (March 2026): complete pre-training on customer data (expensive, highest switching costs)

  Each layer pulls users into the next. Computing capacity → revenue → debt service → more chips → more revenue. Self-reinforcing loop.

  Winners / losers

  Winners: European players with infrastructure plans and credible bank syndicates (pharma, defense, industry) wanting to compute under European jurisdiction → new financing window opens.

  Losers:

  • US cloud hyperscalers (AWS, Azure, GCP): structural conflict—every GPU for customers = one fewer GPU for their own AI services (Gemini, Copilot).
  • European startups without secured capacity: they rent GPU time from the US provider hourly, where the seller sets the rules. Wait lists grow.

  Why debt beats equity

  Objection: Mistral’s capital structure is US-dominated (Andreessen Horowitz, Lightspeed, Nvidia, Microsoft, Salesforce). Where’s the sovereignty?

  Answer: debt financing from European banks (BNP, Crédit Agricole) with European creditors anchors the infrastructure legally in Europe—not the capital structure, but collateral sovereignty. Financial claims follow European law; states can act at the hardware level.

  Three concrete steps for decision-makers

  1. Fragility test:
  • Does your cloud provider have a conflict of interest? (Does he sell similar AI services?)
  • If memory/helium prices triple → does your business model collapse?
  1. Leverage points:
  • Founders/managers: forget flexible cloud hourly rates. Lock in 12–24 months of capacity with European infra player (cost: ~15–20% premium, value: survival assurance).
  • Consultants/freelancers: stop “API integration sales pitch.” Sell supply chain risk diagnostics instead—be the one who sees the entire physical chain while others see chatbots.
  1. Indicators of thesis collapse:
  • HBM prices fall two quarters in a row.
  • TSMC publicly announces unused process capacity.

  Until then: window closes in quarters, not years.

  Core thesis

  Computing capacity is no longer operating costs—it’s the new strategic asset of the decade. Whoever doesn’t secure it becomes a buffer for competitors.

  Format & tools: deep-dive, opinion/reflection with macroeconomic analysis; Mistral AI covered (+ Nvidia, TSMC, SK Hynix, hyperscalers); no specific AI-coding tool discussed.

Julian Ivanov | AI Automation (2 new videos)

• I Built a Company Without Humans (Paperclip Tutorial)
  3.4.2026, 15:40:03

  Summary: I Built a Company Without Humans (Paperclip Tutorial)

  The creator built a company composed entirely of AI agents that supports his YouTube channel. It consists of eight agents with clear hierarchy: a CEO coordinates the team, a Trends Scout researches AI news, an Editorial Director leads video production with four sub-agents (Deep Researcher, Script Agent, SEO Strategist, Repurposer), and a Quality Agent reviews the work. The tool behind it is Paperclip, an open-source project that transforms AI agents into a self-organizing company – with real org charts, hierarchies, goals, budgets, and 24/7 operation.

  The problem Paperclip solves: OpenAI offers autonomous agents with heartbeat functionality (working around the clock), but lacks oversight and coordination between agents. Claude Code offers good control and collaboration via Agent Teams, but requires constant active monitoring and only runs in active sessions. Paperclip combines both worlds: autonomous round-the-clock work with organizational structure, oversight, and coordination.

  Core features of Paperclip: Agents gain identity through files (Agents.md for instructions, Soul.md for personality), an org chart with hierarchies, a ticketing system with full logging, Goal Alignment (every task tied to company mission), a governance layer (user approves decisions and pauses agents), budget management per agent, and compatibility with various language models (Claude, OpenAI GPT, Gemini, Cursor, OpenAI via Gateway).

  Practical setup: Paperclip can be installed locally or hosted on a virtual server (e.g., via Hostinger with direct template). After installation and admin account creation, API keys from various providers can be added or existing subscriptions (ChatGPT Plus, Claude) can be used. The tutorial demonstrates creating a sample company “Job Matcher”: the user defines the mission, the CEO is created, receives tasks, autonomously considers what additional agents are needed, and orchestrates their work. Every task is logged as an issue, agents can use Skills (prompts for specialized processes), and the user can provide targeted comments and feedback on tasks – not just in chat like other tools.

  Who it’s for: Paperclip makes sense if you need to coordinate multiple Claude Code sessions or different agent systems and require oversight, cost management, and 24/7 automation. Not ideal if you already work well with Claude Code alone, want a simple personal assistant (OpenAI), or need clear step-by-step workflows (N8N).

  Cost optimization: ChatGPT Plus or Claude subscriptions can be connected to Paperclip via device code authentication (e.g., Codex in the terminal) instead of paying for API tokens. The creator also shows how to install Codex in the server terminal and configure it via Paperclip, as well as how to use Codex itself to manage and debug the Paperclip instance.

  Explicit AI tools: Paperclip (open source), Claude, OpenAI (GPT-4), Gemini, Cursor, Claude Code, OpenAI, Codex, N8N, Hostinger (hosting), Supabase. Format: Tutorial (deep-dive with demo and practical setup walkthrough).

• Obsidian + Claude Code: Build Your Second Brain
  29.3.2026, 18:01:18

  Obsidian + Claude Code: Build Your Second Brain

  The video shows how to build a personal knowledge system that uses Claude Code (or Cowork) as an AI agent to manage and expand structured knowledge.

  Core problems being solved:

  Claude typically starts each session from scratch – without context about your projects, rules, writing style, or decisions. This leads to generic responses. Claude’s memory function is too limited for comprehensive project and context knowledge. At the same time, personal insights, learnings, and ideas are lost if not systematically documented.

  The solution: Obsidian as your “second brain”

  Obsidian is a local markdown-based note app where you store your knowledge in a structured way. Claude gains access to this entire vault and can independently create, organize, and link files. The advantage: your knowledge remains your property (local files, no cloud lock-in), is persistent, and can be made accessible to any AI tool.

  Recommended folder structure (8 folders):

  • Context: Information about you (writing style, background, ideal customer profile, branding, offering)
  • Inbox: Brain dump for unfiltered thoughts and daily notes
  • Projects: Tasks with fixed deadlines (later moved to archive)
  • Areas: Ongoing responsibilities without deadline (community, business, marketing)
  • Resources: General knowledge, tool documentation, templates, research
  • Daily Notes: Log – document daily accomplishments
  • Archive: Completed projects and tasks
  • Attachments: Images and files

  Setup steps:

  1. Install Obsidian from obsidian.md, create new vault
  2. Enable community plugins (Settings → external extensions)
  3. Install BRAT plugin (enables beta plugins)
  4. Add Claudian plugin via GitHub repository (enables Claude chat directly in Obsidian)
  5. Install Obsidian Skills (via GitHub repo – teaches Claude how to work with Obsidian)
  6. Download the provided “Cloud.md” file (with onboarding prompts) and place it in the vault root
  7. Tell Claude: “Do the onboarding” – he interviews you, creates personalized folder structure, and finalizes the system prompt

  The Cloud.md file:

  After onboarding, it serves as the standardized system message for Claude. It contains:

  • Brief info about you
  • Vault structure (so Claude knows where to search)
  • Rules for vault management
  • Session start instructions (e.g., check inbox, offer new notes)
  • Session end instructions (e.g., write daily note, clean up inbox)

  Practical workflows:

  • Daily work: Work in Claude Cowork or directly in Obsidian with Claudian chat; Claude automatically reads recent daily notes and active projects at session start
  • Weekly review: Claude evaluates daily notes from the week, tracks completions
  • Meeting processing: Load transcripts into inbox folder, Claude processes and automatically saves info to the right folders
  • Project context: For similar new projects, tell Claude to use old projects as reference

  The compound effect over time:

  • Week 1: ~15–20 files, Claude knows basic info
  • Month 1: ~40–60 files, projects documented, writing style defined – significantly better output quality
  • 3 months: ~100 files, Claude knows workflows and decision history, suggests connections himself
  • 6 months: True knowledge system; every piece of info connects with existing knowledge; your context becomes a transferable asset

  5 practical tips:

  1. Don’t aim for perfect structure from the start – let it grow organically
  2. Don’t skip daily notes (only 30 seconds, but huge long-term payoff)
  3. Don’t migrate everything at once – build incrementally
  4. Make “remember that” a habit when Claude generates something or you establish a rule
  5. Update/expand the Cloud.md file regularly (Claude can do it himself if you tell him)

  Visual design (bonus):

  Anup Puccin theme + Style Settings plugin + rainbow colors in graph view for better overview of folder clusters.

  Availability: Cloud.md file as free download via newsletter subscription in video description download hub.

  Tools/providers: Claude (Anthropic), Obsidian, Claude Code, Cowork, Claudian plugin, BRAT plugin, Style Settings plugin, Anup Puccin theme, VS Code — Tutorial with demo elements.

Kyle Balmer | AI with Kyle (4 new videos)

• The $100/Day Newsletter System Nobody Talks About
  1.4.2026, 17:00:07

  Summary: The $100/Day Newsletter System Nobody Talks About

  The core of the system is generating leads through short-form video content (60-90 seconds) on hot topics while immediately making money. The process: create a video with a call-to-action (e.g., comment with a specific word), which leads through ManyChat or Claude-based automation to automated responses that direct users to a landing page with a lead magnet.

  Revenue comes from multiple levels: (1) SparkLoop monetization – when newsletter subscribers sign up for recommended newsletters, the publisher gets approximately $1-2 per signup, potentially $5+ when multiple newsletters are accepted. The creator shows concrete payouts: $120, $300, $320, $350, $700 in monthly payments, which at the current pace generates about $100/day. (2) The system scales through weekly or daily new lead magnets – the creator produces new content daily, converts it into lead magnets and landing pages, sets up ManyChat triggers, and promotes on Instagram.

  Critical success factors: Lead magnets must be high-quality (first impression matters), automation runs through ManyChat or Claude as scheduled tasks for automatic comment responses. The infrastructure uses Beehiiv (newsletter platform with its own monetization feature called “Boosts,” which the creator doesn’t recommend as much), SparkLoop for affiliate monetization, and artificial intelligence to generate landing pages and lead magnets. The creator emphasizes: email lists are essential, don’t rely on social media – the system has built him a six-figure business in two years.

  Deep-dive demo focusing on newsletter monetization via Beehiiv, SparkLoop, and ManyChat; covers Claude and AI-powered automation.

• How I Get 200+ Email Subscribers a Day Using AI, ManyChat & Spark Loop
  1.4.2026, 06:15:02

  The creator shows his system for gaining 200+ email subscribers daily, based on two years of building from zero to mid-six-figure income. The core principle: move people from social media into an email list, as it’s your own asset — unlike the fragile dependence on algorithms and platform policies.

  The process has five steps: (1) Create a simple conversion video (60-90 seconds) on a trending topic, (2) establish a trigger keyword that users can comment with, (3) create an opt-in landing page, (4) set up automation via ManyChat (for Instagram) or Claude Code Scheduled Tasks (for TikTok, YouTube Shorts), (5) repeat continuously. The video should be top-of-funnel content — very simple, clear concept, no deep knowledge required.

  Automation happens through: ManyChat for Instagram automation, where comments trigger a DM with a link; Claude Code for other platforms to automatically respond to comments and direct to the link in bio. Landing pages and lead magnets are generated with Claude Code — based on video transcripts or live streams. Once established, the system can be repeated daily.

  Monetization runs in parallel: With SparkLoop (or Beehiiv’s “Monetize Boosts”), newsletter recommendations are made to new subscribers; for each successful signup, the publisher gets roughly $1-2. The creator earns about $100/day (~$3000/month) just from these recommendations. The email list itself (45,000 subscribers for him) is the foundation for further offers.

  Critical: Lead magnets must be high-quality (first impression counts), the volume of parallel giveaways prevents confusion since social media users won’t see everything. The system is not fully automated — the human is at the beginning (live, video, opinion), then it flows through AI into newsletters, scripts, PDFs, short-form content. Recommendation: Don’t start daily, begin weekly instead.

  Tools explicitly mentioned: Beehiiv (newsletter platform), ManyChat (Instagram automation), Claude Code (automation & content generation), SparkLoop (newsletter monetization), Kit/ConvertKit and Substack (alternatives), NotebookLM (content structuring) — mix of demo/opinion with instructional elements.

• The NotebookLM Strategy That Builds My Email List on Autopilot
  31.3.2026, 18:15:00

  The creator shows a strategy for automated email list building with NotebookLM. The core concept works on two levels: frontend assets for grabbing attention (infographics, carousels) and backend assets

  Practical application: videos or content are uploaded to NotebookLM to automatically generate usable assets. One example is converting a one-hour video about Claude Code into a slide deck or guide, then placing it as a lead magnet on the website – this brings the creator hundreds of people daily to his email list.

  An additional pro tip: you can also take successful videos from others (like on tax topics or trends), upload them to NotebookLM, and convert them into reports with your own branding – focusing on specific target audiences like “HENRYs” and creating reports, mind maps, or infographics.

  For maximum scaling, the creator uses a system with a research agent that automatically finds trending topics, plus an unofficial Python API for NotebookLM (via Claude Code) to fully automate asset generation – instead of clicking through manually piece by piece. This enables systematic, automated lead magnet production. The creator mentions that an official NotebookLM API doesn’t exist yet.

  NotebookLM and Claude Code as explicit tools; demo with practical use cases.

• NotebookLM Masterclass: Create Presentations, Hallucination Free Content Creation and it’s FREE
  31.3.2026, 05:15:00

  Summary: NotebookLM Masterclass

  NotebookLM is a free Google tool that functions as a personal RAG system (Retrieval-Augmented Generation) and prevents hallucinations by drawing information only from sources provided by the user — not from general training data. You can upload PDFs, URLs, YouTube videos, slides, audio files, EPUBs, and websites, which the tool then works with. The core idea of RAG: a query is first matched against the provided documentation before the language model generates an answer – this produces reliable, source-backed outputs.

  The interface has three main elements: sources (left), chat for querying content (center), and various output formats (right). The latter include slide decks, infographics, podcasts (with the option to participate yourself), mind maps, reports, flashcards, quizzes, and animated videos (in cinematic, explainer, or brief styles). All generated content is source-attributed, which is essential for lawyers, academics, and other professionals.

  The speaker uses NotebookLM primarily for two business applications: (1) Daily live stream presentations – he automatically creates slide decks from sources to go live daily on YouTube, Twitter, and other platforms; (2) Lead magnet generation – he takes successful own videos or popular videos from others, creates slide decks or PDF guides from them (with his own branding and adjusted focus), and uses these as bait for email addresses. This way, you can generate multiple market-ready assets from a one-hour video with minimal effort. You can also manually add notes to control the output, or edit the generated slides afterward.

  For large-scale automation, you can use the unofficial Python API to build research agents via Claude Code that identify trends and automatically generate assets. On the older question of which Google subscription you need: none – NotebookLM is completely free with a standard Google account.

  The speaker emphasizes this isn’t “AI slop” but a genuine education and productivity tool because quality and direction are controlled by the sources provided and the user, not by generic training data noise.

  Demo/review of a Google tool (NotebookLM/Gemini) in live show format; geared toward advanced users interested in automation options, but also accessible to beginners.

Leon van Zyl (3 new videos)

• Paperclip is Insane – I Built a Full AI Company
  3.4.2026, 11:27:16

  Paperclip: A fully automated AI software company

  The user demonstrates Paperclip, a framework that organizes multiple AI agents in a hierarchical corporate structure. Instead of using individual coding tools like Claude or Cursor directly, you delegate tasks to a CEO agent who distributes work to specialized sub-agents – marketing lead, CTO, engineering lead, frontend/backend developers, QA engineers, security specialists, and other roles. Each agent can be configured with individual prompts, skills, and models.

  Setup & Deployment: Paperclip is installed locally via Node.js command or on a VPS (e.g., Hostinger with Docker). For authentication, you use either Claude Code subscription or API keys. After registration, you define the company vision and assemble your team.

  Workflow: You create issues/tickets and assign them to the CEO, who forwards them on. The CEO can request approvals from the user (e.g., to confirm new hires). All communication runs through tickets and inbox. In the dashboard, you see live status of all agents, their activities, and cost overview when needed.

  GitHub Integration: Agents can commit directly to GitHub repositories, create branches, and open pull requests – fully automated. You set up a deploy key so agents are authenticated.

  Critical Assessment: The creator considers this impressive from an implementation perspective but still recommends reviewing and verifying code before using it in production.

  Explicitly mentioned tools: Claude, Claude Code, Cursor, Paperclip (41,000 stars after just weeks), GitHub, Vercel, Netlify, Hostinger, AutoForge (creator’s own project). Demo with deep-dive into setup and practical application.

• The Only Claude Code Tutorial You Need (2026 Update)
  1.4.2026, 14:01:14

  Claude Code Tutorial (2026 Update) – Summary

  This video is a comprehensive tutorial on Claude Code, Anthropic’s coding tool for developing real web applications. It’s aimed at both beginners and experienced developers and shows that even non-technical people can build websites and tools with it.

  Access & Installation

  Claude Code is available through multiple channels: the Claude website, the desktop app, or as a CLI tool in the terminal. For the desktop app, you need to download a link; the CLI tool is set up via installation command (for Windows, Mac, Linux). A Claude subscription (Pro plan around $20/month) is required.

  Core Features of the Desktop App

  • Chat Interface: You send messages to Claude, can attach files (PDFs, images, screenshots) and connectors
  • Modes:
  • “Ask Permissions” – Claude asks before making changes
  • “Auto Accept Edits” – makes changes without asking, but asks before commands
  • “Planning Mode” – discusses only, no implementation
  • “Bypass Permissions” – automates everything (riskier)
  • Model Selection: Opus (powerful, for planning), Sonnet (middle ground), Haiku (fast, cheap)
  • Voice Input: Give voice instructions with a button click
  • Live Preview: Embedded browser shows the running application in real-time

  CLI Tool Specific Features

  • Switch modes with Shift+Tab
  • Insert files via drag-and-drop or Alt+V (screenshots)
  • Slash commands (/model, /effort, /voice) for settings
  • --dangerously-skip-permissions flag for automated execution

  Workflow: Income & Expense Tracker App

  1. Project Setup: Create new folder, create-agentic-app command for boilerplate (Next.js, React, Drizzle ORM, PostgreSQL, BetterAuth, Vercel Blob Storage)
  2. Docker Database: Install Docker Desktop, let Claude execute database setup commands
  3. Planning Mode:
  • First create a PRD (Product Requirements Document) in the chat view
  • Then go to Planning Mode, insert PRD, Claude asks clarification questions
  • Implementation plan gets saved in .cloud/plans/
  1. New Session for Implementation: Save fresh context, insert the plan
  2. Design System: Claude first creates a UI design system (using Front-End Design Skill from the boilerplate), saves it under docs/design-system/
  3. Claude.md File: Set project-specific rules here (e.g., “always reference design system”) – apply in CLI and desktop
  4. Loop Command (/loop): Automated cron jobs, e.g., check UI every 10 minutes and compare against design system
  5. Sub-Agents: Instead of having one agent do everything, split the work: agent divides work into waves, fires multiple sub-agents in parallel (faster, more efficient)
  6. Testing & Debugging: Claude tests the app itself end-to-end, spots bugs (e.g., 500 errors on dashboard) and fixes them automatically
  7. Remote Control: Mobile app for Claude allows remote control from your phone

  Additional Features

  • Plugins: Extend model capabilities (e.g., Gmail connector)
  • Slash Commands: /model, /thinking (Reasoning Mode), /effort (low/medium/high/max), /voice, /context (shows context usage)
  • Thinking/Reasoning Mode: Agent analyzes the problem first before making changes – costs more tokens, better quality
  • VS Code/Cursor Integration: Button in desktop app jumps directly into code editor
  • Dev Button: View all changes from a session
  • Deployment: Covered in separate video

  The focus is on Claude Code using autonomous agents to build complex applications – user provides requirements, Claude plans and implements, tests itself and fixes bugs.

  Explicit tools: Claude Code (desktop & CLI), Claude models (Opus, Sonnet, Haiku), Next.js, React, Drizzle ORM, PostgreSQL, BetterAuth, Vercel Blob, Vercel AI SDK, Docker, Airtop (mentioned as sponsor for monitoring AI tool updates), Gintik Labs (learning community) – Format: Tutorial (for beginners to advanced) with live demo of complete app development.

• Claude Code Tutorial: Build an AI Brand Monitor App
  30.3.2026, 13:01:05

  Claude Code Tutorial: Build an AI Brand Monitor App – Summary

  The video shows how to build a practical business application with Claude Code (or alternatively Cursor): an AI Brand Monitor. Instead of developing toy projects, the instructor focuses on a real problem that companies want to solve.

  The Problem: While companies traditionally do SEO for Google, information search is increasingly shifting to AI assistants like ChatGPT, Perplexity, Gemini, Grok, and Copilot. If a brand isn’t mentioned there, the company loses traffic and visibility – but most don’t know this. The app monitors which AI models recommend a brand and which don’t.

  Key Difference from Simple API Integration: The instructor emphasizes you shouldn’t call model APIs directly. Instead, the app scrapes the actual user interfaces (the ChatGPT website itself, not the OpenAI API) because these contain additional features, optimizations, and geographic adaptations not available via API. For Copilot, there’s no public API either.

  Tech Stack: Next.js frontend, React, SQLite database, Drizzle ORM, and Bright Data as a web scraping service to scrape responses from ChatGPT, Perplexity, Gemini, Grok, Copilot, and Google Search.

  Architecture: The scraping process follows an established pattern: Trigger (POST request to Bright Data) → Polling (GET requests to check status) → Download results. Bright Data returns whether the brand was mentioned, along with quotes and links.

  Implementation with Coding Agent: The instructor uses Cursor with Claude (Opus 4.6) instead of Claude Code to implement the logic. Important: They use Plan Mode and feed the agent extensive documentation, example payloads, and even similar GitHub projects to get better results (context engineering).

  Problem-Solving: When Copilot fails because different providers expect different input parameters, the instructor copies example payloads from Bright Data and feeds them to the agent – the bug is fixed immediately.

  Robustness & Scaling: The first version runs synchronously. To become production-ready, the instructor integrates Inngest, a background job queue. Each scrape now runs asynchronously as a separate job. This means:

  • Users can close the browser, job continues running
  • Failed jobs can be retried
  • Multiple jobs run in parallel with concurrency limits
  • System scales to thousands of users

  Bonus Challenge: Add scheduled scans (hourly, daily, etc.) to track LLM drift and collect historical data – plus alerts when mentions change.

  The instructor demonstrates a complete development journey from problem-finding through API research, intelligent agent prompting, to production-ready architecture with job queuing.

  AI Tools & Format: Claude Code / Cursor (with Claude Opus 4.6), Inngest, Bright Data – Tutorial with practical business focus.

n8n (1 new video)

• 7 Steps to Automate Any Business With AI
  31.3.2026, 21:05:51

  The 7 steps to automating business processes with AI

  Dave Ebeler, who has been working in the AI field since 2013 and runs a specialized agency, presents a structured process for automating enterprises with AI, leading with a counterintuitive principle: the agency deliberately uses as little AI as possible and instead relies on rule-based automations where they suffice.

  The seven steps at a glance:

  1. Discovery: Through interviews and observation of employees (sometimes including office “shadowing”), pain points are identified. The focus isn’t on what customers suggest they want, but on what actually causes problems – repetitive tasks, manual errors, wasted time. The result is a prioritized backlog list.
  1. Prioritization: Beyond impact, factors like complexity, man-hours, error rates, and time to resolution are evaluated. Quick wins are identified (e.g., data flow between two systems) to demonstrate early success. The business case is quantified: cost of status quo vs. benefits of automation.
  1. Map the As-Is Process: The current process is visualized in detail (e.g., using Business Process Modeling Notation/BPMN) – often revealing hidden side paths, edge cases, and exceptions that people hold “in their heads.” This requires collaboration with all stakeholders.
  1. Design the To-Be Process: A copy of the As-Is process is redesigned so that manual steps are replaced by automations. This often uncovers new requirements and enables re-prioritization of components.
  1. Prototyping and Proof of Concept: Actual building happens here – with limited datasets. This is essential for AI systems since their reliability, unlike deterministic software, is not guaranteed. The goal is to prove the solution is feasible before moving to full implementation.
  1. Add Safeguards: Testing with real (or representative) data identifies failure cases. Example: In support tickets, 80% are classified as “Where’s my order?” and can be automated; the remaining 20% (e.g., complaints) are escalated to humans. Human-in-the-loop processes and monitoring metrics are established.
  1. Launch: The system goes into production with clear success metrics (e.g., accuracy rate for automated tickets). In parallel, more complex processes are tackled incrementally. The focus is on delivering value quickly and improving continuously.

  Critical Expectations: Dave emphasizes that with AI, it’s not about 100% accuracy out of the box, but rather 70–80%. Customers must remain actively involved – providing feedback, sharing data, validating iterations. Mismatches occur when customers think they can “hand everything over and it will be solved.” The more AI in the mix, the more critical this collaboration becomes and the more important it is to set realistic timelines and budgets.

  The process consistently emphasizes: don’t start with big ideas, but with low-risk internal processes that enable quick wins and build trust.

  Deep-dive opinion on the seven phases, focusing on the preparatory work before engineering; no tools like n8n or Claude were explicitly mentioned (only referenced as examples for monitoring and data management).

Nate Herk | AI Automation (6 new videos)

• Ollama + Claude Code = 99% CHEAPER
  4.4.2026, 01:28:52

  The creator shows two methods to use Claude Code for free or significantly cheaper: locally with Ollama and via OpenRouter.

  Core concept: Claude Code is the “auto” (harness), the LLM is the “engine”. Normally you use Anthropic’s closed-source models (Opus/Sonnet), which you pay for. The idea is to swap the engine – either to locally hosted open-source models or to free models via OpenRouter. This avoids limits or makes them work differently.

  Why not just run Opus locally? Open-source models are published and downloadable; closed-source models (Opus, Sonnet) are locked and only accessible via APIs – that’s why they cost money. However, the performance gap between the two is shrinking: according to SWE-Bench scores, some open-source models are already better than Claude Sonnet 3.7. Google’s Gemma 4 offers the best Elo-score-to-size ratio and can run locally.

  Method 1 – Local with Ollama: You download Ollama, choose a model (e.g., Qwen 3.5, 9 billion parameters), run ollama pull [model-name] and then launch Claude Code with it via ollama launch claude. Requests are then local and free, but significantly slower. Problem: smaller models can’t optimally use Claude Code tools (context too small, missing tool-calls support). With increased context limit it works better. For cloud models via Ollama (e.g., MiniMax), you can also use online-trained models – but there’s pricing involved.

  Method 2 – OpenRouter: You create an account, load $5–10 (to increase rate limit from 50 to 1000 requests/day) and use free models from there. Important: in settings.local.json the API endpoints must point to OpenRouter and the OpenRouter API key must be used instead of the Anthropic key. You also need to set model variables for all tiers (Opus, Sonnet, Haiku) to free models – otherwise Claude Code will continue pulling expensive Anthropic models for small tasks. With this method it costs effectively 50–100x less instead of completely free.

  Use cases for open-source models: Low-stakes tasks (summarize files, search codebase, generate boilerplate), research and data collection, categorization, simple tests and code reviews. Not suitable for high-critical work – use Opus/Sonnet there. Also good when Claude is down or you’ve hit rate limits.

  Warning: There’s no real “free” – you either need hardware for local models or you pay for cloud hosting/subscriptions. Smaller open-source models are slow and can’t natively use web-search tools. Context management is important since open-source models have smaller context windows than Opus (1 million tokens).

  Demo shows: Qwen 3.5 locally takes ~4 minutes for simple queries. MiniMax via Ollama Cloud is significantly faster and more reliable. OpenRouter with Qwen 3.6 works flawlessly for many tasks, but fails at web search without native tool support.

  Explicitly mentioned: Claude Code, Ollama, OpenRouter, Anthropic (Opus/Sonnet/Haiku), Google Gemma 4, Qwen models, MiniMax, SWE-Bench. — Tutorial/guide.

• 18 Claude Code Token Hacks in 18 Minutes
  2.4.2026, 01:46:58

  18 Claude Code Token Hacks

  The video covers 18 strategies for optimizing token usage in Claude Code, organized in three difficulty tiers.

  Key understanding: Claude reloads the entire conversation history with every message – not linearly additive, but growing exponentially. After 30 messages, ~250,000 cumulative tokens may already be consumed, with 98.5% of that just reloading conversation history. Additionally, cloud.md, MCP servers, system prompts and files also reload with every message. A bloated context doesn’t just cost more, it also leads to worse output quality (loss-in-the-middle phenomenon).

  Tier 1 (9 hacks): Start new conversations for unrelated tasks; disconnect MCP servers when not in use (can cost ~18,000 tokens per message); batch multiple prompts into one message; use plan mode before real tasks (to avoid wrong paths); run /context and /cost for visibility; set up terminal status line; keep dashboard open; be precise with paste behavior (don’t paste entire files when only one function is needed); watch Claude Code while running to catch wrong paths early.

  Tier 2 (5 hacks): Keep cloud.md under 200 lines and structure it as an index file; address file references precisely instead of whole repos; at ~60% context capacity manually work with /compact (don’t wait for 95%); don’t pause longer than 5 minutes without /compact or /clear or the prompt cache expires; limit shell command output and use commands deliberately.

  Tier 3 (4 hacks + bonus): Choose the right models – Sonnet as standard, Haiku for sub-agents, Opus only for deep architecture planning; understand sub-agents – they require 7–10x more tokens than standard sessions since each instance loads full context; use peak hours strategically (8am–2pm Eastern time weekdays = higher drain, off-peak = more efficient); design cloud.md as a self-updating system – store stable architecture decisions and learning points instead of repeating conversation flows.

  Mindset: Token consumption isn’t a problem of the plan, it’s a problem of context hygiene. Hitting the limit is actually positive – it shows intensive use and productivity. The balance between quality and cost must be calibrated individually.

  Demo/practical tools: /context (shows token distribution), /cost (spend tracking), /compact, /clear, status line in terminal, Code Experts plugin for reviews without Claude tokens.

  Claude, tour through token management and structural best practices — Tutorial/deep-dive.

• Claude Code Just Gave Everyone Virtual Pets (April Fools?)
  1.4.2026, 14:00:54

  Summary: Claude Code Virtual Pets Feature

  Claude Code introduced a new /buddy feature on April 1st – a Tamagotchi-like virtual pet system that runs directly in the terminal while coding. Users can hatch a companion pet with /buddy, which receives a random species (duck, cat, dragon, turtle, ghost, robot, etc.), rarity tier (Common 60%, Uncommon 25%, Rare 10%, Epic 4%, Legendary 1%) and a generated name. Each pet has five stats (Debugging Patience, Chaos, Wisdom, Snark) based on the user’s coding history, plus descriptive personalization. The pet is permanently tied to the user ID – there’s only one per account, which regenerates.

  The buddy occasionally comments on coding work in the terminal via chat bubbles and can be directly addressed. With /buddy pet you can spawn hearts around the pet, with /buddy off you turn it off. The system has no functional impact on coding performance or token usage and is purely decorative. Rare and epic pets can wear accessories like crowns, hats or propellers and have different eye variations. The feature only works in the Claude Code terminal (version 2.1.89+), not in the regular VS Code extension.

  Claude Code (Anthropic) is the tool covered; format: demo with explanatory elements, audience-friendly and average technical depth.

• Claude Code Source Code Just Leaked… 8 Things You Must Do
  1.4.2026, 02:01:27

  Claude Code became known through the release of its source code (2,000 files, over 500,000 lines of code) after a security leak. The video outlines how users can use Claude Code much more effectively based on insights from this codebase.

  The eight key insights are:

  1. Claude Code is not a chatbot app – It’s a complete agent runtime with tool system, command system, memory system, permission engine, task manager and multi-agent coordinator. Most users only use about 10% of the functionality.
  1. 85 slash commands exist – Particularly relevant are /init (set project context), /plan (planning instead of direct execution), /compact (save tokens/costs by compressing conversation), /review and /security (structured code reviews), /context (file management), /cost (spend overview), /resume and /summary (session continuation). Power users know these commands, standard users know about 5.
  1. Cloud.md is critical – This file isn’t documentation, it’s operating context for Claude Code. It should be short, concise and operational (e.g., TypeScript strict mode, test structure, conventions). It gets injected in every session and heavily influences future behavior.
  1. Permission system prevents slow feeling – Instead of writing better prompts, you can set wildcard permissions (e.g., “allow all git commands” or “allow all edits in /src”). This eliminates constant asking and enables true agent autonomy.
  1. Multi-agent architecture is built in – The codebase reveals coordinator subsystem, agent tools and task system for parallel work. Practically this means: break complex requests into sequential or parallel steps, not as a massive monolithic prompt.
  1. MCP plugins and skills are the real extension layer – Claude Code is both MCP client and MCP server. External tools, databases, APIs and internal systems can be connected – the real power comes from the connected ecosystems, not just from the tool itself.
  1. Unreleased features are waiting – Feature flags in the code hint at internal/experimental functions: voice mode, daemon mode, coordinator mode. These will probably roll out later; users should follow updates.
  1. Top 1% users design their operating environment – The secret isn’t better prompting, it’s: (1) use cloud.md as force multiplier, (2) learn command service, (3) configure permissions for routines, (4) break complex work instead of monolithic prompts, (5) manage context like money (/compact, /context), (6) connect tools/MCP, (7) treat as infrastructure layer (model routing, backend selection, privacy controls tuning).

  The video covers Claude Code / Anthropic with deep-dive focus on architecture insights from the leaked codebase – opinion/reflection combined with practical use cases.

• Codex Just 10x’d Claude Code Projects
  31.3.2026, 01:55:08

  Summary: Codex Just 10x’d Claude Code Projects

  OpenAI released an official Codex plugin for Claude Code that simplifies integration between both tools. The creator compares both models using benchmarks and real experience: Opus (Claude) leads slightly on SWE-Bench, while GPT-5.4 (Codex) has a 10–13 point advantage on most other coding benchmarks and is significantly cheaper.

  But their strengths complement each other: Claude sometimes over-engineers and is token-hungry, but can be better at planning and ideation; Codex is more efficient at execution and code review, but can be more rigid. The workflow of many users on X is therefore: Claude Code for planning and POC, then Codex for execution and production push plus code reviews. The plugin installs via three terminal commands and offers various skills like Review (standard review), Adversarial Review (challenges design decisions) and other functions.

  In the live demo the creator builds a dungeon crawler game with identical prompt on both models: Opus finishes faster but delivers visually less polished results; Codex produces better-looking UI at first glance but takes longer. Codex’s adversarial review then identifies real bugs in Opus code (softlock error from missing upward travel mechanic), which the creator then fixes in Opus – a strong combination example. The creator recommends testing which model feels better and flexibly switching between them depending on use case.

  Claude/Opus and OpenAI GPT-5.4 (Codex) are compared as concrete AI code assistants; demo of Codex-Claude Code plugin with real game-building examples.

• I’ve Built 500 AI Workflows, This is What Businesses Want in 2026
  30.3.2026, 12:35:12

  The five most profitable AI workflows for 2026

  After building hundreds of AI workflows for real customers, the author has found that businesses don’t want the complex, technically sophisticated solutions hyped online – they want five specific, simple automations that demonstrably save time and money or reduce errors.

  Speed-to-lead (fast response): When a prospect fills out a form or calls, a clock starts. Companies that respond within 5 minutes convert 10x better than those that wait 30 minutes – yet the average response takes 47 hours. An automation captures leads, qualifies them by criteria like budget or location and routes them to the right person, while simultaneously sending a personalized message – all in seconds. Service businesses (dentists, law firms, tradespeople, real estate agents) pay well for this because the ROI calculation is immediately visible: a dental clinic with 100 leads/month and 12% conversion rate could gain 13 additional patients at 25% conversion rate with the same ad budget.

  Document processing: Accountants, insurers and law firms spend hours manually typing information from invoices or PDFs into other systems. A workflow automatically extracts vendor name, amount, date, etc., checks against chart of accounts and pushes clean data forward – reduces processing time from 15 minutes per document to about 2 minutes. That saves over $70,000 annually in labor costs and reduces error rates that cost the company money. Often you don’t even need AI for this, rule-based logic is enough.

  Follow-up and nurture sequences: 80% of sales require at least five follow-ups, but most sales teams stop after one or two. Leads that already filled out a form or attended a webinar are warm – an automated sequence can personalize follow-up without a human doing it manually. Example: a B2B consulting firm increased from 4% conversion rate on manual webinar follow-ups to 10-12% with automation, which at $20,000 average deal size per webinar means going from $36,000 to over $90,000 in revenue.

  Database reactivation: Every established business sits on a goldmine: past customers who churned, newsletter subscribers who never bought, trial users who disappeared. A workflow segments this database and sends personalized messages referencing their history. A gym with 4,000 contacts could reactivate 80-130 people with just 2-3% conversion – at $50/month and 8 months retention that’s $32,000-48,000 revenue without new ad spend. Agencies specializing in this report average 1,200% ROI in 60 days.

  Internal reporting and status notifications: Sales managers pull weekly numbers, agency owners compile KPI reports, ops teams gather status updates – all manually. A workflow pulls data from different systems, runs analysis and sends daily Slack messages with yesterday’s sales figures or weekly emails with client metrics. Example: a workflow converted daily phone orders into the text format the construction site team used anyway, saving 45 minutes daily and avoiding $12,000/month in planning errors.

  Sales strategy: Don’t sell automation, sell the business outcome – saved time, reduced costs, focus on more profit. There are two paths: (1) specialize in one process (e.g., just speed-to-lead), become the expert, charge higher prices, get better case studies; (2) be a consultant and identify the real bottleneck in the business by asking “what would break first if 500 new customers came tomorrow?” The business is a pipe with cash flow – fix the bottleneck first, then push more volume through. These five workflows are the most common bottlenecks.

  Explicitly mentioned tools/platforms: None – the video focuses on conceptual workflows and sales logic, not specific automation tools.

  Format: opinion/reflection + practical deep-dive

NeuralNine (2 new videos)

• Agent Skills 101: Never Explain Twice Again…
  3.4.2026, 16:00:49

  Summary: Agent Skills 101

  Skills are Markdown files that provide AI agents with specific context information for recurring tasks without having to explain everything each time. Unlike a centralized agents.md file that contains all project information and strains the context window, Skills are organized separately and only loaded when relevant.

  The structure is straightforward: In the .claude/skills/ directory (for Claude Code), you create a folder for each Skill with a skill.md file that starts with a YAML header (name, description) and then contains detailed instructions. The agent scans Skill names and descriptions to decide which Skill to load. In the demo example, a Skill is created that when adding Python packages not only uses uv add but also automatically writes uv python freeze to a requirements.txt. The agent recognizes the Skill automatically or can be manually activated with /skillname.

  Anthropic and OpenAI offer pre-built Skill repositories with best-practice examples (e.g., PDF processing). These often contain additional files alongside the skill.md such as forms.md (instructions for special cases) and scripts that the agent can call. An interesting use case is the LangChain Skill, which instructs the agent to always consult the current documentation instead of relying on outdated code knowledge – limited to five web searches to avoid drift. The Claude Code implementation had weaknesses with web-search fetches, while Open Code handled it better.

  Additional features (from the documentation) include placeholders like $arguments and $cloud_session_id as well as header options such as allow_tools or disable_model_invocation.

  Claude (Anthropic) was demonstrated as the primary tool; Open Code (OpenAI) also tested; Format: Tutorial/Demo.

• OpenCode is so much better than the rest…
  30.3.2026, 16:01:06

  OpenCode – Terminal Agent with Extensive Configuration Options

  The video introduces OpenCode – an open-source, community-driven agentic terminal agent, similar to Claude Code or Codeex, distinguished by a particularly good terminal user interface.

  Basic Setup and Models:

  After installation, you start OpenCode and see an interface with context information (token usage, costs). You can use various models – free Open Code models, OpenAI subscriptions or API keys, Anthropic APIs (not the subscription), Ollama locally or in the cloud. The provider is configured via Ctrl+A.

  Permission System:

  Central to the tool is the ability to control permissions granularly. Via opencode.json you can configure: every code change requires approval (edit: ask), and Bash commands must be authorized – unless you whitelist individual ones like ls (allow). With each action, you are asked and can allow or deny once or permanently.

  Additional Features:

  • Diff View (Ctrl+F in fullscreen mode): Shows GitHub-like changes with LSP integration (linting, refactoring).
  • Undo/Redo: Unlike Claude Code, you can not only undo but also redo.
  • Message Navigation (Ctrl+X+G): Jump to previous messages with options to fork (new session with same history), copy, or revert.
  • Sessions (/sessions): Management of multiple conversations.
  • Editor Integration (Ctrl+X+E): Opens the default editor (e.g., Neovim) for more complex prompts.
  • Plan vs. Build Mode (Tab): Plan mode provides read-only access and creates a plan; Build mode implements it.
  • Reasoning Level (Ctrl+T): Toggle between Low, Medium, High, and Extra High.
  • Plugins: Easy loading of NPM-based community plugins like the Notifier plugin, which you specify in opencode.json under a plugins field.
  • Ollama Integration: Local models can be defined as a new provider (schema, base URL, model name).

  Practical Example:

  The video shows a to-do app (Flask with HTML/CSS/JS) that is automatically created, then extended with SQLite persistence – each time after user confirmation.

  The video explicitly covers OpenCode (open-source agent), with comparisons to Claude Code and Codeex; OpenAI integration is central. The format is a Tutorial/Demo with practical application examples.

Nic Conley (1 new video)

• Claude Code – Full Tutorial for Beginners (2026)
  31.3.2026, 15:06:51

  Claude Code – Full Tutorial for Beginners (2026)

  This video is a complete beginner’s guide to creating a web app with Claude Code without requiring programming knowledge or terminal work.

  Basic Setup: You download the free Claude Desktop app, switch from Chat to Code, and select a local folder where Claude saves the generated files. You should upgrade to a paid plan (20 euros/month) to build web apps.

  App Development: As an example, a stock-tracking app is built using the free massive.com API. You select the Claude model (Opus 4.6 for best quality, Sonnet 4.6 for economical token usage), start in Plan mode so Claude creates a build plan, then enter a prompt with API documentation. Claude develops the app independently in minutes – you see live token usage and can use the preview function to test the result locally.

  Deployment: To take the app live, you commit it to GitHub (as a free backup and to enable hosting), create a new repository there, and let Claude upload the code. Then you connect your GitHub account to Hostinger (from $2.99/month with coupon), select a domain, and Hostinger automatically deploys the app. If errors occur (like wrong Node.js version), you can simply give Claude the error message and it fixes the problem – then the code is pushed to GitHub again and Hostinger redeploys automatically.

  Subsequent Changes: You can return to Claude Code anytime to request new features or change the design. Every change is committed to GitHub, Hostinger detects it automatically and updates the live app.

  The video shows Claude Code, Hostinger, and GitHub in a practical end-to-end demo – beginner-level tutorial.

Nick Saraev (1 new video)

• Paperclip Sucks, Actually
  29.3.2026, 16:28:16

  The author sharply critiques agent frameworks like Paperclip as empty promises primarily designed to maximize engagement on social media. His core criticism: These tools organize agents according to classical hierarchical corporate structures, even though there’s no functional reason to do so – and many showcase examples don’t demonstrate real business results, but merely agents managing other agents or stuck in endless meta-processes (converting SEO audits into tasks, improving dashboards to improve dashboards).

  The main point: Clients and customers don’t care about the technical setup, only the end result. Those who actually make money don’t rely on complex agent swarms, but on fundamental work – the author compares it to how brilliant people only need Apple Notes for their productivity, while mediocre people get lost in tools. His thesis on better AI organization: AI systems are highly parallelizable and should be structured completely differently from human organizations – for instance, by having 50 parallel agents create the same thing and then synthesizing the results – rather than delegating hierarchically like humans do.

  In the end, he warns against the hype cycle itself: this is the same dynamic as with N8N agents 2.5 years ago – lots of motion, little movement.

  Topics: Paperclip (Open Source), Claude, N8N; Format: Opinion/Reflection with deep-dive into AI organization theory.

Niklas Steenfatt (1 new video)

• 100 Hours of OpenClaw in 19 Minutes
  3.4.2026, 21:10:51

  OpenClaw in 19 Minutes – Compact Overview

  OpenClaw is not an AI itself, but rather a bridge between language models (like Opus 4.6) and the rest of the world. The tool uses an LLM as its “brain” as a foundation, stores memory in Markdown files, operates via heartbeats (pulses every 30 minutes) that allow it to act proactively, and has access to external tools as well as potentially your computer.

  Installation & Hosting: Three options – locally on your laptop (free, but impractical), on a continuously accessible Linux server via Docker (for IT professionals), or Managed OpenClaw (managed by the provider, no admin overhead). The choice of AI is flexible: Opus 4.6 as the most powerful model, or the more cost-effective Claude Sonnet 4.6.

  Important Markdown Files in the Workspace: Soul.md defines the agent’s character (“You are not a chatbot. You become someone”), User.md stores personal information, Tools.md contains API keys and technical parameters, Memory.md collects general rules and goals, the journal documents daily activities, and Agents.md explains the model its tasks.

  Heartbeat and Cronjobs: Cronjobs trigger recurring tasks at fixed times (e.g., daily briefings). Heartbeats every 30 minutes are crucial – they transform OpenClaw from a reactive chatbot into a proactive 24/7 colleague that autonomously executes tasks defined in Heartbeat.md (website monitoring, journal sync, etc.).

  Reverse Prompting: Instead of telling the agent “help me with X”, you ask it: “How can you create value for me based on everything you know about me?” In doing so, the agent learns your profile better and better.

  Skills and Internet Access: Skills are just Markdown files with API documentation – nothing more. They function as memory aids, so OpenClaw doesn’t have to constantly research things anew. For web searches, OpenClaw uses the Brave Search API by default (free with limits) or alternatively Perplexity via API.

  Security: The main risks are prompt injection (especially with open-source models) and user error (wrong commands can delete emails or send embarrassing messages). Best practice: Give agents only the minimal necessary permissions, as you would with an unknown new employee.

  Error Handling: When problems occur, a new session (slash command), restart in the panel, or simply a second OpenClaw instance that debugs the first one often helps.

  Demo & Practical Tips: The creator shows his setup on a Hostinger VPS, where files are visible in the file explorer. Regular updates are important. You can transfer Markdown files between instances and thereby preserve the “personality”.

  OpenClaw’s key feature: Each session is like a restart for the agent (memento effect), which is why precise Markdown notes are central. Over time, true collaboration emerges between human and agent.

  Tools/Providers Mentioned: OpenClaw (Open-Source), Claude Opus 4.6 and Sonnet (Anthropic), ChatGPT (OpenAI), Ollama, Hosted on Hostinger, Brave Search API, Perplexity API, n8n (in another video), Trello skill example — Deep-dive / Tutorial hybrid, advanced technical level.

No Priors: AI, Machine Learning, Tech, & Startups (1 new video)

• AI for Atoms: How Periodic Labs is Revolutionizing Materials Engineering with Co-Founder Liam Fedus
  3.4.2026, 10:00:41

  Liam Fedus, Co-Creator of ChatGPT and former VP of Post-Training at OpenAI, discusses Periodic Labs, his new venture developing AI foundation models for materials science. His career began as a physics major researching dark matter, took him through Google Brain (2016–2017, the era of Transformers and distributed training), and led to OpenAI, where he worked on productionizing GPT-4 and developing ChatGPT.

  Fedus explains that connecting AI with the physical world is necessary to achieve scientific acceleration—2022 technology was still too weak, but improved models, reasoning, test-time inference, and coding agents made it possible. Periodic combines language models as an orchestration layer with specialized, symmetry-aware neural networks for atomic systems. The company uses a combination of open-source and closed-source models (e.g., Codex for coding) and relies on iterative closed-loop systems: experimental data is validated against simulations and literature to inform the next experiments.

  On the data question: Periodic already leverages billions of tokens from open-source models as a base prior, but shows high sample efficiency in specific chemical spaces. A critical problem in the literature is data variability across orders of magnitude—experimental data provides ground truth. Generalization is limited: systems that model quantum mechanics don’t automatically help with fluid dynamics.

  Fedus emphasizes the team’s multidisciplinary composition (physicists, chemists, top AI researchers, engineers) as a core strength and compares the field to early Google Brain days—soon, far more automation and scaling will be possible. He sees Periodic as an “intelligence layer” for companies working with the physical world, and contemplates a discovery model similar to biotech.

  On the AGI/ASI question: Fedus critiques the notion of intelligence as a simple scalar; systems exhibit “spikiness”—they can be world-class in one area but severely degrade when perturbed. Self-improvement is domain-specific: in software engineering it happens “right now” (unit tests are verifiable, quick to check), in AI research more slowly (GPU-intensive experiments). The connection to the physical world is crucial—only closed loops against real domains enable genuine improvement.

  Robotics is a major accelerator, but not essential—hybrid systems with humans and reliable automation already deliver high-quality data. Off-the-shelf robotics suffices for now, but better systems will massively speed up scaling. Fedus is also excited about the interface potential of AI with the physical world overall—robotics, control, agency—given global labor shortages in the physical sector.

  Explicitly mentioned AI tools: OpenAI, Google Brain, ChatGPT, GPT-4, Codex; Format: Live Q&A/Interview (Deep-Dive), aimed at a technically savvy audience.

Productive Dude

No new videos in this period.

Sebastien Dubois (3 new videos)

• The 8 Levels of AI Use. Time to level up!
  5.4.2026, 03:00:01

  Summary: The 8 Levels of AI Use

  The speaker presents eight levels of AI usage, based on insights from Steve Yagi, a well-known programmer:

  Level 1–2: Basics like using ChatGPT simply or integrating a coding agent into your IDE – you ask questions and get answers (single roundtrip).

  Level 3: Give the AI full permissions (read/write/modify) without asking for approval.

  Level 4: Stop reviewing every change; trust the agent’s activity and focus on direction rather than controlling details.

  Level 5: Use tools like Cline or Codeex – you describe tasks in the terminal, the agent works independently.

  Level 6–7: Run multiple agents in parallel (different terminals for different tasks). From Level 7 onwards, you become the bottleneck because you have to wait for and coordinate agents.

  Level 8: Build or use an orchestrator (like the mentioned Gaston) – manage not 1 or 10 agents, but 100+. This allows agents (video editor, coder, QA, etc.) to work in parallel and assign tasks to each other.

  However, the speaker emphasizes that this classification is incomplete. The second, often overlooked dimension is context management: the more structured information (goals, processes, notes in tools like Obsidian) you provide to the AI, the better outputs you get. If you’ve organized your own knowledge, you can feed it contextually to the AI – for example, when drafting articles through references to writing style, ideas, and knowledge base – and achieve significantly higher quality than with blind questions lacking context.

  Steven Yagi and the tools Gaston, Cline, and Codeex were mentioned; this is an opinion/reflection with a practical deep-dive character.

• I Built an Obsidian Plugin to Convert Handwritten Notes to Markdown ✍️
  3.4.2026, 15:31:51

  The creator developed an Obsidian plugin called Transcriber that converts handwritten notes from images into Markdown. The plugin uses locally running AI models (via Ollama) to perform the conversion – meaning your data never leaves your computer.

  The workflow system works in two stages: First, notebooks are imported as images into the Obsidian vault (shown in a previous video). In the second step, the Transcriber plugin uses a local vision model – the creator demonstrates the GLM OCR model – to convert these images to Markdown. Ollama must be installed and configured separately; after installation, you download the desired models through the plugin.

  In the plugin settings, there’s a prompt that tells the AI how to perform the conversion: Obsidian-flavored Markdown, preserve all text, original document structure, accurate transcription of handwritten text, and for diagrams, conversion to Mermaid syntax (which Obsidian natively supports). The prompt is customizable, and multiple models can be installed in parallel.

  The demo shows that on the first run, the model must be loaded into memory (takes longer), then it stays in RAM for about 4 minutes and subsequent conversions run faster. The recognition isn’t perfect, but the creator describes the result as time-saving and efficient. The plugin also offers the option to transcribe all images in a folder at once. At the end, the creator shows how integration with Remarkable notebooks works to sync fresh handwritten notes directly and then convert them.

  The video covers local AI models (Ollama, GLM OCR) and the Obsidian ecosystem – it’s a demo with tutorial elements.

• I Built an Obsidian Plugin to Sync My reMarkable Notes 📝
  30.3.2026, 18:43:34

  The creator developed an Obsidian plugin that enables synchronization of notes from the reMarkable tablet into the Obsidian vault. The plugin works with two cloud options: the official reMarkable Cloud or RM Fake Cloud, a self-hosted alternative that you can install, for example, in Docker on a NAS or computer.

  The plugin downloads all notebooks and stores them as images in the vault. The creator demonstrates the installation and features: after manual installation, you get various commands (list notebooks, synchronize, import RM files) and a panel showing all available notebooks. In the settings, you configure the server connection, storage folder, and image format (PNG here). The creator uses RM Fake Cloud on a local machine himself because, in his opinion, the official solution has too many restrictions and is paid. After syncing a notebook, all handwritten pages appear as images in the vault. The next step – converting these images to Markdown text – will be covered in a separate video.

  Demo of a custom-built Obsidian plugin for a niche function.

Simone Rizzo (2 new videos)

• Ho rifatto OpenClaw… ed è stato troppo facile
  2.4.2026, 15:00:51

  In this video, the developer builds “Rizzo Clone” – a standalone recreation of OpenClaw – using the Agno framework and demonstrates how simple it is to create an AI agent.

  Architecture and Setup: The system consists of a chat component (Telegram integration), an agent loop for 24/7 availability, tool support, skills, and persistent memory. He uses Agno as the framework – a Python-based, open-source multiagent system that is model-agnostic, supports all major LLMs, and according to its creators is 529x faster than LangGraph.

  Development Process: The author uses Claude Opus as a Coding agent to generate most of the code. He starts with a Telegram bot (via BotFather), creates the skeleton, and then integrates step-by-step:

  • OpenAI integration for agent responses
  • Audio upload and transcription
  • SQLite-based chat history (local, no cloud)
  • Memory manager for storing user preferences (dynamic memory function)
  • File handling (CSV, PDF, images) with Telegram delivery
  • Web search tool, file tools, Python and shell access
  • Skills (DocX, PDF, PowerPoint, XLSX) for advanced processing

  Practical Tests: The agent reads tables from images, creates infographics via Python code, performs data analysis, generates PDF reports with embedded graphics, and sends everything back via Telegram – all with persistent memory that learns user preferences.

  Conclusion: The author demonstrates that OpenClaw-like agents can be rebuilt relatively trivially with modern frameworks and AI coding assistants – the complexity lies less in the technology than in the conceptual understanding of the architecture.

  Demo with Claude Opus as a coding agent via Agno framework – focus on practical implementation, not technical depth.

• Vibe Design è il futuro? Provo Google Stitch + Claude Code
  30.3.2026, 15:15:00

  The creator tests Google Stitch, which has received an update with “Vibe Design” – a feature that enables creating web, mobile, and poster designs through text prompts and building interactive prototypes without writing code.

  Workflow with Google Stitch:

  The tool analyzes inserted URLs or screenshots (in this case, a personal website), automatically extracts color palette, fonts, and page structure as a design system, and reconstructs the design. Designers can generate variations and preview designs across different viewports (mobile, tablet, desktop). The tool allows manual edits of individual elements and export to Adobe Studio, Figma, Jules, ZIP, or Code/MCP.

  Practical Demo – Roommate Finder App:

  The creator builds a “Tinder for roommates” from scratch, completely without coding: Roommate Discovery (swipe through profiles with budget/location/preferences), Matches, Chat, and Profile. With “Connect and Preview with Instant Prototypes,” buttons are automatically linked and interactive. Missing screens (match confirmation, skip confirmation, notifications) can be generated by simply clicking buttons, without writing prompts.

  Export and Integration with Claude Code (MCP):

  The project is exported as a ZIP with Markdown documentation (design tokens, colors, styles). Via MCP server (Stitch integration), the project is loaded into Claude Code. The agent then generates a fully functional React web app locally (on localhost) that is swipable, chatable, and navigable – all within ~15 minutes, without writing a single line of code.

  Creator’s Conclusion:

  Vibe Design makes prototyping for startup pitches to investors drastically easier: instead of months for UI/UX and development, you have a demo in minutes. Serious development (privacy, authentication, database) remains a separate chapter, but initial idea validation has now become trivial.

  Featured Tools: Google Stitch, Claude Code (via MCP integration), Figma, Adobe Studio – demo video of the Vibe Design workflow.

WorldofAI (7 new videos)

• OpenAI Spud (GPT 6), Claude Conway, GPT Image 2, Cursor 3, Claude Code Ultra, & More! AI NEWS!
  5.4.2026, 08:02:28

  AI News Roundup: OpenAI Spud, Anthropic Conway, and more

  OpenAI Spud (GPT 5.5/6): OpenAI is focusing on the Spud model, expected in spring 2026. It’s a new foundation model that could be GPT 5.5 or GPT 6, designed to handle complex, long-term tasks, act more flexibly, and unlock new capabilities. OpenAI has redirected resources from projects like Sora to prioritize Spud.

  GPT Image 2: OpenAI is testing its new image generation model GPT Image 2 under three codenames (Masking Tape Alpha, Gaffer Tape Alpha, Packing Tape Alpha) in Arena. The model impresses with global knowledge and near-perfect text rendering in images, such as handwriting or company logos.

  Anthropic Conway: Anthropic is developing an Always-On Agent named Conway, which runs in its own UI, can use browser connectors, cloud code, and webhooks, and supports custom tools through the CNV-Zip standard.

  Claude Price Changes: Starting April 4, third-party tools like OpenClaw will no longer be covered by Pro and Max subscriptions and will require separate billing. Reason: Users were exploiting $200 Max plans for expensive agentic workloads. Anthropic is offering a one-time credit equal to the monthly subscription fee.

  Claude Code Ultra Plan: A new Ultra plan feature allows detailed planning in cloud code on the web (rather than locally), with browser-based verification and flexibility in implementing locally or in the cloud.

  Anthropic Voice: A leaked Claude Code update shows Deepgram voice model integration, signaling Anthropic’s expansion into multimodal AI.

  Cursor 3: Cursor introduces a redesigned IDE that supports multiple agents running locally or remotely and offers an optimized editor interface.

  DeepSeek Version 4: Launches in spring and will run natively on Huawei Ascend 95 PR chips – a strategic milestone for China, as it’s the first frontier model to run on domestic hardware. Alibaba, ByteDance, and Tencent have already ordered such chips in massive quantities; prices rose 20% in weeks. This signals a shift away from Nvidia’s CUDA ecosystem.

  Qwen 3.6 Plus: Alibaba’s new model with 1 million token context window, scoring 78.88 on SWAY Bench, outperforms Claude Opus on most benchmarks and offers stronger coding capabilities.

  Gemma 4: Google’s new open-weight model under Apache 2.0 license, available in multiple sizes, ranks 3rd on Arena, and runs on local devices – even on iPhone 17 Pro with ~40k tokens/second via MLX optimization, with multimodal support (text, images, audio, video).

  Explicit Tools/Providers: OpenAI, Anthropic (Claude), Google (Gemma), Alibaba (Qwen), DeepSeek, Cursor, Huawei, Deepgram | Format: News Update/Roundup.

• Gemma 4 Is INCREDIBLE! Google’s Open Model IS POWERFUL! (Fully Tested)
  4.4.2026, 06:05:20

  Google has released the new Gemma 4 series, a family of four open-source models under the Apache 2.0 license, designed for efficiency per parameter: the 2-billion model for mobile/edge, the 4-billion with multimodal capabilities, the 26-billion model (using only ~3.8 billion parameters actively) and the 31-billion flagship model with high quality. All support multi-step reasoning, math, planning, agent workflows, tool use, structured JSON outputs, over 140 languages, and up to 256K context window.

  The core strength lies in efficiency: the 26-billion model runs on older Macs at ~300 tokens/second, and the 31-billion model requires about 2.5x fewer output tokens than Qwen 3.5 (27B) for similar tasks – despite slightly lower benchmark scores (31 vs. 42 on the Intelligence Index). In testing, it often outperforms larger models in reasoning and coding. On coding benchmarks it achieves 80%, on MMLU Pro 85.2%, and is currently ranked 3rd on the LM Arena leaderboard.

  The creator tested the models extensively with Kilo CLI and found that the 31-billion model delivers very good frontend generation (macOS UI, complex UIs with state management), though SVG quality sometimes falls short and complex 3D animations perform weaker. The smaller 26-billion model showed comparable capabilities with recognizable limitations. Interestingly, Google has also launched “Agent Skills” in the Gemini app – a smaller Gemma 4 model runs completely locally on the device, chains tools together, and executes multi-step tasks, including multimodal analysis of images.

  Pricing for the 31-billion model via API is around 14 cents per million input tokens and 40 cents per million output tokens. Access through Google AI Studio (free to test), Google API, OpenRouter, Kilo (with $25 free credits recommended) or locally via Ollama, Hugging Face, or LM Studio.

  Google Gemma 4, demo with local agentic workflow.

• Qwen 3.6 Plus: GREATEST Opensource AI Model EVER! Beats Opus 4.5 and Gemini 3 (Fully Tested)
  3.4.2026, 05:21:24

  Summary: Qwen 3.6 Plus – Performance Test and Demo

  Qwen 3.6 Plus is a new open-source agentic model with 1-million-token context window, optimized for complex coding tasks, automation, and multimodal capabilities. It competes benchmark-wise with Claude Opus 4.5 and Gemini 3 Pro and sometimes outperforms them on Su Bench and Terminal Bench. The model excels in frontend development but can be time-intensive when generating longer projects, as it thinks longer before delivering outputs.

  In practical tests, the model showed impressive results: it created a functional macOS clone in the browser with fully coded apps (Finder, Safari, Mail, Calendar, etc.), including SVG icons and dark mode toggle – something Claude Opus 4.5 didn’t generate. An F1 drift simulation with variable RPM and camera angles, plus multiple landing pages with animations, also showed high quality. With SVG painting and butterfly animation, Qwen 3.6 Plus outperformed competitor model Kimi K 2.5. Particularly impressive: a TikTok clone for mobile with full functionality and a Minecraft clone with functional blocks, water, cave systems, ores, and lava – with health bar mechanics.

  The model costs 50 cents per 1 million input tokens and 3 dollars per 1 million output tokens. Free to test via chatbot, API (Open Router, Kilo Code), and smaller open-source variants are expected. The speaker used Kilo CLI for testing and particularly recommends the model for frontend, visual coding tasks, and multimodal applications – overall a qualitative leap for autonomous AI agents.

  Explicit Models/Tools: Qwen 3.6 Plus, Claude Opus 4.5, Gemini 3 Pro, Kimi K 2.5, Kilo CLI, Open Router (plus Whisper Flow as sponsor) – Format: Demo with comparison, emphasis on practical testing.

• NEW Hidden Features You MUST Enable In Your Claude Code Setup!
  2.4.2026, 07:05:15

  Summary: Hidden Features in Claude Code

  The video presents a series of lesser-known or undocumented features in Claude Code that, according to the creator, are hidden in configuration files, feature flags, and environment variables.

  Autodream/Memory Consolidation: The /dream feature (called Autodream) automatically consolidates Claude’s memory between sessions by removing outdated notes and preserving useful insights. It’s activated via /memory and can be called with instructions like “consolidate my memory using dream”.

  Flicker Mode: An experimental renderer fixes the problem of flickering and stuttering UI. Enable via cloud_code_no_flicker = 1 in config files. Trade-offs include lack of Command+F and changed copy-paste behavior.

  Powerup Command: /powerup offers interactive, terminal-embedded lessons for learning Claude Code.

  Codeex Plugin: A plugin provided by the OpenAI team integrates a second code review agent directly into Claude Code to mitigate rate-limit issues.

  Computer Use via MCP: With /mcp, Claude Code can open applications, navigate through UIs, and find and fix bugs directly. Feature is in Research Preview for Pro/Max plans (Mac OS). For Windows/Linux there’s an unofficial plugin equivalent.

  Teleport and Remote Control: /teleport switches sessions between devices; /remote control enables control of a local session from another device.

  Output Styles: With /output-style, you can set three behaviors (default, explanatory, learning) that customize how Claude Code interacts with you.

  Hooks: Automate repetitive tasks through logic at specific points in the agent lifecycle (e.g., session-start, pre-tool-use, permission-request, stop).

  Session Forking: With /branch or /resume [session-id] --fork-session, you can duplicate sessions to experiment safely.

  Git Worktrees: The cloud_worktree command enables parallel sessions in the same repository.

  Effort Level: Sets the reasoning time per session with slash commands.

  Dynamic Shell Outputs in Prompts: Special commands embed shell outputs directly in skill prompts.

  Explicitly Named Tools/Providers: Claude Code, OpenAI, Codeex, Anthropic (MCP) — Tutorial/Opinion, accessible to beginners through advanced users.

• Claude Opus 4.7 + Sonnet 4.8 + Mythos 5 ALL Leaked & New Claude Code Features!
  1.4.2026, 06:28:00

  A massive leak of over 500,000 lines of Claude Code source code was exposed through a faulty GitHub update and spread across the internet within minutes. Despite takedown attempts, the code was mirrored and publicly reconstructed and published by developers on GitHub. The leak revealed internal codenames for existing models (Fenick = Opus, Tangu = Haiku, Capra = Sonnet, Titan) as well as hints at upcoming versions like a 1-million-token-context Capra model and the new models Opus 4.7 and Sonnet 4.8. It also uncovered 44 feature flags showing upcoming features: a background AI agent named Karios, a companion AI called Buddy (humorously confirmed as a Tamagotchi-like pet for April Fools), voice features, multi-agent coordination, advanced planning tools, a hidden mode, and structured long-term memory to solve Claude Code’s memory problems. Other revealed features include Autodream (infinite memory), Chyros Agent, proactive agents, Ultra Plan for long-term tasks, Voice Mode, Background Sessions, Dispatch feature, daemon-like agents, and MCP computer control. The leak also revealed an “Advisor” – a server-side tool where a stronger Claude model monitors conversations in real-time. Developers have already begun cloning Claude Code and creating their own versions, some with removed telemetry and unlocked experimental features. The next tier flagship line will be Mythos, internally tested alongside improved versions of Capra, featuring a massive 1-million-token context window and fast and full reasoning modes.

  Claude/Anthropic models and Claude Code were explicitly featured; news update/demo format.

• Claude Code Computer Use Can Control Your ENTIRE Computer! Automate Your Life!
  31.3.2026, 06:12:02

  Anthropic has introduced a computer use capability for Claude that allows Claude to interact with the computer like a human – opening apps, navigating browsers, filling out forms, and automating tasks. This feature is now available in Claude Code for Mac OS (Pro/Max plans) and is activated via the MCP menu. After confirming permissions, Claude can then click any UI elements, interact with applications, and perform visual debugging.

  Primary use cases are: fully test native apps, execute end-to-end UI workflows, fix visual layout issues directly, and work with GUI-only tools (design software, simulators, proprietary apps without CLI/API). The transcript shows practical examples like automatically creating and filling a Google Sheet or testing a self-built movie tracker app with data validation.

  For Windows and Linux users, there’s an open-source workaround: a Dev Browser CLI available on GitHub that provides similar capabilities by having the agent write and execute code instead of using native screen interaction. Installation is via npm commands and the tool is then called as a plugin in Claude Code.

  Another point: Anthropic is actively working on a solution for new rate limits in Claude Code that developers are hitting earlier than expected.

  Claude (Anthropic), Dev Browser CLI as workaround for Windows/Linux — Demo.

• Turn Antigravity Into AN AI Autonomous Engineering Team! Automate Your Code with Subagents!
  30.3.2026, 04:40:33

  Anti-Gravity + Arcade: AI Agent Team for Real Automation

  Anti-Gravity has an integrated Mission Control system that orchestrates sub-agents with specialized skills – but with one critical limitation: the agents can plan but can’t safely execute in the real world. That changes with Arcade.dev, a free MCP runtime that serves as an execution layer and empowers the agents to actually act across 7,500+ tools (Gmail, Slack, Google Docs, Calendar, etc.).

  Workflow Example from the Video: An onboarding task was automatically split – one agent crawled the website for fonts/logos, another compiled a walkthrough, the third wrote an email. No manual handoffs.

  Setup Steps:

  1. Create an Arcade account and select tools in the Tool Catalog (Gmail, Slack, Google Docs, Calendar)
  2. Configure MCP Gateway in Arcade (assign name, select tools)
  3. Enter MCP snippet in Anti-Gravity (Settings → MCP Servers → Raw Config)
  4. Open Mission Control and launch sub-agents through prompts

  Demo Result: An AI-Ops dashboard was built visualizing metrics and KPIs. The agents then automatically created Google Docs (onboarding guide), drafted Slack messages, and wrote emails – each with real OAuth authentications instead of hacked workarounds.

  Important: The Playground function in Arcade lets you test individual tools beforehand. Tool executions are tracked and logged for auditability. You can dispatch multiple specialized sub-agents at the same time on different tasks rather than using a single all-in-one agent.

  Demo with practical results: Anti-Gravity + Arcade connected; the command “Onboard new designer” immediately produced an email draft, could send (after OAuth) a Slack message and create a Google Doc – all in one workflow without manual copy-paste.

  Anti-Gravity and Arcade (free MCP runtime) were featured as central tools; Format: Tutorial/Demo with sponsor integration.

Zubair Trabzada | AI Workshop (2 new videos)

• Claude Code + Bad Google Reviews = Easiest AI Business Ever
  3.4.2026, 14:00:29

  Claude Code + Bad Google Reviews = Easiest AI Business Ever

  The creator built a custom AI tool with Claude Code that automatically analyzes a company’s entire online reputation in minutes. The tool leverages multiple AI agents in parallel to evaluate reviews, sentiment analysis, competitor benchmarking, and everything aligned with that — and generates a professional PDF report with concrete, actionable 90-day roadmap.

  Demo using a plumbing company: The tool collects data in phase 1 via web search (Google Reviews, Yelp, Trustpilot, etc.), then spins up 5 parallel agents. The report shows: Reputation Score (here 62/100, grade C+), Executive Summary, Sentiment Distribution, review theme analysis by platform, competitor benchmarking with response rates and gaps, plus auto-generated response suggestions for negative reviews that you can copy.

  Ideal target businesses: Moving companies, locksmiths, contractors, HVAC, roofers, repair services — industries where bad reviews naturally occur (subjective work, pricing confusion, customer expectations vs. reality). These businesses know reviews are critical but lack the time or tech savviness to manage them.

  Customer acquisition & sales: Cold outreach doesn’t work; instead, run the audit for free first, then present the PDF report focusing on the 3–4 main findings and competitor gaps. This demonstrates value and increases conversion.

  Business model: Audit + Report free. Then $500–$2,000/month for ongoing reputation management (responding to new reviews using tool templates). With just 5–10 clients = $10–$15k/month recurring. Work per client: max 1–2 hours/month; the tool does the heavy lifting. Regular re-audits show progress.

  Demo tool with Claude Code, focused on local service businesses and review management — opinion/guidance on the business model.

• How I Make Money With Claude Code
  2.4.2026, 14:00:07

  Summary

  The core of the video consists of three mental shifts to actually make money with Claude Code instead of just consuming tutorials:

  Shift 1 – From practice to problem-solving: Instead of building demo apps, tackle real business problems. There are countless small business owners, startup founders, and freelancers dealing with manual work daily — data transfers between spreadsheets, time-consuming routine tasks — with no idea how AI can help. This is where the monetization gap lies: develop a simple, working solution to a real problem for a real person.

  Shift 2 – From selling hours to selling products: Taking on client work trades time for money — not sustainable. Smarter: turn the knowledge from each project into reusable templates, starter kits, or automation packs and sell them on platforms like Gumroad. This creates multiple income streams, and product sales run without your personal time investment.

  Shift 3 – From builder to guide: The critical transition is leaving the builder role and guiding other builders instead. Sharing your knowledge (content, community support, documentation) builds trust and develops an audience. A community with recurring members ultimately generates more consistent income than individual projects or products — and scales without additional work per person.

  The central message: it’s not about lacking skills, but the mental shift from consumption to production and who you help — with Claude Code as the tool to make it all happen.

  Claude Code, opinion/reflection.

---

Automatically generated from the latest YouTube videos of the curated channel selection. For feedback, suggestions, or to unsubscribe: simply reply to this email.