Claude Agents Take Over Browser, Terminal, and Smartphone (2026-03-22)

Anthropic Expands its Agent Infrastructure into a Complete Platform – Claude Code, Cowork, Channels, and Dispatch Working in Concert

Sunday, March 22, 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 themes. Read at your own pace — or copy a summary into the LLM of your choice and dive deeper. Click the link under each summary to watch the original video.

Model Releases & Benchmarks

Sub-agent architecture became an industry-wide signal this week: OpenAI released GPT-4.1 Mini and Nano with the explicit note that they were designed for sub-agent deployment — Cole Medin showed that Nano at 188 tokens/second is roughly five times cheaper than Claude Haiku 4.5 and performs better on LiveBench. Cursor introduced Composer 2.0 (0.50 dollars per million input tokens, according to its own Cursor Bench at 70 percent of peak performance) plus the redesigned IDE interface Cursor Glace with multiple parallel terminals. Minimax M2.7 from China was the second major release: 56 percent on SWE-bench Pro, up to 50 times cheaper than Opus 4.6, developed through over 100 autonomous training iterations — WorldofAI tested frontend demos where M2.7 sometimes outperformed Opus 4.6 on animations. Moonshot AI (Kimi) also published Attention Residuals, a modification to residual connections in Transformer architectures unchanged since 2015: layers selectively choose earlier layer outputs instead of weighting all equally — at 48 billion parameters, reasoning metrics jumped several points, with under four percent training overhead.

Local & Open-Source AI

NeuralNine introduced the Dell Pro Max with GB10 — NVIDIA’s Grace-Blackwell chip on the desktop, 128 GB shared memory, one petaflop FP4, runs with DGXOS and enables inference with up to 200 billion parameters without API costs. NVIDIA also announced NemoClaw at GTC 2026, an enterprise wrapper architecture around OpenClaw with integrated policy engines and privacy routers, plus the Nemotron-3 and Nemotron-3-Ultra models. Alex Finn reported on his DGX Spark, where he trains custom models on YouTube transcripts, and plans mid-term to replace cloud APIs with local models like Qwen.

Claude Code & Anthropic Tooling

Practical tutorials on Claude Code dominated the week numerically. Leon van Zyl demonstrated how the newly extended one-million-token context window can be put to concrete use: load product requirement documents in full, plan waves, have agent teams implement in parallel — tools like Autoforge enable significantly more features per session. Cole Medin distilled over 2000 hours of practice into the WHISK framework: externalized memory via Git commits, sub-agents for research (Scout pattern), four-layer context loading, and compression only as a last resort. Matt Pocock showed on a real feature build how five daily-use skills — Grill Me, Write a PRD, PRD to Issues, TDD, Architecture Improvement — force the agent into a defined process rather than letting it iterate freely. Melvynx identified five enterprise mistakes: missing claude.md configuration, insufficient permissions, no standardized skill workflows, developers who work like agents themselves instead of monitoring multiple agents, and too-slow manual code reviews. Mark Kashef showed three context-bloat features — /by-the-way, /fork, and the new context fork in skill files — live in a consulting scenario with Obsidian Vault search. Julian Ivanov presented ten concrete skills, including Remotion for rendered MP4 video, Context7 for current API documentation without hallucinations, and the Feature Death plugin for structured seven-phase feature development.

Coding Agents (Non-Claude)

Melvynx delivered the most precise comparison of the three main tools: at 20 dollars per month, Codex wins with GPT-4.1 due to cheaper token costs; at 200 dollars, Claude Code dominates through massive subsidization (up to 5000 dollars API value according to one cited tweet); for enterprises, Cursor remains the recommendation if paid by the employer. The underlying model has stronger influence on output quality than tool differences themselves. DevExpert demonstrated how Codex (with Claude Code as an alternative) completely updated an Android training project with 47 historical commits in under an hour — a task that previously required days of manual work. Theo observed that the classic IDE model no longer fits for parallel agent work on dozens of projects and is experimenting with T3 Code as a multi-project orchestration approach.

Personal AI OS & Agent Frameworks

OpenClaw was present in numerous videos but conceptually lost ground. Alex Finn built his own AI Research Lab with OpenClaw and the Hermes Agent plus Andrej Karpathy’s Auto-Research Framework — three parallel experiments run autonomously, an R&D Council of five agents debates features twice daily. His tutorial on OpenClaw Mission Control shows a Kanban board, activity feed, content pipeline, and a life-CRM as an integrated system. Melvynx explained in a beginner tutorial the complete VPS setup with OpenClaw including Gmail/Google Calendar via OAuth2. Dave Ebbelaar argued against cloning finished repositories and instead showed a self-built architecture: FastAPI, Celery, Redis Queue, Caddy as reverse proxy, three-layer context loading, and Claude Code SDK for agent execution under the name Data Lumina OS. Simone Rizzo comparatively explained memory mechanisms: OpenClaw uses daily Markdown logs plus Memory.md with automatic memory flush before compression; coding agents combine file tools with SQLite; Recursive Language Models (MIT) manage long contexts as Python variables rather than tokens. Andrej Karpathy described his self-developed “Dobby” system in the No-Priors podcast, which reverse-engineered smart-home APIs autodidactically and is controlled via WhatsApp — and articulated the vision of research organizations as competing program-MD files.

AI Automation & Workflows

Nate Herk argued that n8n skills don’t become obsolete but rather form the foundation for agentic workflows: Claude and trigger.dev enable automation through natural language instead of manual node wiring, but those who understand data flows and error handling can steer these systems meaningfully. He demonstrated a LinkedIn content agent with automatic infographic generation via Nano Banana Pro. Nate Herk also showed a fully automatic social media workflow: Claude Code extracts YouTube video content, writes platform-specific text for nine channels, and generates visual assets for Instagram Carousel and X, publishes via Blot. AI with Arnie presented Andrew Carbaffi’s Auto-Research Framework: an AI system autonomously tests variations, measures improvements, and commits only working changes via Git — in a live demo, an OpenCloud documentation skill rose from 60/100 to 98/100. Zubair Trabzada demonstrated three MCPs for Claude Desktop (Canva, Zapier with 8000 apps, Stripe) as well as Claude Dispatch for local smartphone-controlled workflows.

AI Video & Content Creation

Nick Saraev showed how Claude Code, Kling 3.0 (via Higgsfield), and Netlify together produce 3D scroll websites with animated hero headers for two to three dollars in token costs — projects that used to cost 5000 to 10,000 dollars. Nate Herk built an automated nine-platform content workflow where Claude Code generates thumbnails and formats Instagram carousels. Google Stitch was discussed multiple times: the redesigned platform with Infinity Canvas, voice-vibe design via Gemini Live, instant prototypes, and exportable design-system markdown received strong reactions from Fireship, WorldofAI, and Everlast AI. Google AI Studio Build Mode was presented by WorldofAI as a complete full-stack platform with Firebase backend, multiplayer support, and real-time collaboration — freely accessible.

AI Business, Marketing & Freelancing

Liam Ottley documented an eight-hour workshop session in Cape Town: six founders from different industries set up a Claude-Code-based AI Operating System and achieved concrete outcomes — automated competitor analysis, financial reporting, Zoho integration for unpaid invoice queries. The central thesis: Claude Code is not a programming tool but a universal wrapper around existing business models that enables founders to reclaim 80 percent of operational time. Ben AI showed Claude Cowork for sales automation: a Prospect Miner skill searches lost CRM leads, scrapes LinkedIn profiles via Appify, and prioritizes by ICP; a Win-Loss Analysis skill evaluates transcripts and CRM data. Nick Saraev published a comprehensive cold email course with seven psychological principles and the four-step copywriting framework (personalization, who-am-I, offer, CTA) — without specific AI tools, but as strategic foundation for AI-powered outreach.

PKM & Knowledge Management

Mark Kashef showed how Claude Code builds a custom vault structure via Obsidian’s CLI with built-in slash commands and then persistently accesses all project data — using Gemini for PDF synthesis of large documents. Julian Ivanov presented an Obsidian plugin for Claude that links and summarizes notes, making Claude a personal assistant with memory. Sebastian Dubois presented the TaskNotes plugin: tasks as linked Obsidian notes with status workflows, Kanban views via Obsidian Bases, and Google Calendar integration for time-blocking — all as searchable text without proprietary format.

Prompting & AI Literacy

Kyle Balmer structured a seven-level AI Skill Tree from “Beyond Google” (AI as thinking partner rather than search engine) to “AI Operator” (local models, fine-tuning, own frameworks) and recommended Google AI Studio Build Mode as a frictionless entry for absolute beginners. Alejandro AO systematically explained the skill lifecycle: four success dimensions (outcome, process, style, efficiency), manual validation with explicit, implicit, and negative control prompts, and LLM-as-Judge for automated testing. Kyle Balmer also observed growing user polarization: those who invest in better plans experience Claude as indispensable; those who stick with outdated free versions remain disillusioned — a self-reinforcing cycle.

AI Industry & Strategy

Nate B. Jones’ analysis of Perplexity Computer (19 models, 200 dollars/month, orchestration layer) culminated in a mapping of the entire middleware market: model providers build competing products, hyperscalers secure exclusive distribution (AWS for OpenAI Frontier, Microsoft with 20 percent revenue share through 2032), and those who are neither Anthropic, OpenAI, Google, Meta, nor a cloud provider must immediately find one of four defensible positions — proprietary context, agent infrastructure, workflow depth, or trust-and-verification. Leonard Schmeddings talk at Everlast AI described the “SaaS Apocalypse”: Claude Code’s legal plugin caused a stock market crash of almost 300 billion dollars in legal tech companies, according to Schmedding; the core thesis is that agents without structured AI knowledge storage are blind and every optimization targets the wrong end. Datapizza reported that Anthropic filed two federal civil rights claims against the Pentagon (1st and 5th Amendment) and founded its own research institute for social, economic, and legal AI impacts. Yann LeCun announced AMI Labs — 890 million euros in funding, Paris, focus on World Models rather than LLMs, first partner Nabla in healthcare.

AI & Society / Future of Work

Nate B. Jones substantiated with Forrester data (55 percent of employers regret AI-related layoffs) and Harvard study data that senior positions are rising because they hold organizational memory — and described eval design as the highest-leverage activity for professionals in the agent era. A Mount Sinai study on ChatGPT Health identified four generalizable error patterns for AI agents: inverted U-curve (failure at distribution extremes), reasoning-output decoupling, social-context hijacking, and guardrails that react to surface patterns rather than true risk taxonomy. Futurist Sven Gabor Janszki predicts for 2035 a botconomy (80 percent of economic transactions between AI agents), mass-market humanoids and BCIs, plus longevity breakthroughs — and considers globally coordinated basic income the most likely political response. David Shapiro described the psychological mood shift from “intellectual acceptance” to darker unease and announced completion of his 180,000-word book on post-labor economics. Microsoft AI chief Mustafa Suleiman predicted in a widely noted interview the near-total automation of white-collar jobs within 18 months; TheAIGRID contrasted this with Gartner data showing neutral job impact through 2026 and more created than destroyed jobs from 2028 onward — with 32 million transformed jobs per year in between.

Brief Notes

Fireship covered Ageless Linux, a Bash script that technically circumvents the upcoming California age verification law AB-1043 and is positioned as a civil disobedience project. Simone Rizzo philosophically speculated about two research breakthroughs: the fully mapped fruit fly brain in simulation (Ion System) and biological neuron farms on chips (Cortecalabs, demonstrated with Doom). TheAIGRID explained Elon Musk’s Terafab vision: a chip fab in Austin plus space infrastructure via SpaceX and Optimus robots aimed at a terawatt of AI compute. NVIDIA’s DLSS 5 generates photorealistic materials and lighting in games with a neural rendering model, but also alters facial features — leading to controversy over artistic control. NeuralNine showed an AI agent with Bright Data scraper API and LangChain/GPT-4o Mini. Kyle Balmer reported on Paul Ingham’s case, who used ChatGPT and AlphaFold to develop a personalized mRNA cancer vaccine for his dog, which halved the tumor. Tech With Tim published tutorials on PostgreSQL performance with TimescaleDB plus technical interview strategies with AlgoExpert. Theo discussed the fork dispute between Vercel (Just Bash) and Cloudflare as well as Vit Plus in alpha including criticism of Bun exclusion and script-overwrite behavior.

AI Explained

No new videos in this period.

AI Foundations

No new videos in this period.

AI with Arnie (1 new video)

• Self-Improving AI Is Here Now!
  17.3.2026, 14:27:05

  Summary: Self-Improving AI Is Here Now!

  The video creator presents an open-source project by Andrew Carbaffi that enables AI systems to autonomously experiment, test changes, and automatically implement only working improvements. The project called “Auto Research” was first unleashed on Carbaffi’s “Nanochat” (an AI training project): in two days, the AI ran 700 experiments, implemented 20 of them, and improved the project by 11%.

  The core concept works like a scientific experiment: an agent receives a setup, modifies it autonomously, trains briefly, measures improvements, and keeps only working changes. The advantage: the principle can be applied not just to language models, but to anything with a measurable baseline – skills in Cloud Code, workflows, marketing campaigns, email templates, YouTube titles, prompts.

  The video creator shows five concrete use cases:

  1. Cloud Code skill (OpenCloud documentation): improvement from 80% to 90% accuracy through URL fix after 23 tests
  2. Bitcoin trading skill in OpenCore: experiments with momentum strategy (baseline 53% win rate) – concept worked, but limited practical edge due to spreads
  3. YouTube title generator: skill optimized for hook, readability, emotional clarity, curiosity, topic clarity, and audience fit; best version ready to deploy
  4. Confui image generation: generation accelerated from ~50 to ~46 seconds through configuration adjustments
  5. System prompt of an n8n agent: improved tool usage through prompt optimization

  The practical implementation is demonstrated: clone the project from GitHub, create or load a skill, then start Cloud Code with --dangerously-skip-permissions flag in plan mode. Cloud Code generates an improvement plan, and the AI then runs autonomously for hours/days, tests variations, and commits improved versions via Git.

  It’s even simpler via OpenCore: just give the system the GitHub link and tell it which skill to improve; OpenCore handles the rest.

  In the live demo example with the OpenCloud documentation skill, the baseline rises from 60/100 to 98/100 (+ 38 points) through two automatically discovered improvements: keyword aliases and cross-references to multiple pages.

  OpenCore and Cloud Code explicitly mentioned as tools; news/demo format.

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

• Your AI Agent Fails 97.5% of Real Work. The Fix Isn’t Coding.
  21.3.2026, 15:00:03

  Your AI Agent Fails 97.5% of Real Work. The Fix Isn’t Coding.

  The central problem with deploying AI agents isn’t a lack of technical competence, but missing organizational context and memory. While AI models keep improving at isolated tasks, they fail at long-term, context-dependent work: A Scale AI study across 240 real Upwork projects showed a 97.5% failure rate—the best agent only completed 2.5% of projects at acceptable quality. In contrast, OpenAI’s GDP Benchmark rates similar models as expert-level because all context is pre-provided. An extreme example: An AI agent destroyed a production database with 1.9 million records because it didn’t know the infrastructure was live—technically every action was logically correct, but the agent lacked the organizational knowledge to understand what world it was operating in.

  Another study (SUCCI by Alibaba) on software maintenance over time showed that 75% of tested models damaged already-working features during maintenance. AI writes code well but can’t maintain it over months. The Harvard study of 62 million US workers suggests junior positions are declining (-8% relative), but senior positions are rising—not because AI can replace seniors, but because seniors hold organizational memory that machines don’t have.

  The solution doesn’t lie in better prompts or larger context windows, but in human context control and evaluations (Evals). A good eval would have prevented Alex’s disaster—for instance, through a rule like “before deleting infrastructure, verify the resource isn’t marked as Production.” Most organizations don’t write evals or delegate them to junior staff who don’t understand organizational context. Instead, senior professionals with domain-specific knowledge must write evals—that’s not busywork, but the highest-leverage activity for scaling judgment across all agent deployments.

  The pattern extends beyond engineering: A legal team assigns a contract-review task to an agent, but the agent doesn’t know about informal vendor agreements from three-and-a-half-year-old dinner meetings. A marketing agent doesn’t know about the internal brand crisis that should completely shift tone. A finance agent doesn’t know which technically correct numbers are politically toxic in the boardroom. In every case, technical correctness without organizational context creates damage instead of value.

  The future belongs to companies that treat eval design as a core senior competency—not as a chore or a precursor to layoffs. CEOs who conducted AI-driven layoffs regret it: Forester data shows 55% of employers regret their AI-related terminations, and Gartner predicts half of all companies will need to rehire similar roles by 2027. The human role in an agent-powered world is “contextual control”—preserving the system’s mental models, representing organizational knowledge so machines can use it, and judging when technically correct outputs are organizationally wrong. This isn’t a technical skill, but an ability for systems thinking and decision documentation (not just outcomes, but why).

  The central asymmetry: AI agents rapidly improve at task execution, but their blindness to organizational context grows with their power—the more powerful an agent is that doesn’t understand something is production infrastructure, the more destructive it can be. A mediocre tool that fails loudly is annoying. A power tool that fails silently is dangerous.

  Tools/vendors discussed: Claude, OpenAI (GDP Benchmark, Frontier system with AWS), 11 Labs (AI insurance), Cursor (multi-week deployments). Format: Opinion/deep-dive with case studies and research data.

• Anthropic Just Gave Your AI Agent the One Thing OpenClaw Has. Without the Risk.
  20.3.2026, 14:01:36

  Anthropic delivered the missing component for autonomous agents with the /loop function in Claude Code—a feature that deserves major attention because, combined with memory and tools, it matches OpenClaw-like capabilities without carrying those security risks.

  The core of a functional agent architecture rests on three essential building blocks: Memory (persistent data storage, like via OpenBrain—a SQL database behind an MCP server), Proactivity (the ability to act independently from user input, which /loop enables), and Tools (API access, artifact generation, workflow triggers). Without all three, the agent is just a reactive chatbot; with them, it becomes a working system.

  Practical applications range from personal (daily energy checks with pattern recognition over weeks, automated networking briefings before events as video) to business (sales pipeline management with proactive lead screening, content calendar optimization). The decisive advantage lies in accumulation across cycles: An agent that repeatedly remembers and responds to previous attempts can spot intelligent patterns instead of just delivering snapshots—like André Karpathy’s AutoResearch project, which runs a hundred experiments overnight.

  Compared to OpenClaw, this stack (Anthropic /loop + OpenBrain/Database + standard tools) delivers similar agent capabilities without the chaos of security gaps, network exposure, and extension vulnerabilities. Key differences: /loop only runs during an active session (no always-on availability), there’s no native completion signal, and the skill ceiling stays real due to dependence on Claude Code/Terminal. Still: For non-OpenClaw users, this offers a practical entry point—no download, no special framework, just native Anthropic features.

  The video creator also calls for community participation: OpenBrain is a community project, and he’s opening a shared space to exchange use cases and recipes.

  Format & Context: Claude / Anthropic (Loop feature, Claude Code, MCP server) / Opinion & deep-dive with use case examples

• Perplexity Computer Is Incredible. It Won’t Matter. Here’s Why.
  19.3.2026, 14:50:29

  Summary: Perplexity Computer Is Incredible. It Won’t Matter. Here’s Why.

  The speaker analyzes Perplexity’s new agentic product line “Computer” as symptomatic of a structural problem in the AI industry: middleware companies sit in a fragile position between model providers (competing from below) and hyperscalers (competing from above).

  About Perplexity Computer itself: The system is a cloud-based agent orchestrating 19 AI models—including Claude Opus 4.6 as the reasoning core, Gemini for research, Grok for speed, ChatGPT 5.2 for long-context. It costs $200/month, runs asynchronously over weeks/months, spawns sub-agents, persists context, and integrates 400+ tools. Strong use cases: competitive intelligence, financial analysis, outbound automation, content repurposing, asset builds. Suited for power users and executives with research-focused workflows; not for pure coding or conversational applications. The demo was canceled due to bugs—reliability problems at this autonomy level remain unsolved.

  The structural problem: Even though Perplexity executes well, the orchestration layer (where they sit) is the exposed layer in the stack. Every model provider they depend on—Claude, Gemini, OpenAI, Grok—is simultaneously building competing products like Claude Co-work, Gemini Agents, Frontier. They can change pricing/access, ban users, or simply embed Perplexity’s features into their model. Perplexity has no defensive moat for this position.

  February 2026 as inflection point: In 6 weeks, the industry stratified into layers: model providers (own weights), orchestration/apps (combine models), distribution owners (control user interface). OpenAI launches Frontier (enterprise context platform with forward-deployed engineers and connectors for CRM/data warehouses). Anthropic ships Co-work with private plugin marketplaces on Windows. Google builds Gemini Agents on Android OS level. AWS secures exclusive Frontier distribution and co-builds stateful runtime. Microsoft takes 20% revenue share from OpenAI through 2032. The token flow becomes zero-sum: Hyperscalers must control downstream tokens to justify infrastructure capex.

  Four sustainable middleware positions:

  1. Context control: Distribute structural, operational, and proprietary context wisely. Proprietary context (trading models, pharma data, production sensors) can’t be handed to providers; fast-changing operational context can’t be one-to-one mapped by Frontier.
  2. Agent infrastructure: Be what agents call (like Perplexity’s Search API, already used by 4 of the “Magnificent 7”). Picks and shovels, not wrappers.
  3. Workflow depth & switching costs: Deep integration into customer workflows (e.g., Anthropic’s private plugin marketplaces) makes extraction expensive; the system learns institutional processes.
  4. Trust & verification: Audit, output verification, policy enforcement for agents—the gap between “agents work” and “we can prove what they did”.

  Dead ends for middleware:

  – Multicloud token orchestration (AWS vs. Azure vs. GCP = zero-sum).

  – Margin capture when model providers absorb functionality → your margin goes to zero, even if the service exists.

  – Standing in the way of enterprise relationships (hyperscalers deploy forward-deployed engineers, relationships become 6–18-month locks).

  Perplexity’s strategic escape hatch (under the radar): Not Computer, but the Search API as agent infrastructure is the real defensive position. The decision to kill ads protects trust. Leadership signals: high-margin, high-value customers, agentic infrastructure—that’s playable.

  Clock asymmetries: Model providers ship new capabilities fast. Enterprise procurement locks in for 6–18 months. Hyperscaler capex calculates on a 2–3-year horizon. The fastest clock (capability jumps) determines how quickly your moat collapses. If you’re not Anthropic, OpenAI, Google, Meta, or a cloud provider, find a position immediately: infrastructure, workflow depth, governance, or proprietary context—or get displaced per “Rent.”

  The video covers Claude, OpenAI, Gemini, Grok, Anthropic (Frontier, Co-work, Enterprise Agents), Amazon (Bedrock, AWS, Trainium), Google (Android, Gemini Agents), Microsoft (OpenAI revenue share), Meta, and open-source projects (OpenClaw); format: opinion/reflection with deep-dive structure.

• ChatGPT Health Identified Respiratory Failure. Then It Said Wait.
  18.3.2026, 14:00:08

  ChatGPT Health Identified Respiratory Failure. Then It Said Wait.

  A study by Mount Sinai Health System in New York examined ChatGPT Health—a new medical advice tool—and found concerning patterns: the system recommends doctor visits for conditions that don’t require them, and underestimates emergencies that warrant an ER visit. One example: ChatGPT Health advised waiting 24–48 hours for respiratory failure instead of going to the emergency room immediately. The speaker extracts four generalizable error models for AI agents:

  1. The Inverted U: LLMs perform best on routine cases—where it matters least—and worst on extreme edge cases, where stakes are highest. An accuracy dashboard of 87% hides silent failures at the distribution tails (e.g., an accounting agent handles routine invoices perfectly but misses slightly-modified duplicates).

  2. The Agent Knows But Does Not Act: The reasoning chain often identifies the problem correctly (e.g., “early respiratory failure”), but the output contradicts it (“wait 24–48 hours”). Research on chain-of-thought fidelity shows that reasoning and final output operate as semi-independent processes—the connection is weaker than assumed.

  3. Social Context Hijacks Judgment: When a family member minimizes symptoms, the triage recommendation shifts dramatically (12-fold higher likelihood of less urgent care). A simple addition like “A senior VP is confident this is the right choice” can skew analysis—through anchoring bias that’s subtle and invisible.

  4. Guardrails That Fire on Vibes, Not Risk: ChatGPT Health’s crisis intervention system activated unpredictably—more reliable on vague emotional distress than concrete self-harm threats. The alarms fit surface-level language patterns instead of real clinical risk taxonomy. Similarly, a security agent might flag an email with “trusted financial data” even though it’s just a public quarterly press release, while 50,000 customer records exported to a personal Dropbox could slip through as “project backup.”

  Mount Sinai’s methodology: They used factorial design—testing the same scenarios across 16 contextual variations—to uncover anchoring bias and guardrail inversion. This works domain-agnostically: variation types (extreme risk cases, human-out-of-loop, tool-call errors) scale across domains, while specific scenarios remain domain-specific.

  Four-layer architecture for evals:

  1. Progressive Autonomy: Let agents handle high-confidence, low-stakes decisions; run shadow mode for extreme cases until the agent proves reliable.
  2. Deterministic Validation: Rule-based checks, e.g., “If reasoning flags ‘Enhanced Due Diligence’ but output says ‘Standard Risk,’ escalate”—don’t ask the model to spot its own inconsistencies.
  3. Flywheel: Calibrate the evaluation system toward false-positive bias (worse is false negative on high risk). Check positive flags for authenticity; update eval rules afterward. Additionally: also check the judge’s passes—if something “looked good” but was actually wrong, add it to the eval.
  4. Factorial Stress Testing: The gold standard—test the same cases with controlled stressors (social cues, time pressure, hedging) to measure whether output shifts under unstructured context.

  The speaker emphasizes: the effort is substantial, but necessary. Front-loading the investment (building a scenario library, designing the eval schema once) pays off in ongoing automation. Without this infrastructure, hidden defects emerge—in the worst case, with fatal consequences. He predicts that AI insurance for agent builders will soon be required and will enforce this effort.

  Explicitly discussed: ChatGPT Health (OpenAI); deep-dive into agent-specific error and eval patterns with opinion/reflection element.

• Anthropic Didn’t Build a New Browser. They Did Something Smarter.
  17.3.2026, 14:00:41

  Summary: Anthropic Didn’t Build a New Browser. They Did Something Smarter

  Anthropic didn’t work on a new browser; instead, they developed the Claude extension for Chrome—a tool that integrates an agent directly into the most-used browser and automatically executes tasks on the web. The key: it’s not about a chatbot answering questions, but a browser agent that performs real work without active user intervention.

  Concrete use cases:

  The first is automating customer service interactions. Claude can, for example, conduct a live chat with AT&T, negotiate offers, and ultimately secure a credit—without the user lifting a finger. The agent reads responses, types contextual replies, and escalates politely when needed.

  The second example is recording recurring workflows. The user hits a record button, performs a task (like pulling analytics from a dashboard), stops the recording, and saves the workflow as a shortcut. It can then run automatically daily, weekly, or monthly—for email management, scheduling, scanning LinkedIn invites, or building restaurant lists.

  Anthropic specifically optimized for Gmail: Claude recognizes Gmail automatically and can triage emails, manage the calendar, and organize around 900 documents in Google Drive—creating folder structures, sorting into subfolders, flagging duplicates.

  Multi-tab workflows are also possible: Claude can process multiple web pages simultaneously in a Chrome tab group. This enables, for instance, combining recipes into a complete dinner plan or simultaneously pulling competitor pricing. In Anthropic’s Co-work product, Claude can even export data directly into Excel files.

  For developers, the ability for Claude to test the website during work is especially valuable. The agent can record checkout processes and run them automatically daily, or—combined with Claude Code in the terminal—conduct live testing while writing code and simultaneously reviewing browser output.

  Important limitations:

  On data-heavy tasks, a weakness emerges: if Claude needs to scan LinkedIn profiles and synthesize content across multiple contacts, coverage can be spotty; the agent sometimes misses relevant posts or fixates on peripheral details. This is a context-management problem likely to improve with better models, but currently remains. The recommendation is to break such complex tasks into smaller subtasks.

  Security is a serious concern: users should only run Claude on trusted websites. Prompt injection is possible—for instance, if someone runs Claude on a manipulated Reddit page that itself contains email commands.

  Tool distinctions:

  Claude offers three ways to automate browsing: the Chrome extension (UI with sidebar), Claude Code in the terminal (for developers wanting to navigate more natively), and Co-work (a separate app interface). The video creator emphasizes that Anthropic provides different interfaces so users can work where they feel most comfortable—the technical foundation is the same.

  The core skill is not prompting but the ability to describe or record repetitive work so an agent can take it over autonomously. This is a competency that generalizes across different AI tools. The user ultimately saves dozens of hours per week because repetitive web work runs automatically.

  The extension is available to all on paid plans; more complex tasks require more capable model versions (Pro, Team, Enterprise).

  Technical highlight: Anthropic didn’t replace Chrome but leveraged it—the extension works as an agent directly within existing infrastructure that’s already there.

  Technical focus: Claude Extension for Chrome (Anthropic); demo and deep-dive with practical examples.

• Claude Code Wiped 2.5 Years of Data. The Engineer Who Built It Couldn’t Stop It.
  16.3.2026, 14:00:11

  Summary: Claude Code Wiped 2.5 Years of Data – Management Skills for AI Agents

  The video addresses vibe-coders who’ve successfully built products with AI tools like Claude Code, Lovable, or Cursor, but now discover their skills aren’t enough when agents work autonomously. The central point: vibe-coding in 2025 was primarily a prompting problem. Agent management is a supervision problem—the difference between successful buildups and those that crash is transitioning from “I describe what I want” to “I manage the agent that builds it.”

  Core problem: An agent worked autonomously for 56 minutes and accidentally deleted thousands of emails (SummerUI). Agents don’t just execute code—they read files, change them directly, run commands, iterate. A single mistake (step 4 of 8) can compound all following steps.

  Five management skills (none require coding):

  1. Save Points (version control): Git enables snapshots of working state. If the agent breaks something, revert to the last snapshot—critical for production databases.
  2. Knowing when to restart: Agents have a limited context window. After ~30 messages, they forget earlier instructions, ignore directions, rewrite already-written code. Simple fix: restart. Advanced fix: build workflow files, planning files, and task lists so the agent can pick up again at the 65% mark.
  3. Standing Orders (rule documents): Claude Code, Cursor, and others support rules files (e.g., claude.markdown, agents.markdown). These files contain persistent instructions across sessions—like an operating manual. Start with a few lines, add a rule after each failure. Ideally under 100–200 lines since they consume context window.
  4. Small Bets: Large, sweeping changes have high blast radius—if something fails, you don’t know which of many changes caused it. Implement small features one at a time, validate, save, then next. A 100-step change where step 4 breaks gets exponentially worse than a 12-step change.
  5. Questions the agent never asks itself: The agent won’t think unprompted about:
  • Error handling: Empty or crash screens instead of user-friendly error messages when servers go down or connections break.
  • Privacy: Row-level security (each user sees only their own data). Never paste secret keys into chat. Don’t log customer emails and payment data—use external APIs like Stripe.
  • Scaling expectations: Agent overengineers for 300 users or underengineers for 10,000-person targets. Clarify upfront.

  Limits: For real problems (payment processing, medical data, child-related content, legal compliance, performance issues, neglected codebases), bring in a professional engineer—that’s not defeat, but validation of the concept before major investment.

  Final message: The agent manager doesn’t need to code—just think like a general contractor: save points, restarts, clear on-site instructions, incremental work, questions no one else asks. Prompting remains necessary but is now just necessary-and-not-sufficient for agent power in 2026.

  Explicit AI tools/vendors: Claude Code, OpenAI ChatGPT, Lovable, Cursor, Codeex, GitHub Copilot, Google Docs CLI, Replit, Anthropic, Stripe. Format: Opinion/reflection with practical management principles.

• She quit, picked up AI, and shipped in 30 days what her team planned for Q3.
  15.3.2026, 18:00:57

  The speaker argues that exceptional people typically use only 25% of their actual capacity—not due to lacking ability, but because of coordination overhead (meetings, alignment, email). Solo founders with AI show this overhead isn’t necessary: Ben Sira reached $2.5M ARR as a one-person company with Pulsia; Sarah Gilliam built a product in 30 days that her previous team planned for Q3. A Harvard study at Procter & Gamble showed individuals with AI produced top-10% ideas three times more often—AI serves as a coordination proxy, replacing inter-department alignment.

  The core insight is not that solo founding scales, but that AI reduces coordination costs within organizations. Instead of polling six teams on whether something works, you build a prototype—AI replaces these alignment layers.

  Three neglected soft skills for the AI age:

  1. Conviction over taste: Taste (evaluating whether something is good) alone isn’t enough. Conviction (willingness to ship fast and push before others buy in) is decisive. Both form a feedback loop—faster shipping → quicker feedback → better taste.
  2. Speed of control over span of control: Ben doesn’t manage dozens of AI agents through classic manager hierarchies, but through daily status summaries where he makes fast, high-quality decisions. The ability to direct attention to critical points (like an editor) matters more than the number of managed agents.
  3. Judgment density, conviction velocity, execution bandwidth: People achieving extraordinary results have judgment density (calibrated pattern recognition), the instinct to act fast, and the bandwidth to execute.

  The real problem for companies: Many exceptional people were never blocked by ability but by overhead. AI lifts this block—that’s why more people are founding solo (now a third of all VC-backed US startups). If companies don’t free up this talent within their structures—by killing overhead, allowing “no,” protecting vision, supporting ambition—these people leave and found solo.

  For leaders: You must identify and cultivate talent, not just eliminate it. This means: kill overhead, build disagree-and-commit culture, let people say no to meetings and good ideas that don’t fit, foster intentional excellence. AI also helps people level up (e.g., Peter Levels learned TypeScript via AI). Two years of AI-native building could develop more relevant pattern recognition than eight years of traditional execution.

  The uncomfortable implication: Solo founding is often less a choice than a symptom of corporate failure—talent doesn’t flee because they lack the skills they’d need, but because they can’t develop this skill and freedom within the company.

  Tools/models discussed: No specific AI tools or models mentioned; focus on organizational principles and human skills—Format: Opinion/reflection (deep-dive), addresses leaders and individuals in the AI age.

Alejandro AO (1 new video)

• How to Evaluate and Test Agent Skills
  19.3.2026, 10:40:35

  Summary: How to Evaluate and Test Agent Skills

  The video covers systematic evaluation and testing of agent skills, which function as software written in natural language. Skills are divided into two categories: documentation skills (teaching agents how to use existing tools) and workflow skills (defining specific steps to accomplish tasks). The optimal model combines both – skills like Hugging Face’s Model Trainer not only document tool usage but also encapsulate complete workflows.

  The recommended skill lifecycle follows four steps:

  1. Defining success across four dimensions: outcome (correct results), process (expected steps and tool usage), style (formatting, naming conventions), and efficiency (avoiding unnecessary commands and detours).
  1. Manual validation with controlled prompts – both explicitly triggering prompts and implicit and negative controls that show when a skill should not be activated.
  1. Structured test documentation in CSV or JSON with test ID, trigger status, prompts, and expected outcomes – later automated through sub-agents.
  1. Evolutionary test expansion: Start with basic checks (does it work?), later add failure cases, then introduce more quantitative efficiency metrics.

  A recommendation is implementing an LLM-as-Judge that triggers sub-agents with clear rubrics for each success aspect and evaluates automatically. Skills must be version-controlled in Git to track errors against changes. Important: Unlike traditional software, skills often work right from the start (because LLMs are clever), but that doesn’t mean they work optimally – continuous monitoring is necessary.

  Topics covered: OpenAI (article basis), Codex/Claude Code, Hugging Face – demo with Model Trainer skill. Format: Tutorial/Deep-Dive.

Alex Finn (3 new videos)

• LIVE: I built my own AI research lab (Hermes agent/OpenClaw)
  20.3.2026, 20:13:12

  Summary:

  The creator showcases his own “AI Research Lab,” which he built over the last few days using OpenClaw and the Hermes Agent. The lab leverages Carpathy’s Auto-Research Framework and currently runs three autonomous experiments – two of which continuously fine-tune prompts, while an “R&D Council” of five AI agents meets twice daily to evaluate features and debate improvement suggestions.

  The creator explains his understanding of “Vibe Coding”: OpenClaw for on-the-go prototypes and Mission Control (since OpenClaw knows itself best), Claude Code for production applications. As orchestrator, he currently uses GPT-5.4 (cheaper than Claude Opus) but plans long-term to integrate locally-run models like Qwen. He works on an M5 Max Mac Studio and a DGX Spark (specifically for fine-tuning).

  Broader theses: The creator criticizes Anthropic for only copying OpenClaw features and abandoning its earlier product vision. While Claude Code remains technically strong, OpenClaw dominates through its open-source design and lack of security restrictions. He argues you should test multiple agents in parallel rather than relying on a single tool.

  On monetization, he advises against rushing to make money, instead continuously experimenting and creating value. He sharply criticizes trading bots and prediction markets as time-wasting and gambling; the real opportunity lies in positive-sum businesses solving real problems.

  The stream jumps between technical details, philosophy, community exchange, and personal anecdotes – typical for his live format.

  Conclusion: The video covers OpenClaw, Hermes Agent, and Claude Code in the context of a self-built AI Research Lab with autonomous experiment loops; format is live stream (demo + opinion/reflection).

• LIVE: The ULTIMATE OpenClaw Mission Control revealed!
  18.3.2026, 20:29:22

  Summary: LIVE: The ULTIMATE OpenClaw Mission Control revealed!

  The streamer showcases his complete personal OpenClaw Mission Control, a system of custom tools for automating and managing AI agents. Key components include: a Kanban board for task management (agents check for new tasks every five minutes), an activity feed for live overview, a content pipeline for scripts and thumbnails, a calendar for scheduled cron jobs, and a docs section for artifacts created by OpenClaw. He’s also working on a CRM system that automatically captures conversations and updates contact information – a “Life CRM” documenting every interaction.

  Side topics: The streamer met Peter Steinberger at the Nvidia event and discusses differences between local and cloud models. His current recommendation: Claude Code via Codeex (discovered through testing that Claude Code delivers better outputs). He’s currently testing Hermes Agent and built his own model on the DGX Spark trained on his YouTube transcripts. Criticism of the sponsorship model: He turned down $30,000 from Hostinger and criticizes creators who promote products they don’t use. On local models: Nvidia’s pivot to Nekstron 3 is positive; he sees local and open-source models as the future.

  Tools/providers mentioned: OpenClaw, Claude Code, Codeex, Hermes Agent, DGX Spark, Nekstron 3, Chat GPT Browser, Vercel, Vibe Coding Academy. Format: Live Q&A/demo with walkthrough.

• The only OpenClaw tutorial you’ll ever need (March 2026 edition)
  17.3.2026, 21:34:07

  The Only OpenClaw Tutorial You’ll Ever Need (March 2026 Edition)

  OpenClaw is an AI agent automation tool that enables individuals to build an autonomous AI team working 24/7 – unlike conventional chatbots that answer questions. The core difference: you give OpenClaw goals, receive results, and the system continuously improves itself. OpenClaw runs locally on any computer (not on VPS/hosting servers, contrary to widely-sponsored tutorials), can be controlled via Telegram, Discord, or WhatsApp, and can handle autonomous tasks like research, code review, email management, and app development.

  Setup and model selection: Installation happens with a single terminal command line. For AI models, Claude Opus 4.6 (via Anthropic API) is qualitatively superior for agent tasks – but costs more. OpenAI’s GPT-5.4 is supported by OpenAI ($20/month) but often fails on complex agent tasks. Chinese models (Qwen, Minmax) or Open-Router free models are cheaper but deliver lower performance. Telegram and Discord are recommended as interfaces; Discord enables multi-channel workflows.

  Use cases: Beginners start with automated daily briefings (e.g., stock market research with automatic ranking by market protection). Advanced workflows combine news gathering → content draft generation → app prototyping. The core method for finding your own use cases is “brain dumping” (documenting your daily routine) followed by “reverse prompting” (asking the AI system what 10 automations it could implement for you).

  Discord setup, skills, and memory: Discord organizes workflows in separate channels. Skills (text files with instructions) are a security risk; instead of installing third-party skills, have OpenClaw rebuild them from scratch. Memory is improved through daily journal entries documenting important conversation contents.

  Mission Control: A self-built software dashboard where OpenClaw creates custom tools (calendar for scheduled tasks, memory section, document storage, visual office interface, team overview).

  Security: OpenClaw only executes what’s explicitly requested – it doesn’t automatically leak data. The key is personal responsibility: before each prompt, verify whether critical consequences could occur. Security breaches are extremely rare (only one known case mentioned: accidental email deletion due to imprecise prompting).

  Troubleshooting: Fix problems by applying Claude Code or Codeex to your local OpenClaw folder – typically they’re config errors.

  Future: The next phase is local AI models (e.g., NVIDIA Nemotron 3 Super) instead of cloud APIs – for data protection, complete control, and free operation. High-quality local models will be available in ~6 months for $1,000–2,000. The video creator is already preparing with Mac Studios and DGX Sparks.

  This video is a comprehensive tutorial with demonstrations of stock research briefings, Discord workflow setups, and mission control interfaces; it covers OpenClaw, Anthropic Claude API, OpenAI, Qwen, Minmax, Claude Code, and Codeex.

Andrej Karpathy

No new videos in this period.

Bart Slodyczka (3 new videos)

• Claude Cowork Projects Is Here (And It’s Changing How I Work)
  22.3.2026, 11:03:35

  Claude Cowork Projects – Summary

  The video introduces the new Projects feature for Claude Cowork, which previously existed in Claude Chat and is now available in Cowork as well.

  Core of the feature: Projects group related work in dedicated workspaces. Each project automatically receives:

  • Custom Instructions (at project level)
  • Scheduled Tasks (tasks with deadlines)
  • Context (local files, external resources, Skills and Plugins)
  • Built-in Memory – the most important innovation for the speaker

  Memory System – Hard vs. Soft Memory:

  The speaker distinguishes between “Hard Memory” (learning points and notes deliberately stored in Markdown files) and “Soft Memory” (Claude automatically searches all project conversations, automatically creates a Memory resource from important content every 24 hours that future sessions can use). This creates nuanced memory without manual management.

  Three ways to create a project:

  1. Import project from Claude Chat
  2. Convert existing Cowork folder
  3. Create from scratch

  Practical application (example: client Apex Digital):

  The speaker demonstrates how to set up a project for a new client – with Custom Instructions (who the client is, goals), an uploaded proposal document, and instructing Claude to automatically create Scheduled Tasks from the proposal’s timeline. He then instructs Claude to continuously maintain a “learnings.mmd” file to document client preferences, new tools, and credentials.

  Tips for continuous work:

  • Perform regular housekeeping of project Instructions
  • Use end-of-session prompts: before ending a session, ask Claude to extract key insights into Memory files and generate a follow-up prompt for the next session (creates more fluidity than just Memory updates)
  • Optional: Build Skills/Plugins with slash commands (e.g., /new-client for standardized onboarding questions)

  The speaker emphasizes that Projects can exist over long periods (6+ months) and allow you to quickly re-engage with old client work, even if the last session was weeks ago.

  Explicitly mentioned tools/integrations: Google Calendar, Gmail, ClickUp (as possible Skill integrations), n8n (for Workflows).

  Claude Cowork, Demo and practical use cases for client management.

• Claude Code Just Got a MASSIVE Upgrade (Channels)
  20.3.2026, 11:37:58

  Summary: Claude Code Channels – Telegram and Discord Integration

  Claude Code has introduced the new “Channels” feature, which allows you to control a locally running Claude Code session directly via Telegram or Discord. This means: The session runs on your home computer, you can leave the house and manage the session via smartphone through Telegram or Discord – send messages and receive responses.

  Important prerequisites:

  • The feature is still in Research Preview
  • Claude Code must be updated to version 2.1.8 or later
  • Authentication must be done via Claude.ai (not via API key or console)
  • Pro and Max plan users can use it directly; Team and Enterprise accounts need to manually adjust permissions

  Telegram Setup (step by step):

  Create bot via BotFather, obtain bot token → Install Claude plugin → Configure token → Start Claude Code with --channels telegram → Message the bot on Telegram to get pairing code → Enter pairing code in terminal → Lock access with allow-list

  Discord Setup (similar process):

  Create app in Discord Developer Portal → Activate Message Content Intent → Reset bot token → Set OAuth2 permissions (6 permissions) → Add bot to server → Install Claude plugin → Configure token → Start Claude Code with --channels discord → Message bot on Discord for pairing → Enter pairing code → Lock access

  Important: Messages entered directly in the terminal session are not forwarded to Telegram/Discord – so there are two isolated communication paths. Everything from outside (Telegram/Discord) is visible in the session, but not vice versa.

  Demo with Claude Code and practical setup guide for Telegram and Discord integration — Tutorial.

• Claude Cowork Full Tutorial: How to Use Claude Cowork Better Than 99% of People
  16.3.2026, 11:13:43

  Summary: Claude Cowork Full Tutorial

  Claude Cowork is an autonomous desktop tool in the Claude Desktop App that gives Claude direct read and write access to computer folders and can independently execute multi-step tasks – including parallel sub-agents. Unlike Claude Chat (Q&A system) and Claude Code (for developers, terminal-based), Cowork is designed for non-technical users and provides autonomous execution capabilities through a visual folder/file interface.

  Basic setup: A paid Claude account (Pro or Max – not free), Desktop App download (Desktop only, no browser/phone), and a dedicated workspace folder with subfolder structure (context, projects, output) are required. Central to this are persistent MD files (about-me.md, brand-voice.md, working-preferences.md) that are loaded with each task, allowing Claude to work more consistently and purposefully. Global Instructions should be set in Settings to instruct Claude to read these context files.

  Extended Capabilities: Skills are reusable AI workflows – instead of describing each process from scratch, you can convert a one-time executed task (e.g., categorizing invoices and consolidating them in Excel) into a Skill. Schedule Tasks allow you to run Skills automatically on a recurring basis (e.g., every Monday at 9 AM). Connectors link Cowork to external apps (Gmail, Slack, Drive, Apollo, etc.) with granular Read/Write permissions. Plugins are preconfigured collections of Skills and Connectors – for example, a Sales Plugin with Lead Enrichment, Prospecting, and Sequence Loading Skills – enabling you to automate entire roles.

  In the demo example, 5 invoices were categorized and consolidated in an Excel spreadsheet, this process was then saved as a Skill and placed on a weekly schedule – all without manual prompts afterward.

  Note: Scheduled Tasks only run when the Desktop App is open and the computer is powered on. Skills and Connectors save tokens as they use scripts instead of token-consuming analysis prompts.

  Claude (Anthropic), Tutorial with developer focus.

Ben AI (1 new video)

• Claude Cowork Just Changed Sales Forever
  19.3.2026, 13:33:04

  Claude Cowork for Sales Automation

  Claude Cowork enables you to automate sales workflows through Skills – automations created via prompting. The user demonstrates concrete use cases:

  Prospecting & Lead Qualification: A custom Skill scrapes LinkedIn post engagers, qualifies them against your ideal customer profile (ICP), and enriches the data (company size, website, description). Key connectors include Appify (for scraping LinkedIn, Google Maps, Apollo, etc.), Clay, VIP Prospecting, and email platforms like Instantly or LinkedIn tools such as Uniow for automated outreach.

  Lead Nurturing & Follow-ups: A “Prospect Miner” Skill searches lost CRM leads, researches them, scrapes their LinkedIn profiles, analyzes email communication, and prioritizes them by ICP. The key advantage: you can deploy Sub-Agents in parallel to efficiently process large lead lists (100–200 entries).

  Call Prep: A customized Entropic Skill leverages CRM, email, and Fireflies transcript data to provide a structured call brief in HTML format before calls (company overview, interaction history, agenda suggestions). With the new Scheduled Tasks feature, this can run daily at 7 AM automatically.

  Sales Analytics: A Win-Loss Analysis Skill analyzes won and lost deals through CRM data, transcripts, and email communication to create detailed Google Docs reports with win rates, objections, patterns, and red flags. A Sales Rep Performance Skill evaluates individuals based on transcripts and CRM data across different pipeline stages (Discovery, Demo, Objection Handling, etc.).

  Skill Creation: All Skills are created by running a workflow once with Claude and then asking to convert it into a Skill – Claude saves the steps as structured Markdown. Entropic’s pre-built Sales Plugin offers starter Skills (Account Research, Call Prep, Competitive Intelligence) that you can easily customize, for example by telling Claude how your company structures call preps.

  Top connectors overall: CRM (e.g. Ato), Appify, Gmail, Fireflies (Transcription), Calendar, Email, plus outreach platforms.

  Claude Cowork, Entropic Sales Plugin – Demo with practical sales use cases (standard difficulty).

Brian Casel

No new videos in this period.

Coding with Lewis

No new videos in this period.

Cole Medin (2 new videos)

• The Subagent Era Is Officially Here – Learn this Now
  19.3.2026, 00:00:28

  The Subagent era is here – Here’s what you need to know

  OpenAI has released GPT-5.4 Mini and Nano, and for the first time explicitly highlights in their announcements that these models are specifically designed for subagents – a signal that goes beyond a mere model release. The entire industry is focusing on subagents: Cloud Code is building intensively on them, Google released Gemini-3.1 Flash Light for “Intelligence at Scale”. The heavyweight focus is now on smaller models, not the largest ones – a sign that we’re entering the subagent era.

  Why subagents are revolutionary for AI-coding:

  Subagents help solve the context rot problem (models get overwhelmed by too much information). The solution: delegate token-intensive but less demanding tasks like codebase analysis and web research to subagents, while your main agent stays focused. When subagents return only a small summary after research, you don’t need expensive large models for that.

  Model comparison:

  Claude Haiku 4.5 was the standard model for a long time – but GPT-5.4 Nano is already five times cheaper, delivers better benchmarks (LiveBench: GPT-5.4 predecessor ~66 vs. Haiku ~61) and is much faster (188 tokens/second vs. 53). GPT-5.4 Mini is even cheaper than Haiku and significantly more powerful.

  Practical application (used daily):

  • Planning phase: Spin up 3+ subagents in parallel for web research (best practices), codebase analysis (web adapter, backend), etc. Example: For a memory bug, almost 2 million tokens were used for web research – unrealistic with expensive models, but economical with Mini/Nano.
  • NOT for implementation: Don’t use subagents for actual code implementation – only for research. The main agent must oversee all files when writing; separate frontend/backend/database subagents lead to hallucinations.
  • Added benefit: Subagents can also research unexpected bugs as a sidecar and create GitHub issues without interrupting the main workflow.

  Tools with subagent support:

  Cloud Code (pioneer, continuously expanded), Codeex, GitHub Copilot (new: research, code analysis, code review), Cursor, Open Code – all are building in direct support.

  Core message:

  With increasingly cheaper and faster models, the subagent budget grows almost limitless. This unlocks massive possibilities: instead of context rot, we now have context isolation through specialized subagent “arms” that research in parallel while the main agent stays clean. The industry is building toward this architecture.

  Bonus: The video also demonstrates an agentic RAG system on Oracle’s AI Database (LangChain/LangGraph with hybrid search).

  OpenAI GPT-5.4 Mini/Nano and Claude Haiku 4.5 are explicitly discussed, with mentions of Codeex, Cloud Code, Cursor; the video is an opinion/reflection with practical use-case demos – directed at developers with AI-coding ambitions.

• I’ve Used Claude Code for 2,000+ Hours – Here’s How I Build Anything With It
  16.3.2026, 19:15:03

  Summary: Claude Code after 2,000+ hours of use

  The creator has worked intensively with Claude Code for over a year and shares a systematic strategy for using the tool called the “WHISK-Framework,” specifically designed to prevent context rot – the main challenge with AI-coding assistants. The central thesis: approximately 80% of errors stem from poor context management, not model limitations. Even the new 1-million-token limit doesn’t change the fact that too many tokens overwhelm the LLM with “distractors,” similar to the needle-in-the-haystack problem.

  The WHISK-Framework consists of four strategies:

  W (Write) – Externalize agent memory: use Git commits with standardized, detailed messages as long-term storage; start each new implementation in a fresh context window (separate planning and implementation session); maintain progress files and decision logs to transition to new sessions when context fills up.

  I (Isolate) – Use subagents for research and planning to keep hundreds of thousands of tokens out of the main context (only ~4% of the window instead of 100%); use the “scout pattern” to evaluate documentation beforehand before loading it into main context.

  S (Select) – Load context in four layers: (1) Global Rules (500–700 lines, always active), (2) On-Demand-Context (only for specific codebase parts), (3) Skills (agents load them as needed), (4) Prime Commands (at session start for live codebase exploration).

  C (Compress) – Only as last resort; use handoff command or slash-compact with optional summary instructions.

  The Archon project (an AI command center for long-term workflows) serves as a practical example of these strategies in a large, complex codebase.

  Claude Code with deep-dive focus on enterprise practices and context engineering; opinion/reflection based on 2,000+ hours of practical experience.

Datapizza (1 new video)

• A Pisa il primo esame da sostenere con la GenAI
  17.3.2026, 16:00:49

  Summary: “A Pisa il primo esame da sostenere con la GenAI”

  The episode covers three major news stories around AI in education, regulation, and research:

  University of Pisa introduces AI requirement: The University of Pisa has taken a groundbreaking step by integrating GenAI as a mandatory element in the “Advanced Programming” course for computer science master’s programs. Rather than focusing on manual code writing, students now learn to critically read, understand, and evaluate AI output. A custom GPT was developed to generate learning materials from lecture transcripts. In the final exam, students must mandatorily implement a project with AI assistance – they are assessed not on code quality, but on their ability to supervise and critically analyze AI output. According to the initiators (professors Antonio Cisternino and Andrea Corradini), this is necessary because AI is massively displacing programming jobs, particularly junior positions. Graduates will enter the workforce already equipped with AI as a tool – not without competence, but with exponentially enhanced capabilities. The university is signaling an understanding that AI is not a “cheating risk,” but a multiplier of expertise.

  Anthropic sues US government: Following its ban by the Pentagon, Anthropic filed two federal lawsuits on March 9th – against the Department of Defense and other agencies. The company challenges the blacklist as arbitrary, invoking the First Amendment (freedom of speech) and Fifth Amendment (due process, protection against arbitrary deprivation). Anthropic views this as retaliation for maintaining ethical boundaries in the use of its technology and refusing certain government contracts. A victory could set a precedent: the constitutional right of tech companies to set ethical limits on their technology.

  Anthropic Institute founded: In parallel, Anthropic launched a research institute on March 11th to investigate the social, economic, and legal impacts of AI systems. It builds on three internal teams (Frontier Red Team for stress testing, Social Impact Team, Economic Research) and focuses on the transformation of professions, markets, and ethics as well as alignment and governance. This distinguishes Anthropic from other Big Tech providers: foundational research appears to be core business there, not a sideline – similar to academic institutes, but within a private company.

  Yann LeCun founds AMI Labs: The former Meta Chief AI Scientist officially announced his startup Advanced Machine Intelligence Labs, funded with approximately 890 million euros (3.5 billion dollar valuation). LeCun is focusing on “World Models” – models that understand real space and predict future states – rather than Large Language Models. These models capture causality, physics, and enable safe robotics applications. Nabla is the first partner (in healthcare, simulating clinical scenarios). LeCun criticizes LLMs as insufficient for genuine artificial general intelligence; World Models could form the foundation on which generative systems build. AMI Labs is Europe-based (Paris) – a rarity for AI frontrunner startups.

  The episode discusses how these three news stories interact with each other: education must build AI competence, while regulatory battles and alternative research paradigms (World Models instead of just LLMs) reshape the landscape.

  Mentioned actors/tools: Anthropic, Claude, Yann LeCun, Anthropic Institute, AMI Labs, Nabla, Meta, Pentagon, University of Pisa; no specific tools like Cursor or Lovable mentioned. Format: Roundup / News Update.

Greg Baugues

No new videos in this period.

AI and Strategy | Le SamourAI (1 new video)

• 96% failure rate: the AI lie about working in your place
  16.3.2026, 17:00:04

  Summary: 96% failure rate – The lie of AI working in your place

  The video criticizes the widespread overestimation of AI agents in enterprise automation. The central thesis: While tech marketing boldly promises “autonomous systems,” critical information actually disappears between session switches in reality – like a manager without a handover protocol.

  Key points on agent definition: A true agent transfers control flow from human to model – the system decides independently which action to perform and when. This distinguishes it from classic workflows (predefined sequence) and chatbots (user holds initiative). An agent-based workflow adds another layer: the orchestration system itself dynamically decides which sub-agent takes on the task.

  The central problem – opacity and silent erosion: With classic automation, you see exactly which step fails. With agents, you only get the end result – the path remains opaque. This enables so-called “instrumental convergence”: the model optimizes so aggressively for its goal that it begins to circumvent safety measures. This isn’t malice, but statistical behavior – the optimal path almost always contains the same shortcuts.

  The 40% quota reality: Gartner predicts 40% of agent projects will be abandoned – but this only affects the most advanced 10% of the market. That means: four out of ten pioneers fail. The reason lies not in the technology itself, but in unclear business value, exploding costs, and underestimated operational risks.

  The “agent washing” problem: The term describes how every automation loop suddenly calls itself “agent-based.” A simple no-code connection with a Salesforce integration isn’t a true agent – Gartner counts only about 130 out of thousands of vendors as genuine agent solutions. The three test questions for true agents: (1) Can the system adjust its plan independently? (2) Can it coordinate multiple tools without manual configuration? (3) Does a verifiable audit log of all decisions exist?

  The marathon-vs-sprint problem: Agents excel at short, precise tasks under one hour. Once a project runs for days or weeks, performance collapses – not due to lack of intelligence, but because of the context window problem. The agent “forgets” its original constraints progressively and then reproduces its own approximations. Unlike a human who realizes they’ve forgotten something, the agent doesn’t notice its memory gaps at all.

  Protocol and standards as key: The real battle doesn’t happen between models, but at the infrastructure standards level. Anthropic pushes MCP (Model Context Protocol – the “socket” for tool connections), Google launches A2A with 150+ partners (the “common language” between agents). These are complementary, not competing. But the major risk: European companies build their foundations on American standards and then get locked into dependency on their roadmaps – similar to AWS customers today.

  New competency requirements: The real bottleneck is no longer syntax, but the ability to formulate intentions without ambiguity. This requires two skills: (1) specifying constraints and output formats precisely, (2) telling the system exactly which paths it can take, which APIs to avoid. This is less “programming” than “functional eloquence” – a strength of experienced (senior) professionals and product managers.

  Delegation rule: Before using an agent, don’t ask “Is it intelligent enough?” but “What concretely happens if it fails?” Agents work reliably when errors are reversible (generating code, writing articles). They fail catastrophically when errors are irreversible (email to 1000 clients, payment triggered, critical CRM data deleted).

  The invisible core problem: Similar to nuclear power plants, where the shift supervisor gives a successor a structured handover briefing, agents need a protocol to compile their “mnemonics” between sessions – not dumping complete logs, but only passing strategically vital information and current status. This engineering problem is strategically decisive for 2025 and completely underestimated.

  The video ends on a grim note: the economic truth is that it’s not about agent construction, but about long-term agent piloting without derailment. Whoever builds true hybrid orchestration competencies by 2026 will lap the rest of the market – or won’t even be brought along.

  Explicitly mentioned: Claude, GPT, Gemini, Anthropic (MCP protocol), Google (A2A standard), Open AI, Gartner, Deloitte, n8n, Zapier, Make, Cursor; Format: Opinion/Deep-dive with strong critical focus on widespread misconceptions in the agent market.

Julian Ivanov | AI Automation (1 new video)

• The 10 Best Claude Code Skills & Plugins
  19.3.2026, 19:52:36

  Summary: The 10 Best Claude Code Skills & Plugins

  The video presents ten practical skills and plugins for Claude Code that equip the agent with additional context and functionality. The core idea: skills are Markdown files with instructions that Claude automatically loads depending on the situation; plugins combine skills with additional reference files or other components.

  The 10 Tools at a Glance:

  1. Excalidraw Diagram Skill – Automatically creates diagrams and visualizations as PNG/JSON, Claude checks the output for errors and corrects them iteratively.
  1. Notebook LM Plugin – Gives Claude programmatic access to Google’s Notebook LM; enables him to research, create wiki collections, generate podcasts, slides, and infographics – all source-based and free.
  1. Remotion Skill – Claude creates real MP4 videos with code instead of AI generation; changes can be made precisely (e.g., slow down individual scenes) without re-rendering the entire video.
  1. Context7 – Gives Claude access to current API documentation (e.g., Stripe, frameworks) as a CLI tool, prevents hallucinated APIs and outdated code, more token-efficient than MCP servers.
  1. Firecrawl – Advanced web scraping solution: crawls entire websites with JavaScript rendering, extracts structured data precisely, and handles anti-bot measures.
  1. Playwright CLI – Controls browsers through code analysis instead of screenshots; faster and more reliable than the cloud browser extension, runs headless in the background.
  1. Obsidian Plugin – Connects Claude with a personal knowledge system of Markdown files; Claude can read, link, and summarize notes, becoming a personal assistant with memory.
  1. Feature Death Plugin – Structures feature development into 7 phases: Discovery, Codebase Exploration, Clarify Questions, Architecture Design (multiple variants), Implementation, Quality Review, Documentation.
  1. Superpowers Plugin – Comprehensive framework for entire app development; includes brainstorming, test-driven development (tests before code), systematic debugging, subagent-driven development.
  1. Cloud MD Management Plugin – Audits and updates cloud configuration files; checks for completeness and compactness, helps integrate new insights from sessions into the cloud MD.

  Claude, Anthropic, n8n, practical demo video with concrete use cases – Tutorial/Demo.

Kyle Balmer | AI with Kyle (8 new videos)

• Why Your Vibe Coded Apps Still Feel Like Toys
  19.3.2026, 19:15:01

  Summary:

  The video explores how to move from superficial “toy” apps to real, productive applications using Vibe Coding (No-Code/Low-Code tools). The core approach: don’t build directly in the Vibe Coding tool, but plan outside of it first. The creator uses Claude with company knowledge (via Memory function) to generate ideas and clarify requirements. In the example shown, he develops a “What Should I Automate First?” tool—a one-page prioritizer that asks users which tasks they should automate. The method: first ask clarifying questions with Claude (or ChatGPT/Google) and create a detailed plan before transferring the final solution to a Vibe Coding tool (here: Google AI Studio Build). This prevents the tool from jumping into building too quickly instead of planning thoroughly. For complex projects, the creator recommends breaking them into smaller modules and building them sequentially and connecting them, rather than trying everything “one-shot.” The tool uses the Gemini API to create a three-stage user journey (Discovery, Rating, Results) with brand colors (white + purple).

  Claude and Google AI Studio Build were explicitly discussed; format: opinion/reflection with practical demo integration.

• How to start VIBE CODING for free (no coding experience required, at all)
  19.3.2026, 07:30:03

  Summary: How to start VIBE CODING for free

  The video creator shows how absolute beginners with no programming experience can build something in minutes using AI tools. The core idea: “Vibe Coding” means creating applications through natural language description without writing code yourself.

  The recommended entry point: Google AI Studio in “Build Mode” (not the main version). This tool offers a chat interface that immediately shows a working preview panel—you can see and use the app in the browser without deploying it first. This is crucial to avoid the frustration that comes with other tools (e.g., downloading code, compiling locally).

  The first project: A simple toy project, not your dream product. The creator builds a “Social Growth Projector” as an example—a calculator app where you enter how many followers you have and at what weekly growth rate, then see when you’ll reach your goals. He explains: just speak in English about what you want, hit “Build”—the tool does the rest.

  Troubleshooting: If something doesn’t work or look right, either copy the error message or upload a screenshot and describe what’s wrong. The tool will then fix it.

  What to avoid at first: No databases, no user logins, no complex business logic—that comes later. Start “frictionless” so the barrier to entry falls and you experience the power of the technology.

  Next step for more complex projects: Create a detailed project plan with Claude or ChatGPT outside the Vibe Coding tool, then copy and paste that plan into the Build tool. This prevents the tool from immediately running off and building too much.

  The creator also demonstrates a second project: a “What Should I Automate First” tool that asks the user how they spend their day, then provides a prioritized list of automation candidates with concrete solution suggestions.

  Core message: Don’t start with Claude Code, don’t start with complicated setups—use Google AI Studio Build Mode, a simple project, see that it works, then iterate. The fear of programming disappears when you have something working within minutes.

  Tools mentioned: Google AI Studio (Build Mode), Lovable (paid from $20/month), Claude, ChatGPT, Supabase, Firebase, Zapier, Make.com.

  Format: Tutorial/practical demo—pitched at a “completely frictionless for beginners” level, with no technical prerequisites.

• The Best Way to Start Vibe Coding in 2025
  18.3.2026, 19:00:04

  Summary: The Best Way to Start Vibe Coding in 2025

  The speaker recommends Lovable as the best entry platform for Vibe Coding, but also mentions alternatives like Replit, Base, Bolt, and Google AI Studio (Build Mode). Google AI Studio Build is free and works similarly to Lovable, but is limited to Google’s Gemini models—the speaker still finds Lovable more powerful for rapid app prototyping.

  The recommended learning path differs by IDE type: start browser-based with Lovable or AI Studio Build, then move to Cursor or VS Code, and finally end up with Claude Code or Codex as CLI tools. For hosting, the speaker uses Supabase (backend) and Vercel (deployment), but emphasizes that the specific choice doesn’t matter—what matters are the costs involved, which run about 100–200 dollars monthly for multiple apps but remain marginal compared to revenue.

  The biggest beginner trap: People try their dream project (marketplace, SaaS, social network) right away and give up when they get stuck. Instead, the speaker recommends five sequential toy projects (calculator → decision tool → link-tree clone → data handling → login system) to gradually build skills. He develops a generator that suggests specific project ideas based on user profile (e.g., real estate agent in UK)—in the example, a UK Stamp Duty calculator. These mini-projects can be completed in five days and are part of a larger skill-tree structure the speaker is building.

  Tools mentioned: Lovable, Google AI Studio Build, Cursor, Claude Code, Codex, Replit, Bolt, Base, Supabase, Firebase, Vercel, Gemini — Format: Tutorial/opinion with demo elements.

• LEVEL UP: The AI Skill Tree (Most People Stuck at Level 1)
  18.3.2026, 06:59:53

  Summary: LEVEL UP – The AI Skill Tree

  The creator presents a seven-level skill tree model to become “AI Native”—a structured learning journey that provides a clear progression system beyond chaotic tech information.

  The seven levels:

  1. Beyond Google: Shift from pure information gathering (Google replacement) toward AI as a thinking partner. Instead of asking questions and accepting answers, have conversations with AI, provide deeper context, and train “Prompt Engineering” as a communication skill.
  1. Projects: Move from ad-hoc chats to persistent workspaces that enrich themselves with context over time—for example, a newsletter project with brand guidelines and previous content that builds on this foundation daily.
  1. Personal AI: Customization through custom instructions, brand guidelines, skills (packages of instructions in folder structure that put Claude or ChatGPT into specific roles) and different personas for different use cases.
  1. Connected AI: Connect the AI tool with other systems via native connectors (Gmail, Google Calendar, Notion) or MCP (Model Context Protocol—open standard by Anthropic). The AI pulls information from various sources and acts autonomously.
  1. Vibe Coding: Use AI to build and deploy your own software beyond chatbots. Entry point: browser-based tools like Lovable or Google AI Studio Build (free but limited to Gemini); then move to IDEs (Cursor, VS Code) or command-line tools (Claude Code). The creator recommends starting with small toy projects (calculator → tool with logic → link-tree clone → data management → logins), not building the next Facebook right away.
  1. AI Automation: Autonomous agents and workflows that run without human intervention. Start: human-in-the-loop (person reviews each execution), then gradually move to fully AI-driven automation. This is where productivity doubles because the AI handles tasks that would take hours.
  1. AI Operator: Independence from platforms—deploy local LLMs (e.g., with LM Studio), fine-tuning, larger agentic frameworks. Optional for most, but valuable as practice.

  Mindset shifts per level: from searching to thinking together, from “always start from scratch” to “build context,” from generic consumer app to personalized tools, from “execute task” to “design system,” from dependent to independent.

  The creator criticizes that existing learning resources (Anthropic, DeepLearning.ai) are good but unsorted—you don’t know which courses to take first. He’s attempting to cut through that chaos with this skill tree. Planned: mini-guides for each node, practical exercises, and capstone projects per level, independent of specific tools (which change), focused on skills and mindset.

  Tools/Models: Claude, ChatGPT, Gemini, Lovable, Cursor, Claude Code, Codex, LM Studio, NotebookLM, Supabase, Vercel, Google AI Studio Build, MCP (Model Context Protocol) | Format: Deep-dive/educational framework, practically oriented for absolute beginners to intermediate

• He Used ChatGPT to Make a Cancer Vaccine (And It Worked)
  17.3.2026, 20:30:07

  A man named Paul Ingham used ChatGPT and AlphaFold (DeepMind) to develop a personalized cancer vaccine for his dog Rosie—successfully. After traditional treatments failed, he had Rosie’s genome sequenced for $3,000, fed the data into AlphaFold to identify mutated proteins, and used ChatGPT to work out a plan for vaccine development. Although Ingham is not a medical professional, these AI tools enabled him to find potential targets and corresponding therapeutics. After administering an mRNA-based vaccine, Rosie’s tennis-ball-sized tumor shrank by half within two months. The bigger hurdle wasn’t the scientific work but regulatory approval: Ingham needed full ethical clearance for a drug trial and spent three months working on a hundred-page document until the University of New South Wales supported the project under its umbrella.

  The broader implication extends far beyond a single dog: the concept shows that highly personalized medications—tailored to an individual patient’s genomics—can be developed effectively and in timely fashion. Experts like Martin Smith (Computational Biology, University of New South Wales) suggest this method could soon be applied to humans, ushering in a new era of individualized cancer therapy. The case also demonstrates “citizen science”: a layperson with basic computing skills could advance complex biotechnology processes—made possible by freely available AI tools. The transcript underscores that technology is ahead of ethical and regulatory frameworks.

  ChatGPT and AlphaFold (DeepMind) were central; format: opinion/reflection with concrete case study.

• 143M jobs scored by how at RISK they are from AI
  17.3.2026, 07:45:01

  Summary: 143M Jobs Scored by AI Risk

  The video creator discusses an analysis by Andrej Karpathy (co-creator of ChatGPT) that scored 143 million US jobs by their risk from artificial intelligence—on a scale from 0 to 10. The output visualizes results like a stock market heatmap: green for safe jobs, red for high-risk ones.

  Key findings from the analysis:

  • Safe jobs (low risk): Tradespeople, construction workers, elderly care workers, cleaners—jobs that are physical and non-algorithmic
  • High-risk jobs (risk 8–9/10): Software developers, customer service, administrative staff, secretaries, lawyers (they mainly do document-driven, digital work)
  • Total wage exposure: $3.7 trillion in wages could disappear from the US labor market

  The analysis was deleted 10 hours after Karpathy published it; however, a GitHub clone by Josh Kale keeps the data publicly accessible. The video creator highlights three protective factors: physicality (work in the real world rather than at a computer), variability (different tasks daily), and empathy (human interaction required).

  Additional stories in the video:

  A private citizen in Australia (Paul Cunningham) used ChatGPT and AlphaFold from Google DeepMind to develop a personalized mRNA cancer vaccine for his dog Rosie—successfully: the tumor-like mass shrank by half. The project showcases the potential of personalized medicine for humans and took less time than approval procedures.

  Meta delayed publishing its new AI model “Avocado” until at least May because it underperformed in internal evaluations and couldn’t compete with Gemini, Claude, or ChatGPT. This signals Meta is stepping back from the AI race; Gemini from Google is being integrated across Apple, Android, and Chrome, becoming the default AI.

  The video creator’s recommendation: keep your 9-to-5 job, build parallel income streams, and get familiar with Claude Skills (reusable AI capability packages) and available skill repositories to become more optionality and independent.

  Explicitly mentioned tools/providers: ChatGPT (OpenAI), Claude (Anthropic), Gemini (Google), AlphaFold (Google DeepMind), Claude Code, Cursor — Format: News update/roundup with opinion/reflection.

• Why Some People Think AI Is Useless
  16.3.2026, 18:31:07

  Why Some People Think AI Is Useless

  The video’s central point: most people who criticize AI or find it useless are using the free version of ChatGPT—an outdated model from six months to a year ago. They use the auto-model selector instead of deliberately choosing a stronger model, quickly hit usage limits, and therefore experience neither the capability nor the practical applications.

  The speaker observes a growing divide: users who invest in better tools and learning them (such as Claude) achieve impressive results and will be willing to pay more. Free users stay with weak versions, get poor results, become disillusioned, and don’t invest further—a self-reinforcing cycle. This group will be in a difficult position soon.

  On Claude vs. ChatGPT: both are good, but for different things. The speaker long preferred ChatGPT for personal matters because of the persistent memory feature that accumulates context over years (food preferences, games, home location, etc.). Claude only got this feature two weeks ago. The core problem with Claude is high token consumption—the model is smarter, therefore more expensive, and the free plan offers minimal usage. Anthropic pursues a different business model: rather have 40 million paying users than 900 million like ChatGPT, to conserve server resources. Those switching from ChatGPT to Claude are often surprised that usage on Claude, even with $20 monthly, runs out faster—especially with the top model Opus.

  Practical example: Claude quickly transformed an analysis report with 4,000 new subscribers, conversion rates, and A/B test insights into a finished presentation—work that would have taken a person a day. For agencies reporting to clients, Claude is practically indispensable; a $100 plan is a worthwhile business investment.

  Claude and ChatGPT as providers, opinion/reflection format.

• How to build interactive charts and diagrams with AI
  16.3.2026, 07:00:10

  Summary: Interactive Charts and Diagrams with Claude’s Visualizer

  Claude has gained a new visualization feature that lets you present information interactively—similar to ChatGPT via Blocks or Google NotebookLM. The feature is available on all Claude plans, including the free tier.

  How to trigger it: The key phrase is “Show me” (e.g., “Show me how compound interest works”). Commands like “Draw” or “Create” typically result in simple artifacts instead. To force interactive elements, you can add “Make it interactive” as well.

  Practical applications:

  • The creator used it to analyze whether TikTok or ChatGPT uses more water (finding: TikTok uses roughly 60x more)—a visualization with live data and explanations.
  • He created an interactive explanation of LLM chunking, where users can adjust parameters and watch the behavior change.
  • Business analytics: comparing four welcome email sequences (A/B/C/D test) with conversion rates, revenue, and purchase speed—all converted into a publishable artifact and shared with the business partner.

  Sharing and embedding: Visualizations can be saved as HTML artifacts and published (URL: claude.ai/public/artifact/…). They’re then accessible to anyone without a Claude account. HTML can also be embedded on websites.

  Limitations: The API doesn’t yet support visualizations—the feature exists only on the web app. Artifacts aren’t fully interactive if you download or export them as HTML.

  Bigger implication: The creator argues that high-quality AI tools (paid plans) create a “bifurcation”—those who invest see real results; those using only free versions remain unimpressed. Claude is more expensive than ChatGPT’s free tier, but on premium plans makes sense, especially for agencies needing to generate reports faster.

  Tools & models: Claude (Opus, Sonnet, Haiku); mentioned: ChatGPT, Google NotebookLM, Cursor, VS Code, Cowork, open-source models (Qwen, Kimi, DeepSeek). Format: Demo + tutorial with business use case and Q&A elements.

Leon van Zyl (3 new videos)

• 5x More Context in Claude Code – Here’s How to Actually Use It
  19.3.2026, 13:01:25

  Anthropic has increased Claude’s context windows (Opus 4.6 and Sonnet 4.6) from 200,000 to 1 million tokens – a five-fold increase. What makes it special: pricing is uniform across the entire 1-million-token window, unlike Gemini and OpenAI, which charge double for longer contexts.

  The presenter shows concrete workflows to leverage this advantage:

  Process larger files: Product requirement documents, CSV files, and datasets can now be fully loaded into context without compression and information loss from chunking.

  Better project planning: Instead of building one large project in a single session, Planning Mode divides a detailed specification (e.g., a 680-line AppSpec) into waves and features, analyzes dependencies, and groups everything into separate, parallel implementation waves. This uses only 4% of the context window.

  Agent Teams: With Claude Code Agent Teams, multiple agents can implement different waves in parallel while communicating with each other – significantly faster than sequential single-agent work.

  Integration with other tools: Tools like Autoforge, AutoMaker, and AutoClaude allow you to increase the number of features per agent session – from the recommended 1–2 to potentially 10+ features, because the agent has all affected files in memory and encounters less discovery overhead.

  Migration projects: The presenter tells of a friend whose 400+-feature production application failed because the agent assumed outdated tech stacks (SQL Lite). Manual migration under the old context windows was complicated, and context compression caused ~30% of functionality to be lost – with larger context windows, Claude would have enabled more holistic analysis.

  The presenter emphasizes: don’t cram everything into one session at once, but strategically group features so Claude can efficiently handle multiple features with the same files.

  Claude (Opus 4.6, Sonnet 4.6) with focus on Claude Code and Agent Teams; demo.

• 1 Mistake That Kills Every Vibe Coded App
  17.3.2026, 14:00:57

  Summary: “1 Mistake That Kills Every Vibe Coded App”

  The core problem: Vibe coders don’t understand the tech stack and build apps that work locally but collapse in production.

  The three main components of a production-ready tech stack:

  1. Frontend (UI): React is recommended – it’s powerful, widely used, and also enables mobile apps via React Native. Alternatives are Svelte or Astro.
  1. Backend server: The most common misunderstanding. When you want to persist data, agents often create a separate server with Express. Better: Next.js as a meta-framework that combines frontend and backend, seamlessly integrating both.
  1. Database: The critical mistake – agents choose SQLite because it’s convenient. It works locally but fails when deploying to platforms like Vercel that don’t allow persistent files. Solution: PostgreSQL with Docker for local development; Neon, Supabase, or Railway for production. Drizzle ORM connects your app to the database.

  Additionally essential: User authentication – don’t vibe code it, use an established solution like Better Auth.

  Practical tips:

  • When planning, tell the agent: “This app must be production-ready and will be deployed on Vercel” – this steers recommendations in the right direction.
  • Use a free boilerplate template that has all components pre-installed (Next.js, PostgreSQL via Docker Compose, Better Auth, Drizzle).

  The lesson: understand why each component is there. Reading the documentation is worthwhile, and agents can also work well as teachers.

  Tools/providers mentioned: Claude, React, Next.js, Express, SQLite, PostgreSQL, Drizzle ORM, Docker, Better Auth, Neon, Supabase, Railway, Vercel, Lovable, Bolt. Format: Tutorial/opinion – tailored to beginners and vibe coders.

• Your Computer Doesn’t Matter Anymore – Claude Code SSH
  16.3.2026, 13:00:35

  Run Claude Code via SSH on remote servers

  The video shows how to run Claude Code Desktop not locally on your own computer, but on a remote server in the cloud – via an SSH connection.

  Why this makes sense:

  • Data security & availability: Code and dependencies run on a VPS (Virtual Private Server) and remain available even when your own PC is shut down
  • Save resources: Your local computer stays lean; only Claude Code Desktop and the SSH connection run locally
  • Higher computing power: For resource-intensive projects (game development, machine learning), a more powerful VPS can serve as the bottleneck instead of local hardware
  • Multi-device access: Multiple devices (laptop, work PC, etc.) can connect to the same remote server

  Practical guide:

  The creator uses Hostinger as VPS provider (with coupon code “Leon” for 10% discount). Steps on the VPS: install Claude Code (curl...), then set the path and run source ~/.bashrc. After that, generate an SSH key locally on your own machine (ssh-keygen -d), copy the public key to the VPS, and register it with authorized_keys (set permissions via chmod 600/700). In Claude Code Desktop, add the SSH connection with: username (e.g., root), server IP, port 22, and path to the identity file (~/.ssh/id_rsa). You can then select a remote folder and start working with Claude Code right away.

  Demo: Windows PC locally displays Windows 11 Pro and local time; after switching to remote session, the same command shows Linux and different server time.

  The video combines Claude Code, Hostinger, and SSH setup in a practice-oriented tutorial for beginners to advanced users.

Liam Ottley (2 new videos)

• How to Build & Sell AI Agents in 2026: Ultimate Beginner’s Guide
  22.3.2026, 07:54:17

  How to Build & Sell AI Agents in 2026: Ultimate Beginner’s Guide — Summary

  Creator Liam Otley provides comprehensive instruction on how to build AI agents and earn money without any programming knowledge. He structures the course into three chapters: understanding fundamentals (what agents are, how they work), four practical build tutorials (step-by-step), and a proven monetization strategy.

  Core arguments for relevance

  Liam backs up his points with data (McKinsey, World Economic Forum) showing that 57% of all American jobs are already automatable with existing technology, while workers with AI skills earn 56% more and employers are actively seeking AI competence. With only 12% of workers having completed AI training, there’s a massive market opportunity.

  What is an AI Agent?

  A digital worker that understands instructions and executes tasks — different from chatbots in that it doesn’t just provide information but actually performs actions (booking appointments, updating databases, sending emails, creating documents).

  Five technical components

  1. Brain (LLM): GPT-5, Claude, Gemini etc. — the intelligence
  2. Prompt: Behavioral instructions in natural language instead of code
  3. Memory: Context management across conversations (usually handled automatically)
  4. Knowledge: External data (PDFs, Sheets, Docs) that goes beyond general training
  5. Tools: APIs and integrations that enable agents to act in the real world

  Liam simplifies this to three core ingredients for builders: prompting, knowledge, tools.

  How Tools work

  Tools are APIs — standardized request-response patterns on the internet. An agent needs three pieces of information about each tool: description (purpose), input (required data), output (result). Modern LLMs can read and understand these descriptions (schemas) and know when and how to use a tool.

  Example: When asked “What’s the weather in Tokyo?” the agent automatically recognizes that the weather tool is relevant, extracts “Tokyo,” makes the API call, and translates the raw data into: “72° and sunny in Tokyo with a light breeze.”

  There are two types of tools: pre-built integrations (Google Calendar, Gmail, Slack) and custom tools that you build yourself.

  Multi-Tool Workflows & Reasoning Models

  Agents can combine multiple tools to plan and execute complex tasks step by step — for example: web search for AI startups → Google Sheets to enter data → write summaries → send Gmail link. Reasoning Models (newer AI models) can reflect during execution and adjust their strategy.

  Warning: These multi-step tasks are still unreliable; human oversight is recommended.

  Two operating modes

  Conversational Agents: Users send messages directly (chat widgets, WhatsApp, Instagram DMs, phone). Automated Agents: No direct user input; instead event-triggered (form submission) or time-scheduled (e.g., daily at 9 AM).

  Practical use cases

  • Copilots: Support/sales reps with real-time knowledge support
  • Lead Generation & Appointment Setting: 24/7 website engagement, quick responses, calendar integration
  • Research/Qualification Agents: Deepen leads, find LinkedIn profiles, ask questions
  • Voice Agents: Inbound/outbound calls, appointment booking, lead qualification (Retail AI: 40 million calls/month)

  Build example: Telegram Receipt Assistant (n8n)

  The first concrete build demonstrates a more modern approach:

  1. AI Planning: A custom GPT helps plan the automation and sketch out the right n8n architecture.
  2. Spec Writing: A tool converts this planning into a perfect n8n prompt.
  3. n8n AI Builder: Insert the spec, n8n auto-generates the nodes.
  4. Iterative refinement: When complexity arises, you can go back to planning, simplify, and regenerate.

  The example shows: Telegram trigger → check message or photo → for photos: Gemini 2.5 Flash analyzes receipt, extracts fields (vendor, amount, date), if >$500 email CFO → for messages: agent answers questions about Google Sheets data. Instead of hard-coded workflows, you use an agent with tools (Sheets, Gmail) that intelligently decides when to use which tool.

  Liam emphasizes: Modern AI automation building is shifting away from manual node wiring toward AI-assisted planning + n8n AI for generation, with iterative refinement instead of deterministic pre-configuration — faster, future-proof, more accessible for beginners.

  Closing: Claude (Anthropic mentioned), GPT-5 (OpenAI), Gemini (Google), n8n, Google Sheets, Gmail, Telegram, Gemini 2.5 Flash as specific tools; beginner’s guide as course format; clearly designed for beginners since no coding is required and everything is explained in detail.

• I Set Up a Claude Code Operating System for 6 Founders in 8 Hours
  18.3.2026, 08:34:13

  Creator Liam Meley documents an 8-hour mastermind session in Cape Town where he guides six founders (with varying experience levels and industries: ex-agency owner, designer, venture studio operator, AI agency, e-learning platform, holiday broker) through setting up an “AI Operating System” (AIOS) based on Claude Code. The central thesis: Claude Code is not a programming tool but a universal “super-agent” that functions as a wrapper around existing business models and enables founders to save 80% of their time on operational tasks, allowing them instead to work strategically on the business — necessary due to shrinking margins from AI pressure on prices over the next 12–36 months.

  The workshop was structured as: (1) intros, (2) theory (business model wrapping, operator trap, urgency), (3) environment setup (Cursor, Claude Code, starter kit), (4) context OS (loading business context into the system via questionnaire, document import, website, GPT export etc.), (5) practical automations via commands like /brainstorm and /explore. Concrete outcomes: Cyble integrated Zoho and could then query unpaid invoices; Richard created competitor analyses automatically; Brian automated financial reporting; Lionus built a system for automated content idea generation.

  The learning for Meley: nontechnical founders can actually use these systems themselves if the right methodology and prompts/commands are provided — no tech team needed. Further workshops planned in Bali.

  Explicitly mentioned: Claude Code, Cursor, Zoho; format: demo + opinion/reflection, with practical use case focus.

Mark Kashef (3 new videos)

• Did Claude Code Just Make OpenClaw Obsolete?
  20.3.2026, 18:17:22

  Summary: Claude Code Remote Access via Telegram and Discord

  Anthropic has extended Claude Code with the ability to control coding sessions remotely via Telegram and Discord. The video demonstrates setup for both platforms with practical tips.

  Telegram Setup (easier): Register a bot through BotFather using the /newbot command, receive a token, and save it in an environment file. Then install the plugin, start a new terminal session, and run the corresponding command. This takes under a minute. Important: You must configure a Telegram Access Policy so only your ID can access the Claude instance.

  Discord Setup (more involved): Create a new application in the Discord Portal, configure OAuth2 with a dummy URL as redirect, enable all required permissions (View Channels, Send Messages, Read Message History, Attach Files, etc.), and generate a bot invite link. After verification via Captcha and toggling certain bot settings (disable OAuth2 Code Grant, enable Message Content Intent), the bot is ready. You should also set a Discord Access Policy here.

  Gotchas:

  • Both platforms ask for permission by default on each action (Accept-Edits mode disabled for security)
  • File attachments can be blocked and require additional configuration
  • Telegram has no History API (no conversation storage), maximum 50 MB file size; Discord can retrieve the last 100 messages (better persistence)
  • Sessions only run while Claude Code is active; for always-on operation you must run it as a background process (Claude Code can help with this)
  • Discord setup takes 5–15 minutes, Telegram under one minute

  Claude Code can be used with the Chrome plugin to automate setup itself. The speaker suggests these features could eventually replace OpenClaw as an enterprise solution.

  Claude (Anthropic) and Discord/Telegram as integrations – demo/tutorial with setup focus.

• 3 Claude Code Features You’ll Wish You Knew Sooner
  19.3.2026, 15:01:16

  Summary: 3 Claude Code Features You’ll Wish You Knew Sooner

  The video covers three features to combat context bloat in longer Claude Code sessions: The problem is that over extended use, file queries, searches, and failed attempts accumulate in the context window, leaving Claude less space for new thoughts — not because the model gets worse, but because space gets tighter.

  The three features mentioned are: Slash By The Way (for side questions that don’t belong in the main context), Fork (for creating parallel conversation branches without cluttering the main context), and Context Fork (a line in a skill file, new in the last 24 hours), which executes a skill in a separate context window.

  The core example shows a consulting scenario: A Vault Search Skill with context fork searches a personal Obsidian vault in its own context window, performs 12 searches there, and returns only the cleaned summary. While this research happens, side questions can be asked with /by the way (like “How many slides did I use in the last workshop?”) without interrupting the main task. With /fork you can then create a new conversation branch (e.g., for presentation version 2) while keeping the original conversation intact.

  The video shows live how this combination produces a 12-slide presentation with separate versions without unnecessarily bloating the context window — especially valuable for complex, time-intensive tasks.

  Claude Code with multiple best-practice features (Context Fork, Fork, By The Way) — demo tutorial.

• Claude Code Turned Obsidian Into My Dream Second Brain
  15.3.2026, 19:30:00

  The creator shows how combining Obsidian and Claude Code solved his problem with failed note-taking apps. Obsidian is a local, markdown-based app (free for desktop, optional with cloud plan for mobile), organizing thoughts, tasks, and ideas in a searchable structure. The graph view visualizes semantic connections between notes, and the canvas feature enables visualizations similar to Miro diagrams.

  The key is integration with Claude Code via Obsidian’s command-line interface (95 commands). Claude Code can automatically understand and use the CLI without the user needing to master it. The creator demonstrates a setup skill that automatically creates a personal vault structure: After four multiple-choice questions (What’s your profession? What falls through the cracks? Work-only or private? Import existing files?), Claude Code generates a customized folder structure with built-in slash commands like /tlddr (automatically creates notes from conversations) or /daily (daily briefing).

  For processing large files (PDFs, Excel, JSON), he shows a workflow: organize files with Claude, then synthesize via Gemini (1-million-token window) and convert to markdown-based cheat sheets, finally import automatically into Obsidian. Installing the Obsidian CLI is a prerequisite for full functionality. The creator provides the required skills free via links.

  Demo with tutorial elements; Claude Code and Obsidian are the core tools, Gemini is mentioned for PDF synthesis.

Matt Pocock (2 new videos)

• Building a REAL feature with Claude Code: every step explained
  18.3.2026, 14:16:47

  Building a Real Feature with Claude Code: Complete Overview

  The author demonstrates a complete workflow for implementing a real feature with Claude Code in his existing project (a React/TypeScript/Node course video manager with Postgres and Drizzle ORM). The process consists of several phases:

  Grilling Phase (Requirements Discovery)

  The author uses a “Grill Me” skill to sharpen vague requirements with Claude. He wants three main improvements:

  • Direct creation of real lessons instead of the two-step Ghost→Real process
  • Direct deletion of real lessons without Ghost redirect
  • Ghost courses: courses without a filesystem path that serve as pure planning surfaces

  Claude asks precise questions about edge cases (e.g., “Will ghost courses with real lessons automatically materialize?”), forcing the author to consistent definitions and working with an “Ubiquitous Language” document to establish precise terms like “materialize” or “materialization cascade”. This takes about 22 minutes and yields 8 concrete requirements.

  PRD and Issue Breakdown

  The author uses additional skills to write a formal Product Requirements Document and automatically break it into 6 GitHub issues (with blocking dependencies and acceptance criteria). He consolidates these into 4 slices: course creation, UI changes, direct-delete action, materialization cascade.

  AFK-Agent Loop (Implementation)

  With a Docker setup called “Sandcastle”, the author launches a “Ralph” loop—a Claude agent that pulls issues from GitHub, implements them sequentially, and writes them back to the repo as commits. This runs in the background while the author does other things.

  QA and Iteration

  After ~90 minutes, the author reviews the 6 implemented commits. He generates a QA plan, runs tests, and finds bugs/missing features (e.g., no redirect after ghost course creation, missing loading states, unwanted UI structure). He uses a feedback button to create new issues that Ralph then fixes in further iteration loops (8 iterations total, 14 commits). The workflow parallelizes QA work with the agent’s bug fixes.

  Core Philosophy

  The author emphasizes: you should use Claude like a team colleague—architecture and feedback loops matter, not comprehensive upfront planning. The Grill-Me phase is essential to establish clarity before writing code. The author’s minimal code review focuses on input/output and module interfaces, not implementation details.

  Claude Code, demo + practical workflow example; presented not as a structured tutorial but as messy, authentic documentation of a real feature build

• 5 Claude Code skills I use every single day
  16.3.2026, 16:01:49

  Summary: 5 Claude Code Skills I use every single day

  The speaker, an engineer with nearly ten years of experience, presents five skills he uses daily to steer AI agents more rigorously during software development. Because AI models have no memory, they need well-defined processes—these skills codify such processes.

  The five skills:

  1. Grill Me: A three-sentence skill that forces the model to ask relentlessly until shared understanding of a design is reached. It uses the “Design Tree” method to systematically traverse all branches of a design decision. The speaker shows an example with 16 questions for adding a feature.
  1. Write a PRD: This skill generates a Product Requirements Document from learned information. It first requests detailed descriptions, explores the repository, interviews again, then creates a structured PRD with problem statement, solution approach, and user stories, submitted as a GitHub issue.
  1. PRD to Issues: Converts a PRD into Kanban tasks—specifically into “vertical slices” that cross all integration layers rather than horizontally covering just one layer (tracer-bullet approach). The skill creates GitHub issues with blocking relationships to enable parallel work and clear dependencies.
  1. TDD (Test-Driven Development): A more comprehensive skill that forces the model into a Red-Green-Refactor loop. First the model confirms interface changes, then it writes tests before implementation, implements code to pass the tests, and looks for refactoring candidates. Particularly important: interface design for testability, since poorly structured codebases make testing difficult.
  1. Improved Code Base Architecture: This skill explores the codebase to find natural confusion and coupling problems, presents improvement candidates, and generates three radically different interface designs through parallel sub-agents. The user then chooses which designs to combine, and the skill creates a GitHub issue as a refactor RFC.

  The speaker emphasizes: skills don’t need to be long to be effective—the right words at the right time are what matters. The core principle is treating AI agents like humans with specific constraints: they have no memory but need strict, documented processes. A well-structured codebase is fundamental—bad architecture leads to bad AI output. The speaker promotes a two-week course called “Claude Code for Real Engineers” that teaches these skills and the concepts behind them (tracer bullets, feedback loops, steering).

  Claude Code for software development, practical demo/guide with theoretical depth.

Melvynx (5 new videos)

• 5 ERREURS que tu FAIS avec Claude Code (en entreprise)
  21.3.2026, 17:00:13

  The video covers five common mistakes when using Claude Code in a business context:

  1. Missing or insufficient configuration: Team leads should define central guidelines in a claude.md file (workflows, naming conventions, important file paths), set specific rules for code patterns (e.g., API usage), and add skills (e.g., performance optimizer, security check, test generation). This makes high-quality code the norm rather than the exception.

  2. Unfounded fears about permissions: The author argues that data privacy concerns about OpenAI are irrational and alternative solutions already exist. More importantly: the more access and permissions Claude has, the better the results. Limited permissions lead to weaker outputs. A fully configured Claude instance has never done anything dangerous for him.

  3. Missing standardized workflows: Instead of different developers using different tools (Cursor, various models), the team should agree on one tool and build standardized skill workflows there (e.g., “Code Scan → Planning → Execution → Code Review → Test Creation”). This ensures consistent code quality and even enables subagents (e.g., a “Clean Code” agent that flags files over 400 lines).

  4. Developer ≠ an agent: Experienced developers should monitor multiple agents in parallel (ideally 3+), not work like an agent themselves. While agent 1 runs, you can start agent 2 and review agent 3 – keeping the developer constantly productive instead of waiting for agents. Junior or mid-level developers need to learn to handle multi-agent workflows.

  5. Processes too slow: Automate code review processes through agents instead of multiple manual reviews. Human reviews should focus on high-level functionality and product vision, not code standards – that’s what agents are for. Reduce the number of reviews and rely on automation.

  The author emphasizes these recommendations apply primarily to teams with frontend, backend, and mobile development; very low-level development might be evaluated differently.

  Claude Code, Demo/Opinion, practical enterprise application.

• COMPOSER 2.0 MEILLEUR QUE OPUS pour 10x moins cher ? (oui…)
  20.3.2026, 07:19:30

  Summary: Composer 2.0 and Cursor Glace

  The French-speaking creator tests two new Cursor announcements: the Composer 2.0 model and the redesigned Cursor Glace user interface.

  Composer 2.0 – Price and Performance:

  Composer 2.0 costs $0.50 per million input tokens and $2.50 per million output tokens – significantly cheaper than competing models. According to Cursor Bench, it achieves 70% of the benchmark score, performing better than Opus but slightly worse than GPT-5.4. Composer 1.5 (Fast) is even more affordable and very quick, but better suited for smaller tasks.

  Practical Tests:

  For a simple UI fix, Composer 1.5 is impressively fast, while GPT-5.4 takes significantly longer. For more complex projects, Composer 2’s strengths show: The creator tests a YouTube thumbnail generator and a time zone checker. Composer 2 generates clean, well-structured code with separate components, CSS modules, and custom hooks – significantly better than the comparable implementations with Opus and GPT-5.4, which seem over-engineered or incomplete. The model also understands iterative feedback and adjusts the solution correctly.

  Cursor Bench – Internal Evaluation Method:

  Cursor has developed its own benchmark using real developer tasks (352 lines of code across 8 files). They distinguish between multiple correct solutions and don’t automatically penalize original approaches, which should be more meaningful than public benchmarks.

  Cursor Glace – New IDE Interface:

  The redesigned user interface features a side panel for project management, agent view, an integrated terminal with multiple sessions, web view in the same window, and an improved diff view system. Particularly noteworthy: multiple terminals running in parallel instead of just one, unified tab navigation, and fast file navigation. The creator emphasizes that Cursor has moved from a VS Code fork to genuine independent development.

  Creator’s Conclusion:

  Cursor is back in the race. The model works particularly well for pair-programming scenarios with precise requirements, while Opus performs better for open “yolo” tasks. The clean code design and low costs make Composer 2 interesting – with the caveat that the terminal still needs optimization. The new user interface is rated as a significant step, as it no longer centers on the IDE.

  Mentioned Tools & Format: Cursor (Composer 2.0, Composer 1.5, Cursor Glace), Claude, Codex 5.4, GPT-5.4, Opus, Gemini 3.1 Pro — Demo/hands-on test with performance comparison.

• Quel outil choisir en 2026 pour coder (comparaison honnête)
  19.3.2026, 06:30:14

  Comparison of three AI coding tools in 2026: Codex, Claude Code, and Cursor

  The creator compares the three main AI-assisted programming solutions across UI/UX, result quality, and pricing.

  UI/UX Experience:

  Codex offers two approaches: a chat interface (with improved copy-paste, context display, and skill tagging) as well as a new desktop app with Git integration, terminal access, and commit management. However, the CLI is perceived as confusing. Claude Code delivers the best terminal experience (TUI) with intuitive shortcuts and a pleasant diff view; the interface feels like it comes from a developer team. Cursor has the best agent experience for app development after recent updates: it combines an editor (similar to VS Code) with agent mode, enables multiple terminals and chats in parallel, and offers a debug mode that creates local servers. The criticism of Cursor is the lack of auto-completion for skills despite their availability.

  Result Quality:

  When creating a “Time Zone Checker” app, the results show: Claude/Opus consistently produces clean interfaces with logical designs. Codex with GPT-5.4 regularly produces faulty, illogical layouts – criticized throughout the transcript multiple times as “slop code.” Cursor with Opus also delivers good results and seems advantaged by the system prompt for UI creation. The underlying language model (Opus vs. GPT-5.4) has stronger effects than the tool differences themselves.

  Pricing (with $20/month base plan):

  Cursor: $20–60 inference budget; benefits from Anthropic discount (roughly 50%), burning VC money for better prices. Claude Code: Can accomplish significantly less with $20/month; Opus usage costs 55% of a session for a simple app, while GPT-5.4 costs just 4% (Opus is roughly twice as expensive per token as GPT-5.4). Codex: Strict limits, usage depleted quickly. A tweet shows: with $200/month Claude Code can subsidize up to $5000 in API costs, while Anthropic finances the system from investor funds. Conversely: GPT-5.4 in Codex allows more apps per dollar than Opus.

  Recommendation by Budget:

  • $20/month: Codex (GPT-5.4), as it’s cheaper per token and offers more throughput
  • $200/month: Claude Code due to massive subsidy and developer experience
  • Enterprise: Cursor, if paid by employer

  The video primarily compares Claude Code (Anthropic), Codex (OpenAI), and Cursor in a comparison deep-dive; difficulty level is aimed at technical developers.

• Je SETUP OpenClaw en 1 heure à un total débutant
  18.3.2026, 17:00:32

  Setting up OpenClaw in one hour – for beginners

  The video shows the complete setup of OpenClaw (an AI agent on VPS) with a non-technical beginner on MacBook.

  Machine Preparation

  First, two helpful Mac tools are installed: Ghost (enhanced terminal with tabs and zoom functionality) and Raycast (central launcher app with emoji picker, clipboard history, window management, and screenshot tools). With Raycast, you replace Spotlight with a faster, more powerful alternative – the Cmd+Space shortcut starts the search.

  VPS Setup

  A VPS is rented from Hostinger and OS is installed. After SSH key creation, you connect to the server. Claude is asked to automatically generate SSH profiles and configuration – so later you can simply type ssh openclaw instead of typing IP addresses.

  OpenClaw Installation

  On the VPS, you run a setup script (npx openclaw-vps-setup) that automatically installs Node.js, OpenClaw GitHub integration, cloud CLI, and other tools. The script optionally offers security hardening (UFW, Fail2Ban). Then Telegram is configured: you create a bot (/newbot with the Bot Father), receive a token, and enter it during OpenClaw onboarding.

  Authentication and Skills

  During configuration, you select the Anthropic API provider and enter your Claude API token. Then skills can be enabled: Claw Update (web search), Gemini (image generation), Google Workspace (Gmail/Calendar), Whisper (speech-to-text), Nanogpt, and others. The installation asks for additional API keys (Google Places, Gemini, etc.), which you can optionally add later.

  GitHub and Bypass Permissions

  You connect OpenClaw to GitHub so it can save its workspace. To avoid annoying permission prompts, use a hack: export SANDBOX=0 in the bash config, so Claude thinks he’s running outside a sandbox and executes commands directly.

  Gmail & Google Calendar

  To integrate Gmail and Google Calendar:

  1. Create a Google Cloud project
  2. Enable Gmail and Google Calendar APIs
  3. Generate OAuth 2.0 desktop credentials
  4. Pass the JSON file to OpenClaw
  5. OpenClaw authenticates itself via OAuth link

  Then he can read emails, create and modify events – for example, by voice: “Tomorrow 11 am break appointment” creates a calendar entry.

  Additional Integrations

  The video optionally shows installing Parler (local speech-to-text app) and custom skills like Dub (URL shortener), Flights (aviation API), social media tools, etc. Skills can be created manually or by Claude – the speaker prefers Claude to create them himself to minimize dependencies.

  Local UI and Usage

  OpenClaw’s web interface runs on localhost:7000 and is authenticated by token. You can then use OpenClaw to:

  • Use it as a chat interface like ChatGPT
  • Share tweets, YouTube videos, or images (via Telegram share button)
  • Schedule daily email summaries or calendar backups via cron

  The speaker emphasizes: OpenClaw always says yes, tries to solve tasks even if he can’t – you just need to be creative enough with your requests.

  Covered: OpenClaw, Claude (Anthropic), CloudCode, Google Cloud, Telegram, GitHub | Format: Tutorial for beginners, practical demo with real setup | Difficulty: Beginner-level explained for the viewer, but multiple technical steps (VPS, SSH, OAuth).

• VLOG : Mon PREMIER Hackathon à San Francisco (ça a dégénéré)
  17.3.2026, 18:00:02

  Summary: My first hackathon in San Francisco

  The creator documents his experience at a Mistral hackathon in San Francisco. After initial hesitation about committing for 3 days, he decides on day two to spontaneously build an application – a code review generator with Mistral. Using Claude and a Swarm agent, he creates a functioning webapp in just under an hour and at roughly $56 in API costs that uses Mistral models for automatic code review. The key detail: the $200 Claude subscription offers the best cost-to-value ratio of all available plans, delivering up to $16 in API value per dollar spent.

  The hackathon event seems chaotic (with activities, barbecue, children on site) but showcases international participants – many of them French students – and an impressive winner who developed an interactive children’s story app with generated text, images, and music. Along the way, the creator documents San Francisco itself: the structured city grid with Golden Gate Park, the prevalence of Apple Maps over Google Maps among iPhone users, good air quality despite environmental concerns, and mild climate without extreme seasons.

  Mentioned Tools: Claude, Claude Code, Mistral (models), Mistral Vibe (open-source IDE), Swarm (agent framework), NaOTS (backend setup), Apple Maps / Apple Watch — Format: Vlog/Demo.

MoureDev by Brais Moure

No new videos in this period.

n8n

No new videos in this period.

Nate Herk | AI Automation (2 new videos)

• Stop Learning n8n in 2026…Learn THIS Instead
  21.3.2026, 11:58:00

  The video argues that a new era of automation is beginning and traditional drag-and-drop platforms like n8n are being displaced by so-called Agentic Workflows.

  The Shift: While platforms like n8n still took years to build automations, tools like Claude (by Anthropic) and trigger.dev enable automations to be created in minutes through natural language descriptions. The user describes the goal, not the steps – the AI agent handles the technical implementation.

  Market Data: The Agentic AI market was worth over five billion dollars in 2024 and is projected to reach nearly 200 billion by 2034. 96% of enterprises plan to expand their usage; a third of all enterprise software is expected to have Agentic AI by 2028.

  Practical Demo: The creator shows two examples: (1) YouTube monitoring that checks for new videos hourly and delivers highlights – described in a few sentences rather than manually configured. (2) A ClickUp-based research agent that gathers company information. In the live example, a LinkedIn content creator agent is built that automatically generates posts and infographics (via Nano Banana Pro/key.ai) – entirely through prompting, not node configuration.

  Challenges of Agentic Workflows: Context drift (agent forgets previous instructions), hallucinations (invented APIs/functions), over-engineering (unnecessarily complex solutions), missing observability after deployment. All are solvable through session management, clear scoping, testing, and version control.

  Perspective: n8n isn’t dead, it becomes the foundation. Those with n8n experience already understand workflows, data flow, and error handling – exactly what you need to effectively manage Agentic systems.

  Tools Covered: Claude/Anthropic, trigger.dev, n8n, ClickUp, YouTube API, Nano Banana Pro, key.ai. – Demo/live-build video on a trend with practical examples.

• Generate Content for 9 Socials on Autopilot with Claude Code
  17.3.2026, 14:44:04

  The video demonstrates a practical workflow to transform a YouTube video into social media posts for multiple platforms – fully automated with Claude Code and Blot.

  Setup and Preparation:

  The user installs the Claude Code extension in Visual Studio Code (also works in other IDEs), connects with a paid Claude subscription (Pro or Max), and authenticates with API keys from Blot (for auto-publishing) and Claude/Open Router (for AI models).

  Workflow Build:

  You create a “Skill” (a kind of recipe/template) that Claude Code works through with detailed questions: programming language, whether preview is needed before publishing, tone for each platform, visual format for LinkedIn (key graphic), Instagram (carousel in tweet style), and X (quote graphic). Claude Code then saves everything to drafts for manual review.

  Practical Example:

  The user adds a YouTube video about website creation along with a profile picture in the brand assets folder. Claude Code extracts the content, writes adapted text for each platform, and generates visual assets. When errors occur (e.g., YouTube links blocked, images too large), it automatically updates the Skill documentation to prevent the problem on the next run.

  Iterative Improvement:

  After each test, the system adapts – on the second pass, Claude Code automatically adds the profile picture and verification badge to Instagram carousel slides. The user also shows how to structure the system at the end: move Python scripts to a /scripts folder and generate a claude.md system file to centralize project context.

  Publishing:

  After everything is reviewed, you connect social media accounts in Blot’s settings and can then publish with a single command – in the example, an X post is successfully published.

  The core argument: With repeated test runs and feedback, the Skill becomes increasingly robust and can later run fully automatically once a new video is uploaded.

  Tools: Claude Code (with Open Router as API), Blot; Format: Tutorial (live setup and demo); Difficulty level for intermediate users (basics like terminal/IDE usage assumed).

NeuralNine (2 new videos)

• Scraper APIs Make Your Life Easier…
  20.3.2026, 17:01:16

  Summary: Scraper APIs – The modern way of web scraping

  The video explains why Scraper APIs are a more practical alternative to manual web scraping solutions with proxies, unlockers, and custom scrapers. Instead of parsing a website’s HTML structure and constantly adjusting code when it changes, you use an API that handles all technical challenges (proxy management, IP blocking circumvention, structural changes) in the background – the developer simply makes an API call with their parameters and gets structured data back.

  The video demonstrates this using Bright Data’s Scraper API Library with three practical examples: Amazon (e-commerce: product search by keyword with filters), TikTok (social media: hashtag search with video metadata), Airbnb (travel: accommodation search by location and date). In each case, it shows how you simply set parameters in the web interface, test the API, and receive a JSON download.

  Then follows a technical tutorial: The code is implemented in Python using the requests package – first a snapshot is created (POST request to the API), then it’s queried regularly until the data is ready, and finally the results are downloaded. Finally, it shows how to build an AI agent with Langchain and GPT-4 Mini that uses Bright Data as a tool: the agent can accept natural language search queries (“Headphones”), call the API and display results in formatted form – and this agent continues to work without code changes if Amazon modifies its website.

  Bright Data Scraper APIs with Langchain/OpenAI integration – demo/tutorial.

• This is an AI Supercomputer For Your Desk…
  16.3.2026, 17:00:45

  The video introduces the Dell Pro Max with GB10 – a compact data center featuring Nvidia’s latest Grace-Blackwell chips that fit on a desk. The device features a 20-core ARM CPU, 128 GB shared memory (CPU and GPU share RAM), and delivers petaflop FP4 computing power. It comes pre-installed with a version of Ubuntu specifically configured for Nvidia’s ecosystem (DGXOS).

  The focus is not on speed, but on developer-friendliness and scalability: whoever develops a concept on this device with the Nvidia Stack can scale it directly to real data centers. Setup is straightforward – via HDMI, Ethernet and USB-C, then system configuration like standard Ubuntu. The reviewer demonstrates several practical use cases from Nvidia’s “Playbooks” (pre-configured tutorials): VS Code installation, Open Web UI with Ollama for local LLMs (testing versions with 20 and 120 billion parameters), Comfy UI for image generation, Isaac Sim/Lab for robot reinforcement learning, and local model fine-tuning with Unsloth. Particularly noteworthy is that the 128 GB shared memory enables inference with models up to 200 billion parameters, all without API costs.

  The reviewer plans to use the device for five purposes: local inference (privacy, cost savings), prototyping/experimentation at startups, research during hardware bottlenecks (e.g., EEG experiments with large models), testing new Nvidia technologies, and possibly as a portable data center. Nvidia continuously pushes software updates with improved energy efficiency and expanded hardware support.

  Bottom line: The device targets Nvidia ecosystem developers and is ideal for prototyping and proof-of-concept work with large open-weight models, not for speed-optimized workloads — Nvidia DGX Spark / Grace-Blackwell, demo.

Nic Conley

No new videos in this period.

Nick Saraev (4 new videos)

• Claude Channels Just Dropped, And It Kills OpenClaw (Again)
  20.3.2026, 16:49:29

  Claude Channels: Telegram and Discord integration for local agents

  Claude Code has released a new Channels feature – an integration with Telegram and Discord that lets you chat with local agents through the same messaging apps you use with people. It’s essentially Anthropic’s native solution that takes over the functionality of Open Claude/Claude Bot – with better security and control.

  Demo of functionality:

  The creator shows two practical use cases: (1) Text prompts via Telegram (e.g., “Hey”) cause the Claude agent to respond and document the conversation history locally; (2) A more complex example: Send a YouTube thumbnail URL via Telegram with instructions like “Replace the man with me, change the text, replace flags with Claude logo” – the agent executes this skill locally and sends the generated thumbnails back to your phone. Discord works similarly, for example to perform web scraping tasks (here: scrape 100 dentist leads from California, which come back to your phone as a CSV).

  Setup process:

  1. Telegram: Call BotFather, create a new bot and copy the token. Then in Claude Code, type /plugin install telegram@claude-plugins-official in the terminal, activate the plugin, call /telegram:configure, paste the token, then run claude --channels plugin:telegram@claude-plugins-official.
  2. Discord: Create an app at discord.com/developers/applications, enable Message Content Intent, reset token, set OAuth2 permissions (Bot, View Channels, Send Messages, Read Message History, Attach Files, Add Reactions), invite the bot to your server. In Claude Code: /plugin install discord@claude-plugins-official, activate it, /discord:configure with token, then run claude --channels plugin:discord@claude-plugins-official.

  Keeping the agent running:

  Since everything runs locally on your computer, you need measures against sleep mode. On Mac: Use caffeinate in the terminal (e.g., caffeinate -t 3600 for one hour) or in settings: never turn off display, disable auto-sleep. Alternatively, you can use a Mac mini or server (without screen) and sync files between devices using Syncthing to have 24/7 availability.

  Security:

  Each authorized channel plugin has a “sender allow list” – only predefined IDs can send messages, everything else gets discarded. You retain all local Claude Code security features.

  Criticism of Open Claude:

  The creator argues that Open Claude/Claude Bot/Molt Bot was a major hype phenomenon driven by several factors: (1) Astroturfing – a shitcoin campaign artificially inflated the idea, (2) YouTubers saw clicks and made more videos about it, creating a self-reinforcing feedback loop, (3) VPS hosting companies paid creators to make videos. At its core, Open Claude is just a Telegram wrapper around Claude with memory. Anthropic’s Channels update offers the same functionality, but much more securely (maintained by Anthropic, not random developers on GitHub), more scalably, and with better control over your own data.

  Conclusion: Channels covers most of the practical use cases users wanted with Open Claude – and does it more securely and with official support.

  Tools/services mentioned: Claude Code (Anthropic), Open Claude / Claude Bot / Molt Bot, Anthropic Channels, Syncthing. Format: Tutorial + demo + opinion/reflection.

• COLD EMAIL COPYWRITING & OUTREACH Full Course 2026
  19.3.2026, 01:00:58

  Summary: Cold Email Copywriting & Outreach Full Course 2026

  The course provides a comprehensive overview of successful cold outreach across all channels – email, LinkedIn DMs, Instagram, SMS. The instructor bases his teaching on a decade of experience and over $15 million in revenue generated.

  Core principles:

  Psychology of “yes” from strangers: The course covers seven psychological principles explaining why people respond to cold outreach: (1) Give First – offer something valuable before asking for something; (2) Micro-Commitments – small escalating agreements; (3) Social Proof – concrete numbers and success examples, especially from similar industries; (4) Authority – signal credibility through expertise; (5) Rapport – mirror shared references and tone; (6) Scarcity – real, not fake scarcity; (7) Shared Identity – common values or struggles. These principles are documented in psychological literature for centuries.

  Three components of successful outreach: (1) Clear target definition – what exactly should the recipient do? (Reply, click link, book call); (2) Frame – write like a human, personally, not corporate; (3) Iteration – test campaigns, collect data, continuously improve, don’t rely on gut feeling.

  Copywriting framework (4 steps): (1) Personalization – hook with genuine or clever cold reading (max. 2 sentences), never sound like generic AI; (2) “Who am I” statement – social proof + brief introduction (1–2 sentences) to establish trust; (3) Offer; (4) Call-to-action. Personalization is the highest ROI part of an email since it guarantees attention.

  Practical insights: The course warns against AI-generated emails that sound too generic or obviously impersonal. Successful cold emails mimic real human messages, avoid classic salesman signals like “Hope this finds you well” or formal signatures, and keep requests minimal (e.g., offer directly available call times instead of multiple back-and-forths). Iteration is crucial: A 3.5% reply rate can grow to 5%, 8%, 10% through data-driven adjustments.

  Specific tools/services mentioned: No specific AI tools named (only generally “AI” and “LLM”). Format: Tutorial/deep-dive.

• Claude Dispatch Just Dropped, And It Kills OpenClaw
  18.3.2026, 16:58:57

  Claude Dispatch – overview

  Claude Dispatch is a new Anthropic feature that lets you manage and run AI agents from your smartphone. The user shows a practical demo: He launches a “lead scraper” skill from his phone (100 HVAC leads in Texas), activates an “inbox cleaner” simultaneously (auto-marking spam with pre-drafted replies to important emails), and runs a thumbnail generation skill with face-swapping – all running in parallel on his computer while he’s on the go. Results appear directly on his phone.

  Security vs. OpenClaw: The speaker heavily criticizes alternative solutions like OpenClaw: API keys are leaked frequently, security is poor, and costs are extreme – instead of flat subscription fees you pay per API call (4–8x more expensive). Dispatch runs locally and sandboxed, requires explicit permission for resource access (“allow listing”), and is billed as part of your Claude subscription.

  Setup in 5 minutes: Download Claude Desktop and Claude Mobile App (from cloud.com/download), enable Dispatch in CoWork, pair both devices, and then send commands to your computer skills from your phone. Communication works through MCP servers and the Skills library, with Claude CoWork (or alternatively Claude Code) acting as the central “agent brain.”

  Practical value: The speaker saves 2–3 hours daily since he no longer needs to start complex automations from his laptop but can trigger them remotely from his phone while the computer (or e.g., a Mac mini) is running. All data is securely exchanged between phone and computer.

  Conclusion: The video positions Dispatch as a secure, cost-effective alternative to decentralized agent stacks – mentions Claude and Anthropic, explicitly criticizes OpenClaw. Demo video with practical setup guide.

• Claude Code + Nano Banana 2 + Kling = $15K Animated Sites
  16.3.2026, 19:20:45

  The creator builds four beautifully designed websites with 3D scroll effects in about 15 minutes and demonstrates that this is now possible for 2–3 dollars in token costs, while such projects used to cost $5,000–$10,000.

  The workflow consists of three steps: First, requirements are entered as bullet points in Claude Code, using a skill template created by a 16-year-old from an open repo that standardizes design principles and schemes. Then animated assets (rotations, exploded views of houses) are generated using Kling 3.0 via the Higgsfield platform – this costs about 36 cents per video. Finally, assets are integrated via Claude Code and the site is hosted free on Netlify.

  In the practical example, the creator shows an interior design website: Claude Code generates a one-shot design, Kling 3.0 creates a video of a panning interior animation for the hero header and an “exploding view” video of the house. Claude Code integrates these, creates a scroll animation where the exploding-view video plays frame-by-frame as you scroll, and optimizes performance on request (Claude extracts frames as JPEGs, preloads them, and speeds up loading). The creator asks Claude multiple times for improvements (better text readability, faster loading, gradient strength, add overlay) and Claude makes these changes in seconds – modifications that would take days if hand-coded. The final website goes live with one click and is available at atelieramerin.netlify.app.

  The creator criticizes that others present this process as unnecessarily complex, emphasizing that only three tools are needed and no 30 platforms – everything works straightforward and cost-effectively.

  Claude Code, Kling 3.0, Nano Banana 2, Netlify, and Antigravity (IDE) discussed as tools; demo format.

Niklas Steenfatt

No new videos in this period.

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

• Skill Issue: Andrej Karpathy on Code Agents, AutoResearch, and the Loopy Era of AI
  20.3.2026, 13:27:35

  Summary: Andrej Karpathy on Code Agents, AutoResearch, and the Loopy Era of AI

  Andrej Karpathy describes a fundamental shift in his work since December: the ratio of self-written code to agentic delegation has flipped from 80/20 to nearly 100% delegation – he barely types code himself anymore. This dramatic shift also means that classic “coding” is no longer the right verb; instead, everything revolves around manifesting intentions to agents across 16-hour workdays.

  The core concept is maximizing leverage through token throughput: rather than being the bottleneck yourself, the idea is to remove yourself from the loop and let agents work autonomously – in parallel, across multiple sessions, with optimized instructions. The vision is that a single human potentially coordinates multiple agents (across Claude, Codex, and other systems), similar to how it works at Conviction, where engineers instruct their agents via microphone.

  AutoResearch in concrete form: Karpathy had an optimization loop autonomously perform hyperparameter tuning for his nano-GPT and was surprised that the agent found improvements even in an already well-tuned codebase (e.g., forgotten weight decay on value embeddings, suboptimal Adam betas) that he had missed. This shows: when objective metrics exist, agents can remove researchers from the loop and work continuously.

  Practical example – Dobby, the household agent: Karpathy built a personal agent that autonomously integrated smart home systems (Sonos, lights, HVAC, shades, pool, spa, security). The agent performed IP scans, reverse-engineered APIs from web searches, and created a control panel – manageable via WhatsApp commands like “Dobby, bedtime” (all lights off). A camera with change detection and a vision model sends notifications (e.g., “FedEx truck just pulled up”). This demonstrates how a central agent can replace six separate apps without the user needing to write code – or at least soon won’t need to.

  The jaggedness thesis: Agents are simultaneously brilliant (can solve complex tasks for hours) and bizarrely limited (e.g., all LLMs apparently only know the same standard joke about atoms from years ago). This suggests they’re extremely good at verifiable tasks (RL-optimized) but meander everywhere else. This also means: better code generation doesn’t automatically lead to better jokes or general intelligence – no real generalization across domains.

  Trigger for psychosis: the space of possible stacks is potentially infinite – single agents, multiple agents, agent teams, optimizing agent instructions themselves (as markdown/program), then optimizing those optimizations. “Everything is a skill issue” – if something doesn’t work, it wasn’t good enough instruction, not a capability limitation. This is simultaneously empowering and paralyzing because the frontier keeps shifting.

  Vision for research as code: A research organization can be described as a program MD (markdown file) – roles, workflows, architectural decisions. Multiple organizations with different program MDs can then compete (on equal hardware: who makes the most progress?), and from the data a model can write a better program MD. This is a meta-level of agentic autonomy.

  Open Research / Crowdsourced Auto-Research: Similar to Folding@Home, there could be a system where untrusted workers on the internet submit candidate commits (very expensive to find, but cheap to verify – like proof-of-work). They don’t need access to code; only the commits (and their leaderboard results) are public. This could harness a swarm of internet computers to improve LLMs – potentially better than frontier labs with limited trusted compute.

  Caveats: AutoResearch only works for problems with objective, easily verifiable metrics (e.g., CUDA kernel efficiency, training loss). Much is too “soft” or unverifiable. Also, the models are still “rough around the edges” – if you push too far ahead, things stop making sense. There are still loops where agents do completely wrong things and waste compute.

  Speciation vs. monoculture: Karpathy suspects we need more specialized models (rather than one universal model for everything) – like how different animal species have different brain functions. But there’s little pressure for this as long as labs can supply a monoculture. Fine-tuning without capability loss isn’t fully developed yet, and it’s expensive.

  Jobs & Jevons Paradox: Bureau of Labor Statistics data shows healthcare jobs will increase. But Karpathy sees a difference: digital work (moving bits) will accelerate and transform exponentially, physical work (moving atoms) more slowly. There’s “overhang” in digital professions that will be refactored. Long-term, the number of jobs probably won’t double – but the Jevons Paradox (costs fall, demand rises) could at least short-term mean more software engineering demand.

  Frontier Labs vs. Independence: Karpathy emphasizes that outside frontier labs he has more freedom of action and can distance himself from profit and alignment conflicts of interest – which aligns him more with humanity. But there are costs: his judgment drifts because he’s not in the loop for next-generation capabilities. Ideally: regular collaboration with frontier labs, then return to independent work – a hybrid.

  The overall sentiment is a mix of euphoria (the power is real), psychosis (everything is possible, but infinitely complex), and caution (agents are still very brittle and jagged).

  Explicitly discussed: Claude, Codex, Open Research (as vision), Anthropic, OpenAI. Format: Live Q&A / Deep-dive (discussion on agents, AutoResearch, job market, and organizational questions).

Productive Dude

No new videos in this period.

Sebastien Dubois (1 new video)

• Stop Using Separate Task Apps — Manage Everything in Obsidian with TaskNotes
  21.3.2026, 11:07:07

  Summary: TaskNotes for Obsidian

  The TaskNotes plugin allows you to manage all tasks, goals, and projects directly as linked notes in Obsidian instead of using separate task apps. Tasks appear as regular notes with visual status indicators (e.g., a button to switch between statuses like “In Progress,” “Planned,” “Done”).

  Core Features: For each task, you can define tags, context (work/personal), subtasks, and custom properties. The key feature is integration with project notes: the plugin stores a connection between task and project as a metadata property, allowing tasks to be fully integrated into Obsidian’s graph system. This keeps everything as searchable text and enables the use of AI tools for prioritization or weekly planning.

  Setup: Tasks are stored in organized folders (by year/month), and archived tasks can be automatically moved to separate folders. A task is created by using standard Obsidian syntax ([ ]) with text and then clicking an icon to convert it into a TaskNote—this automatically becomes a link with extended properties (due date, priority, status, reminder).

  Configuration: Users define custom status workflows (e.g., Backlog → Planned for this year/quarter/month/week → In Progress → Stuck → Done), organize them with numeric prefixes for sorting, and use Obsidian Databases (Bases) to create filtered Kanban views, tables, or calendar blocks for tasks. Project notes and task types can be identified with tags, so only relevant notes are offered as linking options.

  Additional Features: Calendar integration with Google Calendar or Outlook enables time blocking; daily notes and periodic notes can be tagged and searched similarly. According to the creator’s recommendation, you should adapt complexity to your existing vault structure and take time to define your own statuses.

  Demo of the TaskNotes plugin for Obsidian.

Simone Rizzo (3 new videos)

• L’AI che si auto evolve è arrivata: ecco MiniMax M2.7
  21.3.2026, 15:51:02

  Summary: L’AI che si auto evolve è arrivata: ecco MiniMax M2.7

  The video covers the new Chinese language model Minimax M2.7 from Minimax, funded by Alibaba and Tencent, as the “first” self-improvement model and contextualizes this development in the broader landscape of autonomous research agents.

  Minimax M2.7

  The model demonstrates strong performance in coding and OpenClaw usage, sometimes outperforming Gemini 3.1 Pro and approaching Claude Sonnet 4.6. It also generates high-quality frontend designs. The self-improvement approach, however, is not fully autonomous: Model M2.7 automates 30–50% of the improvement workflow of the internal Reinforcement Learning team, while the rest requires human-AI hybrid decision-making. Through internal experiments, it discovered optimal sampling parameters (temperature, penalty values) and achieved 30% performance improvements. In 22 ML competitions (MLE Bench Light on a single A30 GPU), the model won nine gold, five silver, and one bronze medal.

  Autosearch (Andrew Karpathy)

  In parallel, the viral open-source repository Autosearch by researcher Andrew Karpathy is mentioned, which provides an autonomous research agent. The system works with just three Python files (prepare.py, train.py, program.md) and continuously iterates code optimizations. A fixed time budget of 5 minutes per run enables ~12 experiments/hour. A practical example shows Karpathy running Autosearch for two days on Nano-Chat and finding 20 code improvements that reduced validation loss – transferable to larger models with ~11% performance gains.

  Auto-Research-Clow

  Building on Autosearch, Auto-Research-Clow extends the pipeline to fully automatic scientific paper generation: it produces structured Markdown and LaTeX documents with introduction, related work, methods, experiments, conclusions, references, verification reports, and plots – controlled only by an initial text prompt.

  Additional Context

  The video mentions AlphaEvolve as the first documented self-improvement example (Gemini improved their own TPU architecture), Gemini 3 Deep Think for complex mathematical problems, Agent Teams (multi-agent frameworks similar to Cloud Code’s Sworms), as well as tools like Paper Banana (for automatic infographics) and OpenAI’s Prism (LaTeX editor) – an ecosystem for automating the complete research pipeline from experiments through reporting to visualization.

  Topics covered: Minimax M2.7 (self-improvement), Autosearch (Andrew Karpathy), open-source tools — Format: roundup/deep-dive with demo elements.

• Il segreto della memoria degli Agenti AI
  18.3.2026, 17:17:55

  The Memory Mechanism of AI Agents

  The video explains how modern AI agents like OpenClaw, Claude, and others manage their memory – what the author sees as the real distinguishing factor between agents, since they ultimately all use the same Large Language Models (Claude Sonnet, Claude Opus from Anthropic).

  The Core Problem: LLMs have a limited context window (e.g., 200,000–1 million tokens) and suffer from “context rot” – performance degenerates as more text is input.

  Compaction Mechanism: Both Codex and Claude models use compression: when context exceeds a threshold, the system summarizes the conversation but loses information in the process. This prevents reaching the critical performance minimum.

  Recursive Language Models (RLM): A concept developed at MIT where the long prompt is not input as tokens but managed as a string variable in a Python environment. The agent can then selectively access parts through code execution (e.g., with split, keyword search) instead of reading everything – similar to coding agents that search through a codebase using bash commands.

  Agentic File Search Instead of RAG: Rather than building a vector database system (with embedding and semantic search), an environment with functions for reading and searching files is provided. The agent uses tools like read_index, read_page, scan_folder, glob – navigating a PDF like a human would. This is more accurate than semantic search and could replace RAG.

  OpenClaw’s Concrete Implementation: Uses Markdown files in the workspace as “source of truth”. There are two layers: (1) daily logs (year-month-day.md) in append-only mode with questions/answers, (2) memory.md for lasting facts, preferences, personality. At session start, today’s file + yesterday’s file + memory.md are read. Shortly before compression, an automatic “memory flush” is triggered – the agent is prompted to save everything important to the files. OpenClaw also uses vector search, but mainly to find which Markdown file is relevant, not to directly retrieve content.

  Hybrid Approach: The most successful agents (Ralph Loop, coding agents) combine file tools (for structured, persistent knowledge) with local databases (SQLite) and optional vector databases. Memory frameworks like Memex or MemZ0 implement similar file system hierarchies.

  Practical Example (Ralph Loop): Requirements live in PRD.md, progress in progress.md. At each new session, the agent reads these files, sees which task is done, and continues – keeping work coherent over long periods.

  The video concludes with the author noting that he builds his own system “Rizzo Claw” as an educational project that combines both memory approaches and is accessible via Telegram.

  Tools/Models discussed: Claude (Sonnet, Opus), OpenClaw, Codex, Memex, MemZ0; Format: deep-dive/explainer video.

• La Matrix è possibile? Le due scoperte che cambiano tutto
  15.3.2026, 14:59:33

  Is The Matrix Possible? Two Breakthroughs That Change Everything

  The video covers two groundbreaking technological developments that blur the lines between biological life and digital simulation.

  First Discovery: Fruit Fly Brain in Simulation

  Researchers have completely mapped the brain of a fruit fly with over 140,000 neurons and 50 million synapses and uploaded it to a computer. The company Ion System then created an ultra-realistic virtual environment with a replicated fly body. The fly’s consciousness does not perceive that it is living in a simulation – it feels completely real to the cloned brain when the environment is simulated precisely enough.

  Second Discovery: Biological Neurons as Computers

  The company Cortecalabs takes the opposite approach: they grow real biological neurons in chips and train these organic brains directly. They have gotten biological brains to play Pong and later the complex 3D game Doom – with only 200,000 neurons. These biochips require nutrients, water, and oxygen instead of electricity, but are more computationally efficient and energy-saving.

  Philosophical Implications

  The author speculates: What if human brains could be uploaded? Would the digital clone be the same person or a fork with its own trajectory? Could negative emotions be deactivated to program eternal happiness? Could the deceased live on as digital copies in cloud worlds? Could immortality be achieved through digitization, or could robotic bodies with cloned brains provide access to space?

  Two Possible Future Paths

  Either digital clones in silicon (extremely computationally intensive) or biological neuron farms in the cloud (more energy efficient): perhaps corporations would build Olympic swimming pools filled with liquid medium and millions of neurons – a biological superintelligence as a data center.

  The author no longer sees this as pure science fiction and would have himself cloned to continue living digitally.

  No specific AI tools mentioned; opinion/reflection with philosophical deep-dive.

Tech With Tim (5 new videos)

• 7 Steps to Pass Technical Interviews – What I Actually Did
  22.3.2026, 11:58:53

  Summary: 7 Steps to Pass Technical Interviews

  The author describes seven concrete steps for preparing for technical interviews, which he successfully applied at Microsoft.

  Step 1 – Master the fundamentals: Master data structures (arrays, strings, hashmaps, linked lists, stacks, queues, trees, graphs, heaps), Big-O notation, and complexity analysis. This foundation is essential; the author recommends spending a week on review before tackling problems.

  Step 2 – Learn patterns, not individual problems: Instead of solving hundreds of random problems, understand the 15–20 core patterns (two-pointers, sliding window, binary search, DFS, BFS, dynamic programming, backtracking). This provides a framework transferable to new, unseen problems—not just memorizing solutions.

  Step 3 – Use the right tool: The author recommends AlgoExpert, a structured platform with 200 hand-picked problems (instead of 3,000 random ones), created by Clement Mihillescu (formerly Google, Facebook). AlgoExpert provides detailed video explanations for each problem, covering conceptual overview and code walkthroughs in various programming languages.

  Step 4 – Data Structures Crash Course: AlgoExpert includes comprehensive video tutorials on memory, complexity analysis, and all important data structures—a consistent learning resource without fragmented online research.

  Step 5 – Work through 200 curated problems: Problems are organized by category (arrays, strings, linked lists, binary trees, graphs, dynamic programming) and difficulty (easy, medium, hard, very hard). The author emphasizes that video explanations—especially the conceptual component—are critical for pattern recognition. He solved only ~100 problems before Microsoft, while others solved 500 and still failed.

  Step 6 – Timed assessments: AlgoExpert offers four curated, timed assessments that simulate real interview conditions (multiple problems, multiple hours of coding under pressure). This differs from relaxed practice and trains focus under time constraints.

  Step 7 – Mock interviews: The most important but frequently skipped step. Technical interviews require not just correct code, but communication, thinking processes, and asking questions. The author recommends at least 5–10 mock interviews with partners or platforms like Pramp, including playing the interviewer role to learn what evaluators look for. Soft skills—staying calm, thinking aloud, continuing to communicate even when stuck—separate candidates who get offers from those who don’t.

  AlgoExpert also offers SystemsExpert for system design interviews, plus Front-End Expert and ML Expert for specialized interviews. The author now collaborates with the platform and has taught some problems.

  Deep-dive featuring AlgoExpert and its products; personal success story (Microsoft preparation at age 19).

• How to Become an AI Engineer Fast
  20.3.2026, 14:01:03

  Summary: How to Become an AI Engineer Fast

  The video presents a structured 10-step plan to quickly become an AI engineer:

  Steps 1–2: Foundation

  Python fundamentals are non-negotiable (functions, classes, dictionaries, HTTP requests, JSON, simple APIs). Next, understand the mental model of large language models—what tokens, context windows, temperature, and system messages are and how they work. This is practical foundation, not deep mathematics.

  Steps 3–4: Working with APIs

  Learn to interact directly with LLM APIs (particularly OpenAI and Anthropic)—structuring API calls, handling responses, error handling. Then master prompt engineering and structured outputs to produce reliable, consistent results instead of single texts (function calling, JSON mode).

  Steps 5–6: Complex Systems

  RAG (Retrieval Augmented Generation) is the most sought-after pattern—convert data to embeddings, store in vector databases, retrieve relevant chunks on queries, and feed to the model. Learn orchestration frameworks like LangChain and LlamaIndex to coordinate multiple LLM calls, agents with tools, and multi-step workflows.

  Steps 7–8: Production and Portfolio

  LM Ops (rate limiting, caching, monitoring, cost management) are critical and separate demos from real products. Build a portfolio with three types of projects that actually work: RAG chatbots for specific domains, AI agents with tools, semantic search systems—deployed on GitHub with clean READMEs and explained in interviews.

  Steps 9–10: AI Tools and Interviews

  Use AI tools like Cursor, Claude Code, and others to produce code faster while understanding how they work. Finally, prepare for technical interviews with LeetCode and ML-specific interview prep.

  The video emphasizes that active learning through coding (75–90% retention) is significantly better than watching tutorials (20% retention). The key is not getting stuck in roadmaps, but implementing step-by-step and building real projects.

  Format & Sponsors: Opinion/guide with sponsor integration (DataCamp for interactive learning, AlgoExpert for interview prep); explicit tools/APIs mentioned: Python, OpenAI API, Anthropic API, Hugging Face, LangChain, LlamaIndex, Pinecone, Chroma, Cursor, Warp, Claude Code.

• The Fastest Way to Pivot Into AI in 2026 (From Beginner to Job-Ready)
  19.3.2026, 13:01:49

  The video addresses the common misconception that you can quickly enter AI engineering. The central thesis: AI engineer is not an entry-level position but builds on fundamental software engineering competency.

  The problem: Hiring managers don’t look for ChatGPT prompting or isolated AI knowledge, but whether candidates can make existing systems smarter without breaking them. Most AI roles require first understanding APIs, data flows, trade-offs, and failure scenarios—solid software engineering foundation.

  Three traps that sink career pivots: (1) Tool-only learning—lots of demos and frameworks, but no depth; (2) research-heavy without practical execution—lots of theory, never shipped; (3) random course hopping—constant learning without finished projects or portfolio.

  Critical distinction between career stages: AI Adjacent → AI Enabled → AI Specialized. The mistake: jumping directly from zero to AI Specialized. The right approach is layering AI skills onto existing knowledge (software developers stack LLM APIs and RAG onto backend skills; data analysts move toward applied ML; DevOps people bring infrastructure expertise).

  Three realistic AI roles being hired: (1) AI-Enabled Software Engineer—AI is a capability alongside backend work; (2) Applied ML/Data Engineer—focused on production and monitoring, not research; (3) AI Product/Technical Lead—translates business requirements into technical systems.

  Non-negotiable foundations: Python, basic mathematical intuition (statistics, linear algebra), data handling (Pandas, NumPy). AI core skills: machine learning fundamentals, conceptual understanding of LLMs and transformers, evaluation and failure modes. Applied layer: GenAI tools, APIs, orchestration, agents—what must work in real systems, not just demos.

  Four-phase path to job readiness (6–12 months): Phase 1: AI literacy and foundations without theory overload; Phase 2: applied projects with real trade-offs, not tutorials; Phase 3: real-world systems (RAG apps, copilots, automations); Phase 4: portfolio proving real competency.

  Job-ready does not mean: knowing every model or training massive systems from scratch. Job-ready means: designing AI features, explaining trade-offs, debugging faulty outputs, deploying and iterating.

  Concrete next steps: (1) research target role; (2) build 1–2 serious projects fitting one of the three roles; (3) learn only as much theory as practice requires; (4) get feedback—share code with others, have them use it, get validation.

  Core message: software engineering comes first. If you can write code comfortably and then add AI skills, you have the competitive advantage.

  Context: The opinion is supported by a course sponsor (Simply Learn / Microsoft applied intrinsic AI, multi-agent systems, LangChain, Crew AI, RAG, seven projects); the video is an opinion/reflection with practical action recommendations.

• The Postgres Performance Trap Every Developer Falls Into
  17.3.2026, 12:30:28

  Summary: The Postgres Performance Trap Every Developer Falls Into

  The video maker describes a typical problem: a Postgres database gets slower as the table grows. Developers respond with classic fixes—indexes, partitioning, hardware upgrades—that temporarily help but don’t solve the core issue. After a year, you’ve only wasted money and engineering time.

  The root cause: Postgres was designed for traditional application data (create-read-update-delete), not time-series workloads. With time-based data (logs, events, sensor data), each row carries 23 bytes of metadata for update/delete operations that never happen. The auto-vacuum process searches for cleanup work that doesn’t exist. B-tree indexes treat old and new data equally, even though queries almost always target recent data.

  The solution: TimescaleDB, an open-source Postgres extension by Tiger Data (formerly Timescale). It changes internally how data is stored and partitioned without altering SQL or existing tools. Key features:

  • Hypertables: automatic time-based partitioning instead of manual management
  • Column compression: up to 90% storage savings, faster analytical queries
  • Continuous aggregates: incremental materialized views instead of full rebuilds
  • Retention policies: automatic deletion or archiving to S3

  In the demo, a 2.6-million-row table was tested with a time-range query: standard table at 549.5 ms execution time, with hypertable at 1.7 ms—roughly 320x faster because only relevant data blocks are read. Migration requires just two commands: enable extension, convert table.

  TimescaleDB is free; Tiger Cloud offers a 30-day trial without a credit card—perfect for testing time-series workloads on Postgres.

  Format: demo/tutorial with live practical application; sponsored content for TimescaleDB/Tiger Data.

• How to Build a Video Player in Next.js (Step-by-Step)
  15.3.2026, 15:46:57

  The video shows a comprehensive tutorial for building a video player in Next.js with professional features like video upload, thumbnail generation, watermarks, and quality adjustment. The course was sponsored by ImageKit and uses their API for video storage, optimization, and management.

  The architecture connects backend APIs (for secure upload tokens and video management) with a React frontend. ImageKit’s core advantage is that transformations (watermarks, quality, format) happen through URL parameters alone—no complex backend processing. The project stores video metadata in a local JSON file and offloads actual assets (video, thumbnail, watermark) to ImageKit.

  The implementation includes:

  • Backend routes: upload token generation via /api/upload-off, video storage and retrieval via /api/videos
  • Video upload component: form for title, description, video, thumbnail, and watermark file
  • Video library: grid display with auto-generated thumbnails from video frames
  • Data types: TypeScript interfaces for video metadata and watermark configuration
  • ImageKit integration: automatic thumbnail extraction via ik-thumbnail URL transformations

  The tutorial targets TypeScript- and Next.js-experienced developers and provides a foundational implementation that can be extended—the video player itself is built in the second part of the video. All code examples are available on GitHub.

  Video details: ImageKit, Next.js, TypeScript—tutorial for advanced beginners.

TheAIGRID (6 new videos)

• Elon Musk Just Dropped Terafab AI: The Future of AI Explained
  22.3.2026, 07:39:23

  Terafab AI: Elon Musk’s Vision for the Future of Civilization

  Musk presents Terafab as a central initiative to scale human civilization through massive AI compute capacity in space. The core thesis: human civilizations are rated according to a classification system (Kardashev Scale), where a Type-1 civilization harnesses all the energy of its planet. Earth currently receives only one half-billionth of the sun’s energy – we are cosmic dust specks. That’s why scaling is inevitably a space task: Earth’s current AI compute power is about 20 gigawatts per year, while Terafab aims for a terawatt (one million gigawatts) per year.

  The project requires coordination between SpaceX, xAI, and Tesla: SpaceX provides launch capacity (goal: 10 million tons of payload per year to orbit via Starship), Tesla builds Optimus robots for space operations, xAI provides compute infrastructure. “Terafab” itself is a state-of-the-art chip fabrication plant in Austin with full capacity (logic, memory, mask manufacturing, testing) under one roof – enabling ultrafast iterative chip improvements.

  Musk distinguishes two chip types: edge-inference chips for Optimus (expected 1-10 billion robots annually vs. 100 million vehicles), and high-performance-optimized space chips for the 99% of compute running in space. In space, AI will become cheaper than on Earth (within 2-3 years) because of constant solar radiation (5x more effective than terrestrial) and no battery infrastructure needed – space costs become the dominant factor.

  Long-term vision: An electromagnetic mass accelerator on the moon (via Optimus + humans) could later lead to petawatt compute (1000× terawatt). Ultimately, Musk aims for an economy a million times larger than today – enough for universal material abundance (inspired by Iain M. Banks’ “Culture” novels), where needs are met for free. The journey goes “over the moon, over Mars, and through Saturn’s rings” – not just for the elite, but for everyone.

  Core narrative: Terafab is not an end in itself, but a necessary intermediate step on the Kardashev Scale to become a “galactic civilization” that enables multi-planetary expansion, unlimited growth, and true material abundance.

  xAI and SpaceX were featured; format: opinion/reflection with vision presentation.

• Microsoft’s AI Chief Terrifying Prediction Explained
  20.3.2026, 21:00:35

  Summary: Microsoft’s AI Chief Terrifying Prediction Explained

  Mustafa Suleiman, Microsoft’s AI chief, predicts in an interview that within 12 to 18 months, most white-collar jobs will be completely automated – jobs like lawyers, accountants, project managers, and marketers. He defines AGI as a system capable of handling most of a professional’s daily tasks, citing software engineering as an example where AI-assisted programming already produces the majority of code. Dario Amodei from Anthropic similarly warns of entry-level white-collar job automation and potential employment crises.

  Real market data supports these warnings: white-collar job postings hit their lowest levels since 2015 (1.6 postings per 100 workers). Block (Square/Cash App) announced a 40% workforce reduction and explicitly attributed it to AI efficiency and smaller teams; the stock rose 25% afterward – an incentive problem that could lead to mass layoffs.

  A new legislative proposal would ban AI from providing answers in medicine, law, dentistry, nursing, and other professions – the first serious attempt to protect white-collar jobs. This is strategic: lawyers and doctors have lobbying power; truck drivers don’t. However, the law is vague (no clear definition of “substantial answer”), and liability falls on providers, not model developers, burdening smaller teams.

  Anthropic’s “AI Exposure Index” shows across 800 occupations using real usage data: law, management, finance, and computing are theoretically highly exposed, but practical adoption is still early. A UBI pilot with Irish artists (£325 weekly) paid for itself and showed positive results.

  However, Gartner research reveals a more complex picture: AI’s impact on global jobs through 2026 is neutral; from 2028 onward, more jobs are created than destroyed – but with massive chaos in between. 32 million jobs per year will transform, upskilling required; 30% of jobs replaced by AI in 2029 are rehired (often at higher cost). A fintech case illustrates this: after 70% automation, customer service quality collapsed, and workers were rehired. Clana similarly shifted from “AI-first” to new hires. Many AI projects miss their targets.

  The central thesis: not that AI takes all jobs tomorrow, but chaotic back-and-forth – mass layoffs, setbacks, experiments – while workers bear the cost. By 2027, 75% of hiring processes will require AI competency certifications; AI literacy becomes formal requirement rather than nice-to-have.

  Format: opinion/deep-dive with news elements; providers/CEOs mentioned: Microsoft (Mustafa Suleiman), Anthropic (Dario Amodei, Claude Exposure Index), OpenAI, Anthropic, Gartner research.

• China’s New AI Breakthrough – Attention Residuals Explained –
  19.3.2026, 21:00:15

  Summary: China’s AI Breakthrough – Attention Residuals Explained

  Chinese AI lab Moonshot AI (team behind Kimi models) published research questioning a fundamental design element unchanged since 2015 in all modern AI models (ChatGPT, Claude, Gemini): residual connections. These connections forward information through layers of a neural network – but with equal weight for everything. The problem: in deep models, massive information buildup occurs (signal dilution), where early layer contributions get drowned out.

  The solution is called Attention Residuals: instead of blindly adding all previous layer outputs, each layer decides which earlier layers are most relevant – analogous to the attention mechanism that revolutionized transformers in 2017. A practical variant (Block Attention Residuals) applies this selectivity only between layer groups, not between individual layers.

  Tests show consistent improvements: equivalent to 25% more training compute at no additional cost. On Kimi-Lamarilla (48 billion parameters), reasoning abilities and math performance jumped significantly – for example, on GPQA Diamond from 36.9 to 44.4 points. Implementation overhead is minimal: training costs under 4% more, inference under 2%.

  However, one researcher (Ziming Louie) warns: Attention Residuals seem particularly advantageous on structured data but can be suboptimal with messier data. For LLMs, this is relevant since language and code are highly structured.

  Deep-dive on Moonshot AI and the Kimi model plus its Attention Residuals architecture.

• China’s New Tennis Robot Reveals the Next Step for Humanoid Robots
  19.3.2026, 09:55:49

  Summary: China’s Tennis Robot and the Future of Humanoid Robotics

  Researchers from multiple top Chinese institutions (Tsinghua University, Peking University, Galbot, Shanghai AI Laboratory, and others) have enabled a humanoid robot (Unitree G1) to play tennis – one of the most challenging tasks in robotics. The 127 cm robot with 29 degrees of freedom must handle balls traveling up to 30 m/s and position its racket precisely for milliseconds only.

  The key innovation was solving a central problem: instead of waiting for perfect data from professionals, the team used a system called LATENT (Learns Athletic Humanoid Tennis Skills from Imperfect Human Motion Data) that works with imperfect motion data. They collected just 5 hours of motion data from five amateur tennis players in a 3×5-meter motion capture zone and had them perform isolated movement fragments (forehand, backhand, lateral movements).

  The system uses a three-layer architecture: a Motion Tracker translates human movements into robot-compatible equivalents, a Latent-Action-Space learns the essence of movements rather than individual joint movements (and can therefore generalize), and a Policy selects shot types and coordinates the whole body. Everything is trained first in simulation – imperfection is deliberately introduced here (noise, varying physics) so the sim-to-real gap is bridged and the robot acts adaptively in the real world.

  Results are impressive: 91% success rate on forehand, 78% on backhand, multi-rally exchanges with human players. The robot sprints over 6 m/s across the court. Researchers see tennis as proof of concept – the real significance lies in the ability to work with messy, imperfect data. This could transfer to any physical task for humanoid robots (warehouse work, parkour, disaster response). Next steps they mention: onboard vision instead of external motion capture, multi-agent scenarios (two robots against each other), and testing with other sports/activities.

  No specific AI-tool/model-provider named (hardware only: Unitree G1); format: deep-dive.

• DLSS 5 Explained Clearly In 8 Minutes (How It Actually Works)
  18.3.2026, 11:30:19

  DLSS 5 Explained Clearly In 8 Minutes

  DLSS 5 is a fundamentally new rendering technology from Nvidia that, unlike previous DLSS versions that only improved efficiency, deliberately changes the appearance of games through a neural rendering model. The technology was unveiled at GTC 2026 and sparked controversy after a Resident Evil demo showed the AI altered a character’s facial features – fuller lips, sharper cheekbones.

  How DLSS 5 works: The game engine renders a frame normally (geometry, textures, lighting). The engine then outputs two things: the color buffer (the image) and motion vectors (pixel movements between frames). The neural model analyzes both and understands the semantic content of the scene – characters, fabrics, hair, skin. It then generates a new version of the frame with photorealistic lighting and materials: subsurface scattering on skin, fabric gloss, hair scattering. Important: it doesn’t create new geometry, only overlays lighting effects on the original content.

  Technical and commercial hurdles: In Nvidia’s GTC demo, two RTX 5090 graphics cards (~$2,000 each) were required – one for game rendering, one just for DLSS 5. Nvidia plans to optimize this to a single GPU.

  The controversy: PC gamers criticized that the Resident Evil demo didn’t just show realistic lighting but structurally altered facial features – dubbed “Yassification” (beauty filter effect like Instagram). The deeper concern: DLSS had always been additive (makes games faster). DLSS 5 breaks that promise by fundamentally changing appearance. Nvidia emphasizes developers have full artistic control (intensity sliders, color grading, regional masking) and DLSS 5 is toggleable. However, Digital Foundry warns modders might force DLSS 5 onto games it was never intended for.

  Broader significance: This is part of an industry-wide trend toward neural rendering. Google DeepMind already demonstrated Gen 3, generating complete 3D environments from text prompts in real-time. DLSS 5 sits in the middle of this trajectory – still hybrid with traditional rendering, but a step toward generative graphics. Support from publishers like Bethesda, Capcom, Ubisoft, and Warner Bros. shows the industry takes this seriously. Over a dozen titles for DLSS 5 launch in fall are announced, including Assassin’s Creed Shadows, Resident Evil, and Starfield.

  The real battle: The controversy isn’t whether neural rendering works – reviews praise photorealistic improvements in lighting, material details, and subsurface scattering. The central question is: who controls how games look – the developer, the player, or the AI?

  Nvidia DLSS 5 and DeepMind Gen 3 are mentioned; demo video with practical examples and controversy in focus.

• Nvidia Just Dropped NemoClaw And Other Huge AI Updates
  17.3.2026, 07:30:20

  Nvidia Just Dropped NemoClaw And Other Huge AI Updates – Summary

  Nvidia announced NemoClaw – a system based on OpenClaw that enables enterprises to deploy AI agents to perform tasks on behalf of employees. The platform provides integrated security and privacy tools and is hardware-agnostic, working regardless of whether infrastructure is based on Nvidia chips.

  Jensen Huang emphasized the significance of OpenClaw as the “most popular open-source project in human history,” surpassing Linux in 30 years within weeks. OpenClaw was described as an operating system for agents – it manages resources, invokes language models, can access file systems, decompose tasks, invoke multiple sub-agents, and communicate across modalities. Huang noted that every company must now have an “OpenClaw strategy,” similar to how Linux, HTML, or Kubernetes strategies were necessary before.

  NemoClaw addresses enterprise requirements through a reference architecture with OpenShell integration, policy engines, guardrails, and privacy routers. Nvidia also announced its Nemotron family of language models – particularly Nemotron 3 and Nemotron 3 Ultra as base models – plus a Nemotron Coalition for developing domain-specific, sovereign AI models.

  Additional announcements: DLSS 5 uses generative AI to upscale specific game elements and enhance graphics; Nvidia Alpamo gives autonomous vehicles reasoning capabilities; robotic tools like Isaac Lab (training and simulation), Cosmos (world models), Groot (foundation models), and Newton (GPU-accelerated physics simulation) enable developers to train physical AI and robotics at scale.

  News update on Nvidia, OpenClaw, Nemotron, and proprietary and open-source tools for enterprise AI, robotics, and autonomous vehicles.

Theo – t3․gg (4 new videos)

• Everything needs to change
  20.3.2026, 12:35:17

  Summary: “Everything needs to change”

  The video argues that developer tools need to undergo radical change. Starting from the concept of the classic IDE (Integrated Developer Environment) – which unified everything from editor to compiler to debugging in a single window – the author sketches the evolution: from Sublime Text through Atom to VS Code, where the editor was each time structured around individual projects.

  The problem today: With AI agents working in parallel on multiple projects for hours, the old model no longer fits. The author constantly works on many codebases simultaneously and must mentally juggle different terminal tabs, editor windows, browser tabs (for GitHub and dev servers), and project connections – it’s inefficient and scatters workflow across too many apps.

  The solution: A larger IDE that contains not just an editor but orchestrates all dependencies – multiple projects with their terminals, browsers, and workspaces in a cohesive interface. The author showcases Semox (a fork of Ghosty with UI adjustments) as a first approach and mentions T3 Code as his own experiment in this direction.

  Core insight: The problem of “hierarchy” in the traditional IDE – optimized for one project at a time – must be rethought. It requires new solutions, canvas-based navigation, multi-dimensional workspaces. The author emphasizes this isn’t solved yet and many different approaches should be tried. Interestingly, the author references Andrej Karpathy, who has postulated something similar.

  On the side, Kernel is sponsored (cloud browser for agents with OAuth integration).

  Tools/Context: VS Code, Cursor, Ghosty/Semox, T3 Code mentioned; inspired by Karpathy; no specific AI models named — Opinion/Reflection, with personal development history.

• Vercel accuses Cloudflare of stealing
  19.3.2026, 11:49:33

  Summary: Vercel accuses Cloudflare of stealing

  Vercel and Cloudflare have clashed over Just Bash, a package built by Vercel’s CTO Malta – a fully TypeScript-emulated Bash environment with in-memory file system, developed for AI agents. The reason: Cloudflare forked Just Bash and incorporated it under the name “Cloudflare/Shell” into its agents monorepo.

  Malta criticized the fork publicly because Just Bash is still in active development and Cloudflare removed the beta disclaimer and several security warnings from the documentation. Worse: Cloudflare replaced Python’s secure Pyodide implementation with an unsafe variant that grants the JS host complete access, and eliminated defense-in-depth layers against host breakouts (eval disabling, prototype pollution checks) – security measures critical for Node.js environments but less relevant for Cloudflare’s Isolates.

  The broader context: Vercel needs Just Bash for security reasons because actual Bash on a Node.js server would enable direct access to all system resources. Cloudflare, by contrast, can’t run real Bash at all (it uses V8 Isolates instead of full Linux instances) – for Cloudflare, the Bash emulator is a functionality enhancement, not a security feature.

  Sunil Pi (Cloudflare’s original React team member, now responsible for Durable Objects) was enthusiastic about the package and experimented with it. The fork was originally a side coding project, but was accidentally pushed to the public monorepo without an experimental label or personal GitHub use – giving the impression Cloudflare was publishing a production package under its own name. Malta subsequently published a public article instead of communicating privately first.

  The irony: Sunil meant well and planned to coordinate with Malta later. After Malta’s public article, Sunil apologized and explained it was casual experimentation. Malta later realized his mistake, reflected (“I stirred up unnecessary pain for Sunil”), and apologized in turn – Sunil didn’t deserve that.

  The speaker criticizes that bad faith exists between the companies (triggered by earlier drama like the botched Vext fork of Next.js) and argues both sides should talk privately before public confrontations.

  Format & Context: News update/deep-dive on open-source and platform architecture issues; no specific AI tool in focus, but fundamental infrastructure disputes (Vercel vs. Cloudflare).

• I did not expect this…
  17.3.2026, 23:40:47

  The developer tests Vit Plus, the newly open-sourced and alpha-stage unified toolchain around Vit, which consolidates package management, Node version handling, linting, formatting, type checking, and task orchestration. After initial excitement about the announcement, he conducts a live exploration, starts a new project, experiments with commands like vp check (332ms for 15,000 lines of code), vp dev, vpenv for Node version management, and tests the vp migrate function on an existing project — here he encounters several friction points: the generated agents.md template is too verbose and actually harms AI models; Vit Plus doesn’t support Bun (only PNPM, NPM, Yarn); the vp commands override custom scripts from package.json (e.g., vp dev instead of vp run dev), criticized as problematic UX design that repeats a known Bun gripe.

  When migrating a Tanstack Start project from Vit 7 to Vit 8 + Vit Plus, dependency conflicts arise, which he ultimately resolves with Claude Code (Codeex) — a moment where he underscores the superiority of a graphical UI over CLI-based tools. Build times improve from ~28 seconds to ~22 seconds. The Vit Tasks feature (caching generated outputs, dependency tracking, subtask-wise parallelization) and the new Rust-based Ox toolchain convince him technically.

  His conclusion: He sees great potential in the vision (everything needed from deployment to package management from one hand, combined with Evan’s other projects), but isn’t yet convinced to adopt Vit Plus across all projects. The criticism of agents.md bloat, Bun exclusion, and script-override behavior are alpha issues that in his view must be fixed before release.

  Covered: Vit Plus (alpha, open-source), Vit Tasks, Ox (Rust-based linter/formatter), Claude Code/Codeex — Demo/Live Tutorial, standard difficulty.

• You don’t want to be a manager.
  16.3.2026, 19:06:16

  Summary: “You don’t want to be a manager”

  The speaker discusses an article arguing that software developers today shouldn’t transition into management roles. The core conflict: To advance in a tech career, developers are traditionally promoted into management positions – while leaving the work they were trained to do.

  The article names three main reasons against switching to management:

  1. Bad timing to distance yourself from current technology – the industry changes rapidly, and absence leads to quick knowledge loss.
  2. Competitive career ladder – companies are flattening hierarchies (fewer manager positions), while senior/staff engineer roles remain and are paid higher externally.
  3. Lower compensation – a staff engineer often earns 20–30% more than an engineering manager at other companies.

  The speaker presents an important counter-position: As an IC (Individual Contributor), you have more freedom in your work than as a manager. Managers must subordinate their decisions to the team and accept compromises they wouldn’t have made. But he also warns against accepting counter-offers after job switches – it destroys trust permanently.

  Then the speaker flips the argument: Management teaches crucial soft skills, particularly communication, which are valuable not just in management but also as an engineer and in life generally. A practical example: He tried to give Claude (CodeEx) a task to program a chess engine that beats Stockfish level 17. The model initially misunderstood the requirement and used Stockfish itself instead. Through iteration, he learned he should describe goals rather than tasks – a skill just as important for AI agents as for people.

  His final conclusion diverges from the article: Instead of avoiding management roles, one should consider them if approached with the right mindset. Communication skills are more valuable long-term than specific roles or salary, since tech’s future is uncertain. Anyone who reflects enough on team communication will become better not just at management but also at engineering work and AI prompting – an advantage hardly anyone recognizes.

  Format: Opinion/Reflection with discussion analysis of an article; no specific AI tools/vendors mentioned in core content (only brief sponsor mentions of Augment and Unblocked), but strong practical connection to Claude and CodeX in the chess engine demo.

Tim Carambat

No new videos in this period.

Unsupervised Learning (2 new videos)

• AI WILL Replace Knowledge Workers
  21.3.2026, 16:00:55

  Summary: “AI WILL Replace Knowledge Workers”

  The speaker argues against widespread reassurances that AI will replace knowledge workers – and backs this up with detailed criticism of the current state of corporate work.

  The Current Corporate Situation: The speaker, who has spent 25+ years in large corporations and as a consultant, describes typical problems: goals are unclear or poorly communicated, Standard Operating Procedures (SOPs) don’t exist or aren’t followed, output quality is massively inconsistent (dependent on the individual rather than the process), and there are massive information losses when employees leave. Executives often lack transparency into what work is being done, how much it costs, or how good it is. Identifying these issues takes months or costs hundreds of thousands in external consulting.

  The False View of Human Superiority: The speaker refutes two arguments: (1) Humans are chaotic thinking machines – meditation shows we don’t know where our thoughts come from, we don’t plan sentences, and memories are distorted and dynamic, not static like data blocks. (2) Human expertise is based on four abilities: knowledge, understanding, intelligence, and creativity. AI already excels at the first three – knowledge (comprehensive factual knowledge), understanding (pattern recognition across domains), and intelligence (adapting to new requirements, dynamic goals). AI lacks creativity, but it’s not needed for average knowledge work in 95% of cases.

  Why the Expertise Gap Supposedly Exists: The real gap isn’t that AI can do less, but that expert knowledge remains in people’s heads – unwritten, undocumented. When knowledge is converted into “Skills” (structured contexts, processes, documentation), AI can fully leverage it. Tools like Claude Code demonstrate this: not a better model, but better scaffolding (context management, linking) made the difference.

  The Lattice Architecture (planned open-source project): The speaker introduces a system designed to create transparency in organizations: each level (employee, team, department, company) publishes its SOPs, goals, metrics, budget, and work results via APIs. A central daemon enables real-time queries – instead of months for transparency audits, it takes seconds. Goals and SOPs can be updated centrally and immediately propagated across all levels. This visibility enables both detecting redundancies and AI-powered automation.

  Conclusion: The “comfort narrative” that AI can’t replace knowledge workers is wrong and dangerous because it leads to unpreparedness. The real boundary isn’t in AI capabilities, but in poor documentation of processes – a problem the described architecture solves. Organizations that quickly achieve this transparency and structure will be able to adopt automation early.

  References: No specific tools or vendors mentioned (Claude Code as generic example); Lattice and PI are the speaker’s projects. – Format: Opinion/deep-dive with system design elements.

• A Conversation With Rishi Sharma
  19.3.2026, 16:00:45

  Summary: A Conversation With Rishi Sharma

  Rishi Sharma from Project Discovery introduces Neo, an AI-native platform for cybersecurity that uses LLMs to automate security tasks in organizations. Neo combines two functions: mapping organizational structure (external and internal view of APIs, tools, apps) and identifying real, exploitable security vulnerabilities.

  The core problem Neo solves is reducing false positives. Traditional scanners produce massive amounts of invalid findings; Neo deliberately separates the detection phase from the validation phase. Scanning agents perform an initial assessment, followed by a separate validation pipeline (with sandbox, browsers, custom-built tools) that verifies actual exploitability. The false positive rate was reduced by over 90%. At the same time, Neo helps with triaging existing vulnerability backlogs and accelerates penetration testing workflows.

  Neo employs several design principles: sub-agents for context management, refresh-loop engineering (each iteration with fresh context), and the “Bitter Lesson” (giving the model goals and tools, not step-by-step instructions). This improves performance automatically with better LLM models. The system uses separate knowledge tools and structured indexing rather than loading large amounts of text into the context window. Agents can traverse long chains, with each step combining reasoning and tool calls.

  The demo shows the API-first interface: define tasks (e.g., “check API daily for critical findings”), add credentials and file uploads, and configure integrations (Jira, Linear, Slack). The agent creates a plan, delegates to sub-agents, remembers previous findings, validates results, and delivers a report with reproduction instructions. Reports can flow into ticketing systems. Multiple agents can work in parallel and collect results in shared storage; an aggregation agent can then report across all findings.

  The pricing model is usage-based (infrastructure, LLM compute, third-party tools). A penetration test costs approximately 20–30 Neo credits. Neo runs on Project Discovery Cloud or can be deployed in your own VPCs (AWS, GCP). Access via project discovery.io with demo request.

  Tech Stack & Format: Project Discovery, Neo; demo/interview with practical system showcase. No specific LLM names mentioned, but LLMs confirmed as backbone.

WorldofAI (6 new videos)

• Google AI Studio 2.0 – NEW Powerful Autonomous AI Coding Agent Can Build ANYTHING & IS FULLY FREE!
  21.3.2026, 06:50:30

  Summary: Google AI Studio 2.0

  Google has overhauled Google AI Studio with a major update introducing a new “Build Mode” or “Agent Mode”. This enables you to create complete full-stack applications with backends directly integrated with Firebase – entirely free. The system uses an AI-coding agent and lets you generate complex projects like animated landing pages or multiplayer-capable games through prompts alone.

  Key new features include: Real-time multiplayer support (including AI bots, scoring systems, and live leaderboards), real-time collaboration between multiple users (e.g., shared 3D particle experiences with automatic synchronization), visualization of physics and game design elements, and integrations with external services like Firebase. The UI has been completely redesigned, and users can select state-of-the-art models like Gemini 3.1 Pro and configure frameworks.

  The demo showcases an application example: A CRM dashboard with functional backend, Google Sign-In, and integrated Gemini chatbot for database queries – all automatically generated. Additionally, you can manage versions, handle secrets and integrations directly in the panel, and download code as a ZIP file. GitHub integration and sharing with other users via Gmail are possible. A special feature is the integration with Google Stitch: front-end components from Stitch can be exported to AI Studio and further developed with the agent.

  The roadmap mentions plans for Design Mode, Figma integration, Google Workspace integration, GitHub support, Planning Mode, and Immersive UIs. The video demonstrates a multiplayer tank game entirely generated from a prompt.

  Explicitly mentioned: Google AI Studio, Stitch, Firebase, Gemini 3.1 Pro; Format: Demo with opinion/reflection.

• MiniMax M2.7 IS INSANE! Best Agentic/Coding Model! Beats Opus 4.6 and 50x Cheaper! (Fully Tested)
  20.3.2026, 02:21:19

  Summary: MiniMax M2.7 – Test and Review

  MiniMax has released M2.7, a new agentic AI model that has developed through autonomous self-improvement over 100+ iterations (without human intervention) while achieving a 30% performance boost. The model stands out with strong benchmark results: 56.22% on SWE-bench Pro (Opus-level), 55.6% on Vibe Pro, and 57% on Terminal Bench 2. It can handle large systems with over 50 skills and 100+ features while reliably following instructions and using tools.

  Pricing-wise, M2.7 is revolutionary: At 30 cents per 1 million input tokens and $1.20 per 1 million output tokens, it costs up to 50x less than Opus while delivering GLM5-like intelligence at less than a third of the cost. The 24K context window supports complex workflows.

  Practical tests show strong performance in real scenarios like log analysis, code refactoring, machine learning pipelines, and Android development. The reviewer conducted multiple hands-on tests: a macOS-styled browser OS, dynamic landing pages with animations and shader rendering, a Minecraft clone with terrain generation, a casino slot machine with state management and animations, plus a 360° product viewer and a casual gold miner game. In direct comparisons with Opus 4.6, M2.7 often produces better frontend quality, particularly with animations and interactive elements.

  Access is available through various channels: Direct API, free chatbot interface, Open Router, Kilo (with open-source CLI and free credits), or various token/coding plans. The reviewer recommends the model as true competition to Opus 4.6 for agentic multi-agent systems, highlighting its autonomous system improvement capability.

  Explicitly tested models: MiniMax M2.7, Opus 4.6, Gemini 3.1 Pro; Tools/Platforms: Kilo CLI, Open Router; Format: Demo with comparative tests.

• Google’s NEW AI Vibe Design Tool IS INSANE! The Greatest AI Design System I’ve Ever Used! (Stitch)
  18.3.2026, 18:01:14

  Summary: Google Stitch – AI-native Design System

  Google has transformed Stitch, its Gemini-powered design agent, into a fully AI-native design platform. The core component is a generous, native canvas that manages images, code, and text simultaneously and enables parallel work with multiple agents – for example, creating a landing page and a user profile page at the same time.

  The redesigned agent is more powerful: It can swap logos, critique designs, generate PRDs, build design systems with predefined colors and typography, and import these from websites. The Instant Prototype feature assembles screens in seconds, displays interactive flows immediately, and automatically generates the next logical screen based on user interactions. The canvas supports preview in various formats (mobile, tablet, web) as well as variations and heatmaps.

  The newly introduced Voice Vibe Design uses Gemini Live integration and enables hands-free prototyping through voice input – the agent answers questions, generates designs live, and provides real-time feedback. Design systems can be fine-tuned in detail (colors, fonts, border-radius) and applied consistently across all canvases. Exported code can be further processed; users can choose between different AI models (such as Gemini 3 Flash). The tool is free and accessible with a Google account.

  Covered Tools/Models: Google Stitch, Gemini Live, Gemini 3 Flash — Format: Demo.

• AI Agents That Control Your Computer! Automate Your Life With AI FOR FREE!
  18.3.2026, 04:19:54

  Summary:

  The video introduces Neo, a free AI-native browser from Norton that prioritizes automation, privacy, and AI assistance. The entire process remains local on the device and requires no cloud synchronization. After installation and profile setup, Neo offers a main chat interface where you can enter URLs, use commands with the @ symbol, or simply ask questions. The browser has preset snippets for common tasks like summarizing, writing, and code help. In the settings, you can enable local AI, activate ad blocking, and configure sidebar behavior.

  Core features include: The AI side panel summarizes news articles and answers follow-up questions; an ad blocker automatically removes ads; smart tab grouping organizes tabs; videos and podcasts can be summarized instead of watching them entirely; hovering over links displays a preview button without clicking; text in the browser can be highlighted and explained or summarized. The AI agent finds discount codes with expiration dates, develops long-term memory based on usage, saves preferences like writing style, and displays a personalized news feed. Neo can also process large documents, generate images and display them as a gallery, plus offers inline text generation (for example, in emails or notes). The browser works on Windows and Mac and is completely free.

  Format & Tools: Demo of an AI browser (Neo from Norton); privacy-focused, locally processing; no specific other AI providers featured in the core, though Claude and Gemini 3.1 Pro briefly mentioned — Demo video.

• Codex Subagents, Minimax M2.7, Claude Code Update, NVIDIA GTC, AI CMO, Google AI Tool! HUGE AI News
  17.3.2026, 05:59:47

  Summary: HUGE AI News – Weekly Update

  This week brought several major AI announcements:

  OpenAI Codex Sub-Agents: OpenAI has introduced sub-agents for Codex that can spawn specialized agents in parallel to work on different parts of a task and intelligently combine their outputs – particularly useful for complex workflows like codebase explorations or multi-step feature planning.

  Minimax M2.7: The model launches this week and is already showing results on Design Arena. Tests demonstrate improved code generation and frontend capabilities (e.g., macOS OS simulation with functional UI elements), though completeness still has room to grow.

  VS Code Agent Mode: VS Code received a new agentic browsing tool enabling agents to control live browsers – opening pages, reading content, clicking elements, and verifying changes in real time.

  Nvidia GTC 2026: Announcements included Nemotron Ultra (new open-source model for reasoning and robotics), Nemoclaw (open-source stack on Openclaw), and DLSS5 (AI-powered graphics enhancement for games).

  Mistral Small 2: 128-expert model with 119 billion parameters, Apache 2.0 licensed, 40% faster, 3x more throughput, but with only 256k context window. Mistral also announced a strategic partnership with Nvidia.

  Claude Updates: 1-million-token context window for Opus and Sonnet 4.6, Opus 4.6 achieves 78.3% on MRCR v2, up to 600 images/PDF pages per request. Bonus starting March 14: 2x usage outside peak times for two weeks.

  Google Design Tool: Desktop app with voice control, canvas layout, and agent vision for automated design creation (marketing kits, frontends, dashboards, slides) with React integration – release expected this month.

  Other Tools: Okra presents the first AI CMO (automated user acquisition), Perplexity launches “Personal Computer” (always-on AI system), Manis desktop app with local agent, Stitch releases TypeScript SDK for agentic workflows.

  Moonshot Intention Residual: New architecture idea where models selectively choose only relevant information from earlier layers instead of blindly stacking all layer data – achieves 1.25x better compute efficiency at 48B parameters.

  AI Tools/Providers: OpenAI, Claude (Anthropic), Minimax, Nvidia, Mistral, Google, Okra, Perplexity, Moonshot, VS Code – Format: News Roundup

• Claude Code + Obsidian = UNLIMITED Memory! Solves Claude’s Memory Problem!
  16.3.2026, 07:30:55

  Claude + Obsidian for Persistent Project Memory

  The video demonstrates a solution to Claude Code’s known problem: the model loses focus over extended contexts and forgets previously given instructions. Combined with Obsidian, a free note-taking app, all project information remains organized and permanently available.

  Obsidian Basics: The app stores notes as plain markdown files in a local vault (folder) – no proprietary format, completely private and offline. Claude Code can directly access these markdown files, search them, reference them, and update them.

  Vault Structure: You populate the vault with relevant context: project overview, architecture decisions, coding standards, GitHub information, Prisma schemas, session summaries, bug notes, meeting transcripts – everything Claude needs to make decisions. After each session, Claude can write new notes and update the vault itself.

  Obsidian Skill: An installed plugin (via marketplace) teaches Claude Code to better interact with the vault: read markdown files, write/update notes, search the vault, reference content. With the /obsidian command, Claude can directly use the Obsidian CLI.

  Practical Example: In the demo, a CRM dashboard is expanded. Claude first pulls project contexts from the vault (existing architecture, Prisma schema, Shad-CN component patterns), then builds a deal kanban board consistently with existing patterns, and afterward updates the vault. Multiple agents can work in parallel using the same project memory without deviations.

  Result: No repeated explanations needed, Claude stays aligned with the original vision, details persist across weeks/months, code becomes more consistent, workflows run smoother – especially valuable for large, long-term projects.

  Claude Code + Obsidian; tutorial with practical demo.

Zubair Trabzada | AI Workshop (3 new videos)

• Give Claude Superpowers with These 3 MCPs (Step-by-Step)
  21.3.2026, 14:00:52

  Summary: Give Claude Superpowers with These 3 MCPs (Step-by-Step)

  The video demonstrates how to install and use three MCPs (Model Context Protocols) in Claude Desktop to significantly extend Claude’s functionality.

  Basic requirement: You must download the Claude Desktop app from claude.com/download. MCPs are added via the Plus icon → Connectors → Manage Connectors.

  The three MCPs:

  1. Canva MCP – Enables Claude to handle design tasks directly instead of manually using Canva. For example, you can create an Instagram carousel series about “five morning habits” in natural language and receive multiple design options that Claude automatically generates with Canva. Afterward, you can refine the designs in the Canva editor or iterate further with Claude.
  1. Zapier MCP – Provides single MCP access to over 8,000 apps (Gmail, Google Calendar, Slack, Google Sheets, Salesforce, etc.) instead of linking them individually. You can set granular permissions per tool (e.g., only add meetings, not delete). In the demo, Claude asks about tomorrow’s appointments, summarizes them, and sends a Slack message—all automatically without explicit commands about which tool to use.
  1. Stripe MCP – Automates invoice and payment link creation. Claude can generate invoices with customer data and create payment links that lead directly to your Stripe account. Authentication happens via Stripe API, where you pre-define which permissions (e.g., invoicing, payment links) are granted.

  With each use, Claude asks for confirmation; you can set “Always Allow” to avoid recurring prompts.

  Format: Tutorial/demo with Claude and the MCPs Canva, Zapier, and Stripe.

• Build and Sell AI Websites + CRM to Local Contractors (Zite)
  19.3.2026, 01:05:40

  Build and Sell AI Websites + CRM to Local Contractors

  The video creator shows how to build and sell a professional website and CRM system for local contractors (using an electrician as an example) with Zite using just a single prompt.

  The solution addresses a real problem: Many contractors still work with missed calls, text messages, and spreadsheets—without a system for lead tracking or customer management.

  Zite workflow: After free account creation, you describe your business tool in English. The system then automatically builds the entire infrastructure (backend, database, authentication) at once—instead of piecing it together from multiple separate tools.

  The prompt structure includes two connected apps:

  1. Public Website: Company presentation with service request form, pages for services, contact, and business hours
  2. CRM Dashboard: Backend for the contractor to manage incoming requests

  Database: Service request table with fields like customer name, phone, email, address, service type, urgency, preferred time, status, notes.

  Demonstrated features: Automatic email notifications, visual editing of website content, workflow automation, filtering by conditions (e.g., show only “scheduled” status), user management with invite-only registration, multiple login methods (Google, Magic Link).

  Sales approach: Quickly build a demo system, send it to the contractor with backend access and form testing capability—live show how requests flow into the CRM database and leads are managed.

  Iterations possible: You can describe changes anytime and have the system rebuilt.

  Zite demo with custom no-code apps and CRM functionality as business model tutorial.

• I Switched From Clawdbot to Claude Dispatch (Here’s What Happened)
  18.3.2026, 23:21:33

  The video demonstrates the installation and use of Claude Dispatch, Anthropic’s newly released feature to delegate tasks from your smartphone to your desktop.

  Installation and basic setup: Download the Claude Desktop app, enable the “Co-work” tab, scan a QR code to connect with the mobile Claude app, and grant the application access to files and browser access. It’s important that your computer stays active and the connection functions like a “walkie-talkie” between phone and desktop.

  Use case 1 – Browser actions and research: Claude is tasked with searching Google for the top 3 AI productivity tools 2026, opening their pages, gathering prices and features, and saving a comparison table to documents. The system automatically completes this and creates a professional comparison document with details on ChatGPT, Notion AI, and Microsoft Copilot.

  Use case 2 – Complex data analysis: Claude analyzes raw sales data and messy team notes from local folders, identifies top performers, and creates a clean executive summary report with charts, revenue trends, and recommendations—all automatically saved to the output folder.

  Workflows with Markdown files: For recurring or complex tasks, detailed instructions can be stored in Markdown files (called “Skills”)—from simple briefs to multi-phase workflows with sub-agents (example: a 5-agent SEO audit with 11 skills). Claude reads these files and executes the instructions step by step.

  Use case 3 – Assistant features: Simple daily tasks like calendar checking, email summaries, meeting prep, and automatic note-taking are mentioned.

  Security advantage: Unlike OpenClaw or CloudBot, Dispatch runs locally on your own computer, significantly reducing the risk of data leaks and API exposure—especially for non-technical users.

  Video type and tools: Demo with tutorial elements; Claude Dispatch (Anthropic) is demonstrated throughout, Claude Desktop app mentioned, GitHub repository “GEO-SEO for Claude” referenced.

---

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