Blog

Anthropic Pulls Ahead: Computer Use, Dispatch and Skills Make Claude the Complete Agent OS

Sunday, March 29, 2026

Hello, this weekly digest works through the most important new videos from around 45 curated AI and Coding YouTube channels — with substance, no surface-level Top 5. One complete summary per video, plus a weekly overview of dominant themes. Read at leisure — 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

ARC AGI 3 reached the benchmark moment of the week: humans achieve 100%, current models under 0.5% — because puzzles are abstract, interactive, without linguistic cues, and scoring quadratically penalizes inefficiency. AI Explained and Everlast AI explain why ARC AGI 1 and 2 saturated through chain-of-thought gaming and how new design prevents that. Anthropic’s Claude Mythos (internally also Capibara as smaller variant) surfaced in a leaked CMS entry — described as an offensive-defensive cybersecurity leap forcing cautious rollout with cybersecurity partners. OpenAI works on Spud model, freeing Sora capacity. Google released Gemini 3.1 Flash Live with speech-to-speech, lower latency, emotion detection from audio, screen-sharing — Nate Herk demos voice agent integration with ClickUp and calendar. Cursor’s new Composer 2 sparked controversy by secretly using Kimi K2.5 from Moonshot AI; Theo analyzes licensing and structural drivers toward cheaper alternatives to expensive frontier models.

Local & Open-Source AI

Alex Finn delivers the week’s most complete introduction to local models: after over $50,000 in personal investment, he describes the hybrid model of local “muscles” (Qwen 3.5 on Mac Studio as Charlie, writing code 24/7) and cloud “brain” (ChatGPT as Ralph, orchestrating). Recommended models: Qwen 3.5 (best ratio), Nvidia Neotron 3 (open-source, strong), and Minimax 2.5 (fast, lightweight). LM Studio as free chat app, HuggingFace for downloads. The crucial point isn’t cost savings but 24/7 scalability and new use cases impossible with cloud models (a Minimax agent permanently scrapes the web for business opportunities and sends results via Telegram for zero dollars). NeuralNine shows the complete quantization workflow with Llama.cpp and Docker: Qwen 2.5 7B reduced from 15 GB to 4.7 GB via Q4_K_M quantization, then run through Ollama — practical even on old ThinkPad. Tim Carambat explains Google’s TurboQuant research: six times more tokens in the same KV-cache memory, practically four times less RAM usage — on consumer hardware lifts context windows from 8,000 to 32,000 tokens and enables whole task classes (e.g., three-hour podcast transcription).

Claude Code & Anthropic Tooling

Alongside Computer Use, Dispatch, and Channels (see cover), the week brought several deep dives into practical Claude Code usage. Cole Medin counted over a dozen newer features barely anyone uses: Git Worktrees for parallel feature branches, the /simplify command against over-engineering, /batch for parallel sub-agent refactorings, /btw for side questions without context bloat, /loop for recurring in-session prompts, voice support via /voice, plus the new /effort level system. AutoDream (also /dream) is this week’s Memory 2.0 feature: a sub-agent periodically consolidates all memory markdown files, prunes stale timestamps and duplicates — WorldofAI and Nate Herk explain four phases (Orientation, Gather Signal, Consolidation, Prune & Index). Mark Kashef dives into the .claude folder structure and explains why CloudMD should function as a lean router (~50 lines) rather than encyclopedia, how hooks enforce physical blocks (100% compliance) while prompts are “best effort” (~99%), and why max 4–5 tools per agent lowers error rate. His certification guide video on Anthropic’s new “Claude Certified Architect” program structures five exam domains: Agentic Architecture (27%), Tool & MCP Integration (18%), Claude Code Configuration (20%), Prompt Engineering (18%), and Context Management & Reliability (17%). Matt Pocock constructively tested the redesigned /init command: significantly better than before (interactive, suggests skills and hooks, no huge bloat), but still too servile to user input. Tim Carambat explicitly warns against Skills.md as a token trap: individual skills cost up to 6,000 tokens, GStack plans up to 21,000 — leading to substantial costs in cumulative sessions, especially once VC subsidies end.

Coding Agents (non-Claude)

OpenClaw received three independent feature updates this week: Clawhub integration (search and install skills in real-time via CLI), a Mission Control UI for skills management with analytics and build buttons, plus the /btw slash command for lightweight one-off questions without context costs. Alex Finn shows five concrete use cases — Daily Memory Tracker, Trending Content Alerts via X/Reddit/YouTube APIs, Vibe Coding, an R&D team of five parallel AI models (cost: ~40 cents for four memos), and an autonomous Overnight Employee per cron job at 2 AM. Julian Ivanov delivers the most systematic beginner course on OpenClaw’s architecture: Soul.md, Identity.md, Agents.md, the Agentic Loop (Think-Observe-Act), Gateway routing across 20+ channels, Sessions as parallel conversation threads, Subagents as temporary context isolators, and Heartbeat Costs. MoureDev explains the security recommendation: don’t install OpenClaw on your main machine, but on a dedicated Mac Mini or VPS. Nate Herk demonstrates Paperclip as a free open-source orchestration tool uniting multiple Claude Code agents with shared task list, ticketing system, and budget limits in one dashboard — the CEO agent independently hires an engineer who receives tasks. The most philosophical perspective comes from Niklas Steenfatt, who builds a four-panel terminal dashboard to watch his OpenClaw instance Amadeus work — and discovers Amadeus bypasses a non-functional Codex tool by independently spawning sub-agent processes.

Software Engineering & Dev Culture

Theo (t3.gg) fundamentally addresses the future of issue trackers: Linear observes that 75% of enterprise workspaces use coding agents, agent volume quintupled in three months, and agents already create 25% of new issues. The thesis: if AI is competent enough to play CEO, manager, designer, engineer, and QA, human job division makes no sense — the right approach is Prototype-First (code first, then plan informed), not Spec-First. Jira and Atlassian make no moves in this direction; Linear is on the right track but still thinks too much in human role categories. Tim Carambat (AI Made Coding Worse) names five quality problems from AI-assisted coding: confident false delivery without detectability, loss of domain knowledge (after 200 prompts you don’t understand your own architecture), optimization for tests over scalability, Dependency Debt (thousands of lines nobody understands), and the Just-Fix-It Loop. Nate Jones abstracts Nvidia researcher Rob Pike’s five classic software engineering rules to agents: no speculative optimization, measure before tuning, simplicity over complexity — and shows Factory.ai offers an agent-readiness analysis across eight technical pillars (Linting, Testing, Documentation, Dev-Environment, Code-Quality, Observability, Security, Governance).

Personal AI OS & Agent Frameworks

Nate Jones breaks down the agent concept this week into four clearly distinct production types: Coding Harnesses (single LLM with file access, humans as managers), Dark Factories (spec in, software out, humans only at start and end), Auto Research (iterative metric optimization like Tobi Lütke’s 53%-performance jump at Shopify), and Orchestration (specialized roles for thousands-tasks scale). His core argument: confusing these four types is the most common architecture error. Cole Medin contrasts SDK-based approaches (Claude Agent SDK, Codex SDK: fast, simple, automatic conversation management) with classic frameworks (Langchain, N8N, Pantic AI: cheaper in production, essential with multiple users). Terms of Service are an underestimated obstacle: SDKs may only be used for single users with their own subscription per usage terms. Ben AI shows how Obsidian as local markdown vault grows together with Claude Cowork: the central claude.md navigates the entire vault structure, skills point to specific vault files rather than embedded reference files, and updates propagate immediately to all skills. Brian Casel demonstrates four mobile Claude Code workflows — Quick Handoff, cloud session via GitHub, new project on phone, and the power-user setup with Termius plus Tailscale for full local access on the go. Melvynx fundamentally criticizes MCPs: they inject all tool descriptions permanently into context, even if those tools aren’t needed — his counterproposal is CLIs with On-Demand Skills that load only when needed and work more reliably and token-efficiently via standardized bash pipelines.

AI Automation & Workflows

n8n shows in its livestream that MCP can now create and edit workflows directly from Claude Desktop — a live demo builds a daily AI-digest workflow through natural language prompt. Further n8n announcements: CLI for workflow management, One-Click OAuth for ~30 integrations (cloud-only), and Agents as First-Class Citizens rather than just nodes. Firecrawl brings real browser session control for agents with its new Interact endpoint (navigate, click, fill forms); n8n cloud users get 100,000 free credits. Adam demonstrates an n8n system turning YouTube videos into three shorts: Gemini analyzes structure, Replicate generates B-roll, Creator Mate renders from template library — the human just films 45 seconds of themselves, the rest runs automatically. Kyle Balmer connects SEO automation with Claude: Rishi Daniel’s free Claude-SEO Skill (GitHub) runs fully automated audits (technical SEO, EEAT scoring, schema markup, AI-search optimization) and can work through 20 pages nightly with Scheduled Tasks. Zubair Trabzada shows two practical multi-agent tools: a GEO-Audit tool (5 parallel sub-agents analyze AI Citability, Brand Authority, Technical, Content Quality, and Schema; output: PDF with GEO-score and platform-specific ChatGPT/Perplexity/Gemini readiness values) and a Contract Analyzer with 14 skills and 5 sub-agents reviewing freelancer contracts for risky clauses in 60 seconds.

AI Video & Content Creation

Sora’s shutdown buried Disney’s planned $1-billion investment — Kyle Balmer analyzes Google as the likely new video-AI partner for Disney, while Apple has no relevant models despite owning Pixar. Luma AI’s new Uni One model doesn’t work diffusion-based but autoregressive as a Transformer — thinks composition first before generating, which per Everlast AI yields better pixel accuracy and less noise, but weaker on text in images versus competitors. Seeance 2.0 is globally available via PI API (unofficial wrapper): natively multiple camera angles, automatic sound effects/dialog/lip-sync/music, timeline prompting as best practice for cinematic results (five seconds in fast quality: ~40 cents). Remotion, the React framework for video-as-code with over 150,000 installs, and Blender MCP (17,000 GitHub stars for 3D scenes via natural language) are read by Nate Jones as part of a larger shift: design migrates to command line, the classic designer-engineering handoff triangle replaced by parallel, inherently buildable workflows.

AI Business, Marketing & Freelancing

McKinsey’s projected trillion-dollar agent revenue depends, per Nate Jones, on a structural prerequisite almost everyone ignores: product catalogs, shipping promises, return policies, and all transactional data must be “agent-readable and agent-writable” — not as marketing copy but as structured schemas with verifiable sources. Four common misconceptions are worked through: agent discovery doesn’t work like search-engine ranking (agents evaluate structured data against explicit constraints), product complexity is no obstacle but advantage, customer trust begins with intent delegation, and waiting is per the speaker “signing your own death warrant” (data cleanup takes months). Nate Herk documents Cal AI: an 18-year-old built a calorie scanner by photo (started May 2024, one million downloads in 3–4 months, over one million dollars monthly revenue, sold end 2025 for estimated $100+ million) — lessons: problem-driven ideation, Creator-First Marketing (DMs to 20–30 creators, creative freedom, first 15 seconds product demo), and retention through Habit Features (Streaks, Health Score). Today Cursor, Lovable, Claude Code, and Replit enable the same start without coding knowledge.

PKM & Knowledge Management

Ben AI shows the Obsidian-as-second-brain system in mature form: the file structure (Context, Daily, Departments, Intelligence, Meetings, Projects, Resources, Skills, Tasks, Teams) serves as unified knowledge source for Claude Cowork, Claude Code, and any AI agents — all access the same local markdown folder. The decisive long-term advantage: accumulated context over weeks and months makes every agent exponentially better; those starting later lose this edge irretrievably. Mark Kashef demonstrates video-based skill creation: screen recording (5–30 minutes) → Gemini Video Understanding API extracts tacit knowledge, decision criteria, and nuances systematically missed by written SOPs → Skill Creator Skill generates production-ready skills with multiple-choice dialogs for decision points. The approach for content repurposing (YouTube transcript to LinkedIn and X posts) shows how Gemini draws personal writing-style preferences from video and builds them into the skill.

Prompting & AI Literacy

Matt Pocock makes hallucination operational: LLMs hallucinate because training compresses massive data into a smaller model (like extreme image compression) and benchmarks reward rates over uncertainty. Practical consequence: use LLMs only with intrinsic information (data you bring into conversation), force “use your search tool” for extrinsic questions, for critical decisions audit the researched source documents yourself. Dave Ebbelaar derives five new core competencies from his Rust-project experience (never learned language, completed fully with AI): system architecture over line-level thinking, full-stack overview for AI steering, natural language as new programming language (speech recognition improves clarity), radical simplification after each build cycle (ignored step determining code quality), and systematic testing with real edge cases rather than optimistic mocks. David Shapiro reflects a subtler problem: AI’s speed empties creative “wells” faster than they refill — four music albums in weeks with Suno, then a year and a half silence until real life experience brought new impulses. True creative satisfaction comes from external surprise, not AI personalization.

AI Industry & Strategy

Nate Jones maps strategic bets in agent ecosystem across three axes (Laufort, intelligence-orchestration, interface): OpenClaw maximizes data sovereignty at high security risk, Perplexity Computer ($200/month) delivers governance with data-trust trade-off, Manus bets on Meta ecosystem distribution, Anthropic Dispatch addresses less technical professionals, Lovable faces pressure transforming from Vibe-Coding tool to general-purpose agent builder. TheAIGRID analyzes Sora shutdown mathematically: ~$130 compute cost per ten-second video, 11 million daily clips at peak — roughly $15 million daily compute costs without meaningful revenue. Meanwhile ChatGPT lost mobile market share from 69% to 45% while Claude grew 240% monthly. Kyle Balmer runs business models against each other: Anthropic earns similarly or more than OpenAI with 30–40 million users with 900 million — at substantially better margin because API and enterprise revenue dominate. Theo dissects subsidy mechanics: Anthropic’s $5,000 compute for $200/month at Claude Code deliberately crushes competitors and locks users in — a model ending once VC-funding phase ends. Adrian Locher (Merantix) sees Foundation Models heading toward commodity status like cloud computing and predicts future in vertically integrated, outcome-based business models: Vara (AI breast cancer screening, 50%+ all German monthly screenings), Cambrium (biomaterials with protein transformer), Delta (camera systems for factory processes in daily use). Nvidia’s Nemo Claw (enterprise layer over OpenClaw with security guardrails, policy control, and local GPU compute) is read by Nate Jones as countermodel to consulting-dependent OpenAI/Anthropic deployment strategy.

AI & Society / Future of Work

The week brought two complementary macro analyses on work. David Shapiro’s “Universal High Income” essay argues the wage share of national income fell since the 1970s from 65% to 56–58% and the coming automation wave requires three income sources: state transfers (Alaska Permanent Fund as model), public capital (Sovereign Wealth Funds; a US fund at 3–5% GDP/year could generate $58 trillion in 30 years), and private capital (ESOPs, Baby Bonds, cooperatives). The timing problem is critical: funds need decades to mature, automation wave comes 2030–2035. The anthropological-sociological counterpart comes from the Datapizza channel with the Anthropic exposé and Goldman Sachs analysis: programmers exposed ~75%, manual jobs barely — yet $100 billion quarterly AI investment delivered practically zero GDP contribution 2025 (productivity paradox; cf. electric motor: 30 years with no benefit until process reorganization). Nate Jones describes the split job market in parallel: 3.2 AI jobs per qualified candidate, 142 days average filling time — sought are Specification Precision, Evaluation Judgment, Multi-Agent Decomposition, and Context Architecture. The Le-SamourAI channel warns against the LinkedIn-founder trap: 70% more founder titles this year stem from fleeing the collapsing juniors market, not real opportunity — without domain expertise and judgment, entrepreneurship fails, while IBM and Shopify parallel tenfold their junior hires but for AI-native roles with four judgment types (delegation, specification, evaluation, organization).

Brief Notes

Google Stitch (free UI design generator, 350 generations/month, Gemini-3.1-Pro-based, MCP integration for Claude Code) is shown by Leon van Zyl and Nate Jones as Figma alternative for command-line design workflows. GLM 5.1 from Zi reaches 45.3% on coding benchmarks versus 47.9% at Opus 4.6 — an open-source model closing the gap to frontier models. Airavy (open-source context-retrieval layer with 50+ connectors for GitHub, Notion, Slack) shown as MCP alternative for Antigravity agents. 11 Labs CLI now agent-first: voice agents spawn from command line rather than UIs, letting coding agents take over creation. Mistral Boxrol TTS brings text-to-speech in nine languages. Tech With Tims Five-AI-Comparison Tool (ask ChatGPT, Perplexity, Gemini, Grok, Copilot simultaneously, compare brand mentions, via Bright Data Serp API) addresses AI brand monitoring as new SEO discipline. Semux (macOS terminal with multi-level tab navigation, port status, GitHub branch display) and Helium (minimalist Chrome-based browser) recommended as optimal Claude Code dev setup. Anthropic surveyed 80,508 people across 159 countries (via Claude as interviewer): top wish professional excellence (18.8%), biggest concern unreliability/hallucination (26.7%); sub-Saharan Africa and Latin America notably more optimistic than North America. The Maven Smart System (Palantir, AWS, Azure, Google, originally with Claude — then replaced by OpenAI after Dario Amodei objections) is technically and satirically dissected by Fireship as AI-driven military kill chain.

AI Explained (1 new video)

• Two AI Models Set to “stir government urgency”, But Will This Challenge Undo Them?
  26.3.2026, 20:15:12

  The video covers several current AI developments and their implications.

  OpenAI and Anthropic – new models on the horizon: Both companies are working on major performance leaps. OpenAI has discontinued the Sora app to free up computing resources for the new “Spud” model, which according to insiders should be available in a few weeks. Anthropic is warning US government officials that the next Claude version could dramatically improve offensive and defensive cyber capabilities – potentially reigniting negotiations for the Pentagon deal.

  Arc AGI 3 – the new benchmark: A new benchmark system was released where humans achieve 100%, but current AI models score below 0.5%. The key difference: tests are abstract, interactive puzzles with no linguistic or cultural clues; the model must infer its own objectives. Arc AGI 1 and 2 were recently saturated because models using chain-of-thought reasoning “gamed” the benchmarks through similar training patterns as the test sets. Arc AGI 3 prevents this by using different data distributions between public and private test sets. The scoring methodology penalizes inefficiency quadratically and enforces a 5x action limit, making true generalization hard to measure. Symbolica AI achieved all public levels with a multi-agent harness, but harnesses aren’t permitted in evaluation.

  Automated AI research: OpenAI is pursuing fully automated AI researchers – an intern-level system by September. The analogy: like code agents in software development. However, OpenAI’s GDP-Val paper shows that even when AI creates the first draft and humans only edit, speedups typically hover around 40% – no exponential takeoff.

  Security risks: A supply-chain hack in a Python library demonstrated how open-source dependencies can be exploited to exfiltrate secrets. While agentic swarms could be deployed for exploit detection, Nvidia’s Jim Fan warns that “claws need shells” – multiple layers of protection – especially as models can now manipulate benchmarks themselves in real-time.

  Overall impression: We’re in a “messy middle” phase: AI is better at first drafts than humans, but outputs still have gaps. There’s generalization at low-level concepts (programming languages, natural language), less so at high-level objectives (academic integrity, adaptive goal planning).

  Explicitly mentioned: OpenAI (Spud model), Anthropic (Claude), Google DeepMind (Gemini 3.1, NetHack), Arc AGI 3, Assembly AI (Universal 3 Pro Streaming); Format: Roundup/Deep-Dive with opinion elements.

AI Foundations (1 new video)

• Automate ANY Task Using Claude Skills! (Full Cowork Setup)
  27.3.2026, 16:00:40

  Summary: Claude Skills for automating business tasks

  The creator introduces his DBS Framework — a three-layer model for structuring Claude automations:

  • D (Direction): The skill.md file that guides Claude step-by-step on what to do
  • B (Blueprints): The references folder with static files like style guides, data samples, and templates
  • S (Solutions): The scripts folder with code that Claude can execute — for API calls, calculations, and external tool integration

  Practical Demo 1 – Proposal Generator for Trade Businesses:

  The creator shows live how he instructs Claude to develop an automation for creating project proposals. Claude iteratively asks for details (project types, pricing model, branding colors), then runs 2–3 test cases and generates realistic proposal PDFs. After feedback, the automation is saved to the skill database and can then instantly generate a formatted quote from a tradesperson’s simple notes.

  Practical Demo 2 – YouTube Analytics Dashboard:

  The creator uploads YouTube data and instructs Claude to create an interactive dashboard with soft brutalism styling, neon pink accents, and tabs (Video Performance, Growth, Revenue). Once finalized, this output becomes the basis for instructing Claude to build an automation that will automatically transform any future YouTube analytics uploads into this exact dashboard format.

  Bonus Example – Call Prep Skill:

  An existing skill connects Google Calendar and Notion to automatically pull CRM notes and call summaries for relevant contacts before upcoming meetings — all with the command “call prep tomorrow”.

  Access is via Claude Desktop/Co-Work through Customize → Skills. You first enable “Skill Creator” and the DBS Framework Skill (available for download), then create automations in natural language. Claude Co-Work displays a progress bar and continuously loads relevant context and tests.

  Key Insight: Customized data (your own rates, competitor prices, tools, standards) transforms skills from “quite helpful” to “extremely helpful”; one initial setup hour creates lasting efficiency.

  Claude and Claude Desktop/Co-Work were the focus; tutorial format with live demos of proposal and dashboard automation plus a practical call-prep example.

AI with Arnie (1 new video)

• The only Claude Code course you need
  25.3.2026, 21:58:51

  Summary: The only Claude Code course you need

  The course covers Claude Code as a central AI productivity platform and demonstrates its practical application comprehensively – not only for developers, but for anyone who wants to work more productively. The content is very dense and practice-oriented.

  Installation & Setup: Claude Code is installed via terminal (not via IDE extension), requiring a paid plan (Pro subscription from around €17/month recommended). OS-specific commands are provided.

  IDEs: While VS Code is recommended as the favorite (lower complexity, fewer bugs), Cursor and Antigravy (from Google, formerly Windsurf) are also possible – though the latter are more bloated.

  Project 1 – Personal Assistant: Using a folder structure (data, context, prompts), Claude Code is trained as an AI assistant. You add business data, writing samples, and recurring prompts. A Cloud.md serves as a reference guide for Claude. The system can then write emails in your personal style, compose tweets, etc.

  Skills Integration: Claude Code gains functions through Skills, Plugins, MCP (Model Context Protocol), or CLI tools – essentially all function calling. Sapier is shown as an MCP server to enable Gmail and calendar access. Notebook LM is integrated via skill to generate in-depth research, mind maps, and podcasts.

  Permissions: Options include manually approving each action, whitelisting in .cloud/settings.json, or start flags like --dangerously-skip-permissions (allow all) or --enable-auto-mode (middle ground with prompts for critical commands).

  Custom Slash Commands: In the /Cloud/commands folder, frequently used prompts can be saved as .md files – for example search.md for business news – and can then be accessed directly via /search.

  Automations: Difference between Schedule (time-triggered tasks in the cloud, daily/weekly etc., runs in background) and Loops (intervals in active session, max. 7 days, min. 1 minute, full local access).

  Additional topics covered: Various Claude models (e.g., Opus 4.6 with 1 million token context), tracking token usage (/slack-text), compressing context (/compact), customizing statusline, Git integration, version control, plugins, Soul.md for agent behavior/personality.

  The transcript ends mid-example for Schedule tasks, so it’s abbreviated; according to the announcement, the course covers four complete projects (personal assistant, website programming, Python AI agent, command center).

  Topics covered: Claude Code, Anthropic, Notebook LM (Google), Sapier (MCP), Cursor, VS Code, Antigravy – tutorial/deep-dive with high practical detail.

AI News & Strategy Daily | Nate B Jones (7 New Videos)

• Anthropic Just Gave You 3 Tools That Work While You’re Gone.
  28.3.2026, 15:28:38

  Anthropic released three new tools for Claude that enable real automation together: Scheduled Tasks, Dispatch, and Computer Use. The core message isn’t technical innovation, but a fundamental mindset shift: these tools are meant to make work actually disappear from your desk, not just generate more busywork through briefings or drafts.

  Scheduled Tasks functions as a cloud-compute environment that executes code on a fixed schedule (hourly, daily, etc.) without your laptop needing to be on. Examples: gathering AI news daily, monitoring flight prices, managing payment reminders. You can connect existing MCP connectors (Linear, GitHub, Slack, Google Drive).

  Dispatch links your phone to Claude on desktop via QR code and enables parallelization: from your phone, you can launch multiple Claude work tasks simultaneously that run independently on desktop—while you’re away. This isn’t remote control, but an orchestration layer. The trade-off: your desktop must stay on (though this will likely be fixed soon). Multi-app tasks still work only ~50%.

  Computer Use is the game-changer: Claude can control mouse and keyboard, open apps, click through legacy systems with no API (old ERP instances, SAP, Jira, etc.). It solves the problem of millions of office processes not mapped in any MCP server.

  The author argues sharply against “pseudo-work” demos (proactive briefings, trip planning) and instead demands a manager mindset: trust the system to do work while you’re away. Practical use cases are closing commitment loops (keeping promises), making better decisions through data gathering, compound-signal detection (with OpenBrain), and for engineers: overnight jobs (refactoring, tests, migrations). The biggest psychological hurdle is trusting the system when you’re not looking—that’s the real skill shift for 2026.

  Claude, Dispatch and Computer Use (Anthropic); Opinion/Reflection with tutorial elements.

• A Markdown File Just Replaced Your Most Expensive Design Meeting. (Google Stitch)
  27.3.2026, 14:01:22

  The video covers three major AI releases in recent weeks that fundamentally change design: Google Stitch (text-to-UI generator in markdown export format, directly linkable with coding agents), Remotion (React framework powering Claude Code with over 150,000 installations, generating video as code with every frame editable), and Blender MCP (17,000 GitHub stars), which creates 3D scenes through natural language descriptions.

  The central argument: design is moving to the command line, breaking apart the classic product-engineering-design triangle of the 2010s. Instead of sequential handoffs (designer → code export → engineering review), a parallel workflow model emerges where results are buildable by definition. MCP is described as the universal standard for connecting these tools.

  Concrete benefits: Stitch offers 350 free generations/month with multi-screen versioning and design markdown export; Remotion enables scalable video production (data updates trigger automatic re-renders) without After Effects; Blender MCP abstracts away 1500+ UI elements. The video emphasizes: the cost of creative work falls toward zero, not because designers become obsolete, but because operational tasks (moving layers, adjusting keyframes, converting formats) vanish through automation. Creative judgment and refinement remain human—but the speed from ideation to artifact accelerates dramatically.

  Critical limitations are named: Stitch designs aren’t client-ready without rework; Remotion handles complex animations poorly; Blender MCP fails at intricate organic modeling. The video closes with a plea for “command line design thinking” as a 2026 skill: tool mastery isn’t decisive, but the ability to articulate visual intent precisely, iterate quickly, and enforce taste is.

  Claude, Google Gemini, Anthropic (Claude Code), OpenAI mentioned; MCP as central infrastructure; Opinion/Reflection with product demonstration.

• The AI Job Market Split in Two. One Side Pays $400K and Can’t Hire Fast Enough.
  26.3.2026, 15:59:47

  Summary: The AI Job Market Split in Two

  The speaker describes a K-shaped split in the AI job market: traditional knowledge-work roles (product managers, software engineers, business analysts) stagnate on one side, while explosive demand for expertise in designing, building, and operating AI systems exists on the other. The ratio is roughly 3.2 AI jobs per qualified candidate; on average, it takes 142 days to fill a position—many employers fail completely at hiring.

  The speaker identifies seven concrete, demand-driven skills from hundreds of job postings:

  1. Specification Precision / Clarity of Intent: precise, literal communication with agents (not metaphorical like with humans) to avoid misunderstandings.
  1. Evaluation and Quality Judgment: ability to critically assess AI output—particularly resistance to “fluent wrongness,” when AI systems confidently deliver falsehoods. Critical are error detection and edge-case identification.
  1. Multi-Agent Decomposition: breaking complex tasks into manageable subsegments and delegating to different agents—fundamentally a management skill, but with stricter requirements than with humans since agents need clear guardrails.
  1. Failure Pattern Recognition: diagnosis of six typical failure modes: context degradation (quality decline in long sessions), specification drift (agent forgets spec), sycophantic confirmation (agent uncritically affirms wrong data), tool selection errors, cascading failures, and silent failures (plausible but incorrect outputs).
  1. Trust and Security Design: building guardrails and containers around agents—understanding cost of error, reversibility, frequency, and verifiability. Distinguishing between semantic correctness (sounds right) and functional correctness (actually right).
  1. Context Architecture: building context systems that provide agents relevant information on demand—the “Dewey Decimal Classification for agents.” Managing persistent and per-session context, data quality, and searchability.
  1. Cost and Token Economics: calculating token costs for tasks, selecting models based on cost-efficiency and ROI—”high school math at senior architect level.”

  These skills appear in job postings across various titles (operations, engineering, product management, AI reliability) but aren’t engineering-specific—backgrounds in technical writing, law, audit, or library science are transferable. The speaker emphasizes these skills are coupled to AI system logic and therefore remain relevant long-term, and announces a job board and learning resources on Substack to help talented candidates and employers.

  Info: Opinion/Reflection with practical guide elements, focus on Anthropic Claude (as example for eval practices and Certified Architect Program) and general AI agent systems.

• Tobi Lütke Made a 20-Year-Old Codebase 53% Faster Overnight. Here’s How.
  25.3.2026, 14:00:52

  The video breaks down the abstract concept “agents” into four concrete production types that function completely differently in practice:

  Coding Harnesses are the simplest: a single LLM with file access and code tools replaces a developer for a defined task. The human remains the manager. They scale up to project level when a planner agent coordinates multiple executor agents (like Cursor with browser and compiler projects). The key is decomposition—breaking work into discrete pieces.

  Dark Factories remove humans from the middle process: spec in, software out, between them only automated agent iteration against evaluable tests. Humans are involved only at the start (design, spec quality) and end (reviewing evals, code review for accountability). This reduces bottlenecks because agents are faster than humans in the middle.

  Auto Research is a different beast—not for software production, but metric optimization. The LLM iterates experimentally to improve a target (e.g., runtime performance like Tobi Lütke at Shopify, model tuning, conversion rates). Classic from machine learning.

  Orchestration is for specialized roles in workflows: one agent researches, one writes, one manages tickets. This requires heavy lifting in prompt engineering and context management for handoffs and only makes sense at real scale (thousands+ tasks).

  The core mistake: not distinguishing these four. Auto research for software is wrong. Coding harnesses for novel writing too. Architecture must fit the problem—is it software-shaped or metric-shaped? Simply configured agents scale better than complex ones.

  Themes: Cursor, Claude, Codeex, Langraph, Crew AI, Andre Karpathy, Tobi Lütke; Format: Deep-dive/Opinion.

• Nvidia Just Open-Sourced What OpenAI Wants You to Pay Consultants For.
  24.3.2026, 14:00:09

  The video addresses the conflict between Nvidia, OpenAI, and Anthropic over deployment strategy for AI agents. The central point: OpenAI and Anthropic realized over 2025 that their solutions, while technically impressive, are too complex for enterprise teams in practice. So they’re now publicly enlisting consulting firms. Nvidia takes a different path: Nemo Claw, an enterprise version of OpenClaw, is being developed open-source as a layer over OpenClaw with security guardrails, policy-based control, and local GPU compute—not to sell expertise, but to empower developers.

  The speaker argues that real challenges in agentic development aren’t new problems, but rediscovered software engineering best practices: Rob Pike’s five classic rules (no speculative optimization, measure before tuning, simplicity before complexity, simple algorithms fewer bugs, data structures dominate) hold unchanged. Factory.ai demonstrates this through an agent-readiness analysis across eight technical pillars—the result: the agent isn’t the problem, but the surrounding infrastructure (linting, testing, documentation, dev environment, code quality, observability, security, governance).

  Five concrete production challenges are walked through: (1) context compression—Factory.ai’s incremental summarization beats OpenAI’s Compact Endpoint and Anthropic’s Cloud SDK, (2) code instrumentation and measurability, (3) linting to enforce code simplicity, (4) multi-agent coordination with planner-executor pattern instead of over-optimization, (5) clear specs upfront. The central thesis: consultants profit from complexity; real change works only through back-to-basics thinking and co-building, not PowerPoint decks. Nemo Claw signals that developers “can do this” if they understand fundamentals—the opposite of the consulting narrative that creates dependency.

  Demo/News Update, explicitly themed: Nvidia (Nemo Claw / OpenClaw / OpenShell), OpenAI, Anthropic, Factory.ai, Cursor.

• I Mapped Where Every AI Agent Actually Sits. Most People Pick Wrong.
  23.3.2026, 14:00:50

  The core analysis lies not in security debates or the race to copy OpenClaw, but in strategic bets each company placed on different positions in the agent ecosystem. The speaker defines three axes to understand these bets: (1) where the agent runs (local, cloud, hybrid), (2) who orchestrates intelligence (single model, multi-model, model-agnostic), (3) which interface is used (messaging app, desktop, phone).

  OpenClaw maximizes both dimensions: full data sovereignty and control for technical users, but with high security risk and complexity. Perplexity Computer plays the delegation game—cloud-based, secure sandbox, but $200/month and data trust to Perplexity. Manis pursues the distribution angle: Zuckerberg wants to channel agent attention into his Meta ecosystem and bets on scale over privacy. Anthropic Dispatch offers the security narrative: single-threaded, simple, Claude-focused, for less technical professionals. Lovable must transform from pure vibe-coding tool to general-purpose agent builder to stay relevant.

  The speaker predicts “relentless simplification”—all vertical tools face pressure to collapse into conversational agents. The middle is where products die; survival goes to those either highly specialized or general-purpose-delegative. The central 2026 question isn’t “which agent is faster,” but “how do we delegate agent trust?”—a choice that collectively shapes markets for the next 10–20 years.

  Explicitly themed: OpenClaw (primary), Perplexity Computer, Manis, Anthropic Claude/Dispatch, Lovable, Meta, OpenAI; also mentions of Nvidia Nemo, ZeroClaw, Moltus, Open Fang, Nanobot, and open-source forks generally. — Format: Opinion/Reflection (strategic analysis and framework development).

• McKinsey Says $1 Trillion In Sales Will Go Through AI Agents. Most Businesses Are Invisible.
  22.3.2026, 18:00:09

  Summary: McKinsey Says $1 Trillion In Sales Will Go Through AI Agents

  The speaker argues that the coming trillion-dollar revenue shift to AI agents depends on a fundamental, largely ignored prerequisite: enterprise infrastructures must become “agent-readable and agent-writable” from the ground up. This means not just APIs or superficial chatbot features, but transactional systems—product catalogs, shipping promises, return policies, all product data—must be structured so agents can reliably read, interpret, and potentially write them.

  The historical irony: for twenty years, systems were deliberately locked down against bots (CAPTCHAs, closed APIs, JavaScript-heavy interfaces). Now, when agents are the most valuable form of customer attention, these walls must come down. The speaker warns, though: this isn’t just wrapping APIs in an MCP server. The Stripe example shows this concretely—their Sigma analytics layer works as CSV export, but as an MCP server would overload the context window; you need database infrastructure and authentication logic in between.

  SAP sits at the other end: they announced an MCP for Commerce Cloud, but the gap between this slice and truly agent-readable SAP landscape is huge. That’ll be a “multi-quarter initiative” for which SAP currently has no incentive.

  The speaker names four misconceptions:

  1. Agent discovery like search engine ranking: Wrong. Agents evaluate structured data against explicit constraints; there’s no “above the fold.” Winners have clean schemas, not the biggest ad budgets.
  2. “Our products are too complex to structure”: Wrong. The more complex, the more you gain, because customers today get stuck at “good enough” and can cover complexity with real data.
  3. “Customers won’t trust agents to transact”: Wrong. Trust is a spectrum starting with intent delegation (“find me a sound system for my room”), not full purchase delegation.
  4. “We’ll wait and see”: That’s “signing your own death warrant.” Data cleaning takes months to quarters; those who wait become invisible to agents.

  A central problem: roughly 20% of product meaning lives in data structures, 80% in marketing copy and tribal knowledge (e.g., that a coffee supports an Ethiopian village). When an agent searches “coffee that supports important work,” that must be available in data attributes, or the product vanishes. This requires structured schemas—e.g., that a basketball “was used in the 2026 March Madness tournament”—not just as marketing text, but as agent-readable data attributes with verifiable sources.

  McKinsey projects up to a trillion dollars in “orchestrated revenue” through AI agents by 2030 in US B2C retail alone. Google launched its Universal Commerce Protocol, over a million Shopify merchants are online, but big players (Apple, Google) still resist—Apple even blocked coding apps like Replit. The speaker compares this to Napster: the old guard loses in the end because “people” want agent-readable, agent-writable ecosystems.

  The concrete example: a customer types “running shoes under $120, size 10, ship by Thursday, flexible return”—the agent can only solve this if shipping times, return policies, schema details are truly structured and available. Otherwise the agent skips the offering without the human ever seeing it.

  Finally, the speaker recommends an audit: test with Claude or ChatGPT how far your transactional system and your top 3 competitors’ reach. Then systematically structure data for agents—not because you’d forget humans, but because clean data automatically enables great customer experiences for people too.

  Explicit mentions: OpenAI (ChatGPT), Anthropic (Claude), Stripe, SAP, Amazon, Google, Apple, Shopify, Perplexity, Meta/WhatsApp — themes include agent integration, MCP servers, product data structuring and infrastructure transformation. Format: Opinion/Reflection with concrete business examples and actionable recommendations.

Alejandro AO

No new videos in this period.

Alex Finn (5 new videos)

• LIVE: CLAUDE MYTHOS (OPUS 5) REVEALED!!!
  27.3.2026, 20:10:49

  Summary

  The streamer breaks news about “Claude Mythos” (reportedly Claude Opus 5) from Anthropic: A leaked model classified as superintelligent and “too dangerous” for the general public. Anthropic is initially providing it to cybersecurity firms and making it available API-only. The model will be significantly more expensive than previous models – the streamer predicts minimum costs of $2,000 USD/month for individual users.

  Core theses:

  Economic inequality: Access to superintelligence widens the gap between rich and poor. Those who can afford it generate exponentially more economic value; those who can’t remain stuck in a “permanent underclass” and can’t keep up.

  Preparing for AGI: The streamer offers a central recommendation: Build moonshot applications that don’t work now, but are ready to deploy immediately after Claude Mythos launches. This provides first-mover advantage on AGI day. The specific workflow: Use ChatGPT prompts to generate 10 moonshot ideas → select them → vision doc + V1 roadmap → implement in Cursor/Claude Code.

  Local hardware models: Despite frontier models’ superiority, you need local models (e.g., Qwen 3.5 on DGX Spark) for agentic swarms – multiple AI agents working 24/7 in parallel, reducing costs while creating new use cases.

  Practical preparation: Cancel subscriptions (Netflix, Game Pass), invest the savings in compute (DGX Spark, Mac Studio M5), prototype applications now.

  Personal announcement: The streamer will present a self-built moonshot app at MIT in 2 weeks (in response to criticism that he “doesn’t build anything”).

  Additional topics:

  • Hardware is getting more expensive (PS5 price increase), not cheaper → local AI operation becomes costlier.
  • Open-source models lag 6 months behind frontier models.
  • ChatGPT Spud is expected in parallel with Claude Mythos (next 3 weeks).
  • Paperclip AI will be demonetized afterward.

  The streamer positions this not as fearmongering but as an opportunity for early builders working on seemingly moonshot ideas now.

  No specific AI tools mentioned except Claude (Opus 4.6), ChatGPT, Qwen 3.5, Cursor, Claude Code; Format: Live Q&A with news update and motivational reflection.

• LIVE: OpenAI Shutting Down Sora!! It’s OVER. Also I’m running Opus 4.6 locally????
  25.3.2026, 20:45:23

  LIVE: OpenAI Shutting Down Sora + Running Opus 4.6 Locally – Summary

  The video is a chaotic live stream covering multiple topics:

  Sora shutdown: OpenAI is discontinuing Sora. The host used it previously to create videos and send them to friends, but stopped using it after the direct send feature was removed. He views the shutdown as no big deal.

  Rumors of new model: Rumors are circulating about a new OpenAI model called “Spud,” which could potentially be AGI and is referred to as GPT-6. It’s reportedly supposed to combine Cursor, Codeex, and ChatGPT into one app.

  Locally running Opus 4.6: The host demonstrates a distilled version of Claude Opus 4.6 that he runs locally on his Mac Studio. It’s a “learned” model from Qwen 3.5 that sounds like Opus.

  Even Realities glasses (G2): He’s ordered smart glasses with ring control to install OpenClaw on them – to give commands without pulling out his phone.

  Peter Steinberger drama: The host tweeted that OpenAI had acquired OpenClaw. Peter publicly corrected him, saying OpenAI hired him as an individual, not acquiring the project. The host would have preferred private correction; however, he defends that the statement was “spiritually” correct.

  Business philosophy: The host advises building tools that are impossible today so you can simply plug them in with AGI later. He’s working on a secret project called “Henry” for a specific niche – not just an OpenClaw clone.

  Other topics: Hermes agent (with problematic memory compactions), comparisons between Claude Code and OpenClaw, Apple Studio Display XDR (too expensive, no difference), upcoming Bay Area seminars on OpenClaw.

  The stream jumps chaotically between topics since the host just woke up and is drinking a lot of coffee.

  Tools/Models: Claude Opus 4.6, ChatGPT 5.4 Pro, OpenClaw, Hermes, Cursor, Gemini, Codeex; explicitly mentioned: OpenAI, Anthropic – Format: Live Q&A/news roundup with demo elements.

• Why you NEED to be running local AI models (FULL beginners guide)
  24.3.2026, 22:20:54

  Local AI Models – Complete Beginner’s Guide

  The creator has invested over $50,000 in local AI models over two months and shares insights on how these can fundamentally change AI usage – without needing expensive hardware.

  Why local instead of cloud models?

  Cloud models (ChatGPT, Claude, Gemini) run on remote servers and come with several disadvantages: high costs per token, zero control over models (providers constantly change parameters), privacy issues (employees can read logs), latency from internet dependency, and poor scalability. The only advantage is peak intelligence level.

  Local models run directly on your computer and offer: completely free (only electricity costs), fully customizable (your own voice, style, etc.), completely private and secure (no internet connection needed), zero latency, and – most importantly – unlimited scalability: The creator currently runs four local AI models around the clock to scrape websites, write newsletters, and generate code – like multiple employees with no additional costs. The only drawback: local models lag about 6 months behind the best cloud models.

  Required hardware

  Old, cheap laptops work; a $600 Mac Mini already runs local models. For larger models, there are various options:

  • Mac Mini/old devices: Small models (9–16 billion parameters), usable as memory management for agents
  • Mac Studio ($4,000–$10,000): Uses “unified memory,” can load larger models, runs somewhat slower
  • Nvidia DGX Spark ($4,800): Better speed through VRAM, more developer tools (fine-tuning, LoRAs, auto-research possible)
  • Nvidia DGX Station ($100,000): Frontier-level intelligence with multi-agent workflows

  Recommended models

  Qwen 3.5 (best ratio): Intelligent, many versions for different hardware; creator’s “daily driver” for Mac Studio.

  Nvidia Nemotron 3 (new): Very strong, open-source, from the only American company aggressively pushing open-source.

  Minimax 2.5 (fast): Lightweight, extremely performant, not quite as intelligent as Qwen, but ideal for quick tasks.

  Models can be downloaded from HuggingFace. The app LM Studio (free) enables simple local use like a chatbot.

  Practical application – The hybrid model

  The creator shows his setup: A system called a “software factory” with Charlie (Qwen 3.5 locally, writing code around the clock) orchestrated by Ralph (ChatGPT in the cloud). Ralph acts as the “brain” (thinking, deciding) while local models serve as “muscles” (executing). Another example: A local Minimax model continuously scrapes the web for business opportunities and sends them via Telegram – 24/7 for zero dollars instead of thousands daily with ChatGPT.

  The creator rejects the concept of “just saving costs” – the real potential lies in 24/7 scalability and new use cases impossible with cloud models.

  Recommended starting path

  Don’t spend $20,000–$100,000 immediately. Instead: Start with existing hardware, implement one or two small use cases locally, monitor ROI, then gradually upgrade. The creator expects the upcoming M5 Ultra (May/June) with five times faster AI processing to be revolutionary.

  Explicitly mentioned tools and models: Qwen 3.5, Nemotron 3, Minimax 2.5, LM Studio, HuggingFace, OpenClaw, ChatGPT, Claude; Format: Tutorial/demo with opinion component.

• OpenClaw’s new update is MASSIVE
  23.3.2026, 20:14:09

  Summary: OpenClaw’s Massive Update

  The video is a chaotic, energetic live stream where Alex reports on OpenClaw’s biggest new features. The main updates are:

  1. Clawhub integration: OpenClaw can now find and install skills from Clawhub in real time. Via the CLI you can search for skills with clawhub search and install them directly. Alex demonstrates this live and recommends vetting skills beforehand – either by manually reviewing them on the website or by having OpenClaw analyze the skill itself before installing it.

  2. Mission Control UI for skills: During the stream they build a graphical user interface in Mission Control together with viewers that displays all popular skills, makes them searchable, and offers three buttons: one to install, one to analyze (sends code review via Telegram), and one to build your own version.

  3. /btw slash command: This new feature allows asking quick side questions without affecting the context of your main conversation. /btw starts a lightweight one-way question that uses no tools and wastes no tokens – perfect for distractions during intense OpenClaw sessions.

  Additionally, Alex discusses the differences between OpenClaw and Claude Code: OpenClaw is an open-source agent without guardrails that automates everything; Claude Code is a secured, heavily controlled coding tool. He criticizes that Claude Code, despite new features (Dispatch, Remote Control, Channels), still has too many restrictions and lacks the same wild, productive spirit. You can give OpenClaw commands via Telegram from anywhere – e.g., download a model, install it locally, build software around it – and it just makes it happen. One major issue he mentions: Session bloat from cron jobs that drives up costs; he recommends regularly deleting old sessions.

  Tools/providers mentioned: OpenClaw, Claude (Opus 4.6), ChatGPT 5.4, Deep Seek, Hermes; Format: Live Q&A/demo with chat interaction.

• 5 OpenClaw use cases that will actually improve your life…
  22.3.2026, 13:15:13

  5 OpenClaw Use Cases That Will Improve Your Life – Summary

  1. Daily Memory Tracker

  Automates a logging system that summarizes daily what you’ve discussed and built with OpenClaw. This improves the system’s memory and lets you return to any specific project months later. Implementation uses a simple prompt instructing OpenClaw to create daily summaries and feed them into a dashboard. This serves as the foundation for the entire memory system and is said to improve performance tenfold.

  2. Trending Content Alert

  A system using X, Reddit, and YouTube APIs to search hourly for content trending on defined topics (in the example: Claude Code, OpenClaw, AI). Matching content is posted to a Discord channel. This helps content creators always react to current trends and create viral content. The APIs are partly free (Reddit, YouTube) or inexpensive (X).

  3. Vibe Coding

  Spontaneously creating micro-apps directly from chat (without IDE or CLI). Particularly useful for internal tools and personal automation, not large consumer applications. An effective prompt is: “Based on what you know about me and my workflows, what micro app can we build right now?” – OpenClaw knows the user best through memory systems and can make improvement suggestions itself.

  4. Research & Development Team

  An autonomous process with five different AI models that meet daily (or multiple times daily), analyze your work, and debate improvement ideas. This results in a brief memo with recommendations – such as app optimization or revenue increases. According to the speaker, the four previous memos together cost about 40 cents and delivered valuable insights. This process works for any use case: career coaching, content strategy, family planning, etc.

  5. Overnight Employee (Autonomous Night Shift)

  A cron job-based automation that triggers daily at 2 a.m. OpenClaw is instructed to analyze business goals and previous work, then autonomously complete a task to get closer to those goals – such as building a feedback widget, writing a tweet, or developing a micro-tool. You wake up in the morning to find surprisingly completed work.

  All prompts are provided in the video description. The speaker announces an upcoming live bootcamp on Vibe Coding.

  OpenClaw was highlighted as the central tool; Format: Opinion/how-to roundup with demonstration elements.

Andrej Karpathy

No new videos in this period.

Bart Slodyczka

No new videos in this period.

Ben AI (1 new video)

• Claude Cowork + Obsidian Will Change How You Work Forever
  24.3.2026, 11:10:31

  Summary: Claude Cowork + Obsidian for autonomous work

  The creator demonstrates a system that connects a “Second Brain” in Obsidian with AI agents like Claude Cowork to create persistent context for autonomous work.

  The five main benefits:

  1. Persistent context: Instead of running isolated AI chats, the agent has access to detailed documentation on business, strategy, projects, team, and workflows – all centralized in Obsidian. This way Claude can directly know what priorities are on the agenda today or write LinkedIn posts based on team meetings.
  1. Context updates: Decisions, rules, and project updates from AI chats can be written directly back into the Second Brain. The system grows this way: the more you use it, the better the AI becomes through accumulated knowledge.
  1. Better Skills: Instead of equipping every skill with the same reference files, Skills only point to the relevant files in your Obsidian vault (e.g., ICP, voice guide). An update in the vault immediately affects all Skills that use that file.
  1. Provider-agnostic: The Second Brain is just a local folder with Markdown files. Obsidian, Claude Cowork, Claude Code, or other AI agents can access the same folder.
  1. Team-wide scaling: The entire team shares the same strategy documents and context files, making all of the team’s AI agents more powerful at the same time.

  How it works: Obsidian is a visualization of a local folder. The central file is claude.md, a guide for the AI agent on how to navigate the vault structure. The agent reads this file, understands where information is located, and can query or store data there as needed.

  File structure for business: Context (business, team, strategy), Daily (daily logs), Departments (departments with SOPs), Intelligence (meetings, decisions), Onboarding, Projects, Resources (prompts, templates), Skills (with references), Tasks, Teams. For solo professionals: same system, but without Departments, Teams, and Onboarding.

  Setup: Download Obsidian for free, create a new vault and point it to a local folder. Claude Cowork gets access to the same folder. A plugin from the AI Accelerator community helps build the structure faster and populate initial context through prompts.

  Long-term strategy: The system doesn’t need to be perfect from the start – begin with just five files, then grow organically. The real value isn’t in the setup, but in accumulating context over weeks and months: every decision, every rule, every project gets documented and makes the AI exponentially better for you and your team. Those who start later lose this context advantage.

  Key behaviors: Always reference the same folder, explicitly tell the AI what you want it to “remember,” update claude.md when navigation issues arise, adjust old Skills so they reference the vault instead of embedded files.

  Explicitly covered: Claude Cowork, Claude Code, Obsidian, MCPs, Skills, and a proprietary plugin – demo/tutorial format with business strategy component.

Brian Casel (1 new video)

• Claude Code on Mobile: The Complete Guide
  26.3.2026, 12:01:05

  Claude Code on Mobile: The Complete Guide

  The video shows four practical workflows for coding on your smartphone with Claude Code:

  1. Quick Handoff (Desktop to Mobile): You start a Claude Code session on desktop, enable Remote Control there via command, and can then continue the session directly in the mobile Claude app. Changes sync in real time. You can optionally enable Remote Control permanently in the config.

  2. New Session in the Cloud: Via the mobile app (plus icon in the code section), you can select a GitHub repo and start a new Claude Code session that runs entirely in the cloud. Claude automatically creates a pull request at the end. This works without desktop preparation but is limited to cloud environments (no local skills/files).

  3. Project from Scratch: You create a new repository via GitHub Mobile or browser (ideally with a template), then authorize it in the Claude app and start Claude Code on it—all from your phone. Again, completely cloud-based.

  4. Power-User Setup for Full Access: With a combination of Termius (terminal app for remote connection), Tailscale (secure network connection to home machines from anywhere), and optionally T-Mux (keeps sessions active on connection loss), you can switch from your phone via terminal to your desktop project, start claude remote control there, and then work from the mobile app with full access to local files, skills, and configs. This requires initial setup but then runs smoothly.

  Core Tradeoff: Cloud sessions are frictionless but lack local resources. Remote control sessions need desktop preparation or this extended setup with Termius and Tailscale.

  Claude (Anthropic) explicitly mentioned; demo video with opinion/reflection.

Coding with Lewis

No new videos in this period.

Cole Medin (2 new videos)

• Everything You Thought About Building AI Agents is Wrong
  26.3.2026, 00:00:46

  Everything You Thought About Building AI Agents is Wrong – Summary

  The mainstream is currently heavily focused on AI-coding assistants, which is why classical agent frameworks like Langchain, N8N, and Pantic AI receive less attention. The author has also shifted his own content portfolio significantly in this direction. However, there’s an important nuance: while new SDK-based approaches (such as Claude Agent SDK, Codeex SDK) are attractive for many use cases, classical frameworks continue to dominate production reality – the majority of running agents are still built with these older frameworks.

  The classical way: Previously, you’d choose a framework, define tools for the agent, typically integrate a RAG pipeline (with chunking, embedding, and retrieval strategy), and build an agent loop with state and memory management – all involving considerable glue code and complexity.

  The new SDK way: Modern SDKs like the Claude Agent SDK are significantly simpler: they come with prompting and tools already built in, manage conversation history automatically, and support Skills and MCP servers as newer tool-building methods. An agent can be defined in a single TypeScript file, rather than writing separate RAG pipelines and database logic.

  Decision criteria between SDK and framework:

  • Choose SDK approach if only you use the agent, delays are acceptable, and no scaling is needed (faster start, less infrastructure).
  • Choose framework approach if multiple users work in production and speed/cost/full control are critical. SDKs are noticeably slower (due to built-in overhead), token-heavy, and computationally intensive. Moreover, SDKs may only be used for individual users with subscriptions per Terms of Service – with multiple users, you need API keys, which becomes extremely expensive. Frameworks like Pantic AI are more cost-effective in production.

  Skills and MCP servers are the modern ways to add tools to agents – faster and more reusable than directly defined tools.

  On the RAG question: Many say RAG is “dead,” but that’s too broad. Semantic search was standard in 2024; 2025 shows that file search (like grep) works better and is cheaper for smaller document sets – this is built into SDKs. But for large knowledge bases (thousands of documents), semantic search remains more precise and cheaper. Modern approaches use agentic RAG (combined search: semantic + keyword + graph, etc.), especially with large code bases. The author still uses semantic search in his own agents.

  Conclusion and recommendation: Match the tool to the use case – there’s no universal answer. Often it’s worth starting with the SDK to test quickly before migrating to a framework if needed.

  Claude Agent SDK, Codeex SDK, and Pantic AI were explicitly discussed; the perspective is opinion/reflection with practical decision framework.

• You’re Hardly Using What Claude Code Has to Offer, it’s Insane
  23.3.2026, 16:37:20

  Summary: Claude Code’s latest features

  Claude Code has delivered a dozen new features in recent months, evolving the tool from a pure autocomplete assistant into a multi-agent orchestration platform.

  1-million-token context: Sonnet and Opus now support one million tokens (approximately 750,000 words). However, starting around 250,000–300,000 tokens, hallucinations increase noticeably – therefore, memory compaction or a handoff prompt at the start of a new session is recommended.

  Agent Teams: Multiple agents work in parallel and communicate in real time with each other, for example to simultaneously conduct security, performance, and test coverage reviews. The feature is still experimental; agent-to-agent communication isn’t optimal yet, making it better suited for proof-of-concepts than production code.

  Git Worktrees: Enables parallel work on different feature branches with Claude in the same context by creating local copies in the .claude/worktrees folder – saves manual configuration and time.

  New commands: /simplify prevents over-engineering through automated codebase simplification; /batch orchestrates larger refactorings via parallel sub-agents (e.g., replacing all console logs with structured logging).

  Remote Control: Synchronizes sessions between desktop and phone – desktop work can be controlled from your phone.

  Sub-Agents expanded: Persistent memory at sub-agent level, hooks per agent instead of global, and AutoMemory (.claude/memory folder), which lets Claude learn from errors, while claude.md continues to provide full manual control.

  /btw and /loop: /btw generates side questions without context bloat (though without codebase tools); /loop schedules recurring prompts (e.g., check deployment status every 5 minutes or run tests every 30 minutes).

  Voice Support: Native speech-to-text via /voice, though external tools (Aqua Voice, Whisperflow, open-source alternatives) sometimes offer better quality and work everywhere.

  Effort Level: Control reasoning effort (low/medium/high, plus max for Opus) via /effort to balance token usage and problem-solving power.

  Scheduled Tasks: /loop for recurring in-session prompts; cron jobs for continuously running tasks (hourly tests, checking CI/CD pipelines, etc.), all manageable in natural language without cron syntax knowledge.

  The trend shows Claude Code as a growing multi-agent orchestration platform focused on parallel work, asynchronous coordination across devices, and autonomous learning – however, production deployments should still be cautious with experimental features.

  Claude Code demo with focus on agent-based orchestration and workflow automation; opinion/reflection.

Datapizza (1 new video)

• L’impatto dell’AI sulle professioni e sul mercato
  24.3.2026, 16:01:34

  Summary: L’impatto dell’AI sulle professioni e sul mercato

  The episode analyzes the economic and professional impacts of Generative AI based on two key sources: an Anthropic report on AI exposure risk for professions and a Goldman Sachs analysis of the macroeconomic effects of massive AI investments.

  Anthropic report on job exposure: The report introduces an exposure index that measures how strongly individual professions can be automated by AI – divided into complete automation versus AI-augmented work. Surprisingly, it’s not manual workers but highly skilled knowledge workers who are most exposed – programmers, for instance, at around 75%, followed by financial analysts, customer service representatives, and data entry specialists. Manual professions like trades, agriculture, and construction remain less affected so far, as they require physical presence. Crucially, the report emphasizes that 25% of programming tasks will remain human – those where people create value through decision-making, context, and creativity.

  Productivity paradox: Although companies invest over 100 billion dollars per quarter in AI infrastructure, Goldman Sachs shows these investments contributed virtually nothing to US GDP growth in 2025. This is partly because imported hardware (chips, servers) is counted as imports in statistics, and partly because productivity gains from AI are still in early stages. Historically, transformative technologies require years or decades for measurable effects – the so-called productivity paradox (Robert Solow). The electric motor example shows: 30 years with no visible advantage until companies restructured their production processes around the new technology (the “envelope” concept).

  Current adoption reality: NBR data shows: 90% of companies have yet to register significant effects on employment or productivity; 56% of organizations see neither revenue increases nor cost savings. Nevertheless, 66% of managers use AI in daily operations – but only about 1.5 hours per week. Paradoxically, investments continue to rise (252 billion dollars in 2024, planned to double by 2026) because longer-term potential is expected: Stanford data suggests 2.7% productivity improvement in 2025, with forecasts for another 1.4% by 2027.

  Implementation downsides: A UC Berkeley study shows that AI tools often intensify workload rather than relieve it – they increase task variety and remove natural work breaks. The reason: those already skilled at a task often hold themselves back when they need to “relearn” it with AI. Successful adoption requires genuine organizational redesign (as electrification only worked after factory restructuring) plus employee training – Citigroup made training mandatory for 175,000 employees.

  Report conclusion: AI disruption unfolds gradually and cumulatively, not as a shock – similar to internet diffusion. The transition from “testing tools” to genuine process integration and creation of AI-compatible business operations still lies ahead.

  Sources: Anthropic report, Goldman Sachs (via Washington Post), NBR, PWC Global CEO Survey, Forrester, Stanford AI Index, Boston Consulting Group, UC Berkeley Haas School of Business; philosophical perspective on “envelope” design by Luciano Floridi. Format: Deep-dive/roundup.

Greg Baugues

No new videos in this period.

AI and Strategy | Le SamourAI (2 new videos)

• +70% “Founders” on LinkedIn: The Fatal Mistake of an Entire Generation Facing AI
  27.3.2026, 16:00:42

  Summary: +70% “Founders” on LinkedIn – The fatal mistake of an entire generation in the face of AI

  The author analyzes a phenomenon: 70% more founder titles on LinkedIn this year – not from genuine opportunities, but from fleeing a collapsing job market. This is not a victory, but a structural trap.

  The core problem: AI lowers the barrier to entry for entrepreneurship (anyone can build an MVP over a weekend), but simultaneously destroys the learning conditions that let entrepreneurs survive at all. Juniors can no longer make their mistakes in employment, build industry expertise, forge their judgment – that was the “sandbox.” Instead, they’re thrown directly into the harsh entrepreneurial field while everyone else has the same AI weapon. Competition grinds down beginners without real domain expertise.

  The vicious cycle: Missing entry-level jobs → flight into freelancing/startup land → AI makes execution dirt cheap → nobody differentiates through code/content → failure because judgment, distribution, network are missing → even more pressure, even faster to launch.

  But that’s only one side. Intelligent tech giants (IBM, Shopify) are simultaneously tripling/decupling junior hiring – not for execution (AI does that), but as “AI-native” professionals: people who think of AI as a natural extension of thought (tools like Cursor, Claude, Perplexity), not as a utility. They become “orchestral conductors” of models – specify precisely, evaluate critically, bring context.

  Four kinds of judgment become central now:

  1. Delegation judgment: Should I give this to AI?
  2. Specification judgment: What exactly do I ask the AI?
  3. Evaluation judgment: Is this really good?
  4. Organizational judgment: Is this the right solution for this organization/moment? (Agents don’t see that)

  The strategic twist: The same forces pulling you down (missing jobs → pressure → startup without experience) can catapult you up – but with reversed entry point. Whoever understands how to train judgment can compress this curve exponentially: with AI you can run through scenarios in weeks that used to take years. Not by having the machine do your work, but by using it as simulation terrain.

  Warning against theatrical optics: Many large corporations (Deloitte, SaaS companies) rebadge old roles with new AI jargon (“vibe coding,” alpha-numeric level names). That’s cosmetics. The real line runs between organizations that think natively with AI and those stuck in legacy – the latter write their own obsolescence ticket.

  New trend on the horizon: Mistral “Forge” and hardware monitoring (Slack data, office cameras) convert internal corporate culture, power structures, communication patterns into proprietary AI models. The gray zone of data collection remains under-regulated through August 2026.

  Practical start: Every week, audit yourself: How much do you validate blindly from the machine vs. how much do you construct yourself? That’s your live learning debt ratio. Then take a repetitive task and treat it as a judgment exercise (delegate yes/no + why? → precise specification → real evaluation). Run the pattern 10x until the native thinking mode clicks.

  The core point: Entrepreneurship is not the escape solution (90% failure rate), but an option – only with real terrain judgment, not LinkedIn storytelling.

  Covered: AI in general (Claude, Cursor, Perplexity mentioned), IBM, Shopify, Mistral Forge, Deloitte; Format: Opinion/reflection, deep-dive into market mechanics and strategy.

• 40 million views in 12h: Claude “Computer Use” burying office work?
  24.3.2026, 17:11:59

  Claude “Computer Use” – Summary

  Anthropic demonstrated a new level with “Computer Use” in AI agents: instead of just making suggestions or working in isolation within apps, Claude can now directly control the screen – use mouse and keyboard, navigate between real applications, and orchestrate complex multi-step tasks. This differs fundamentally from previous levels: chatbots (2022) answered questions, copilots (2023) suggested code, orchestrators (early 2026) coordinated files between apps – now comes full execution without API integration, even in old legacy systems.

  The central tension lies not in features but in the architecture of the trust question: three models compete. The local, open model (Open Claw) promises maximum control but leads to security chaos (hundreds of malware plugins, remote code execution gaps). The cloud manager model (Perplexity) offers governance and audit logs but sends all data (emails, files, Slack) through external servers – compliance risk for regulated companies, $200/month. The OS-integrated model (Google Gemini, Microsoft Copilot) is smooth but locks you into an ecosystem. Claude takes a controversial middle ground: local execution, permission control with 30-minute timeout, but – critically – Claude continuously sends screenshots to Anthropic servers to steer the mouse. You get control over the action, not the data.

  Realistic limits: Claude Computer Use is still a research prototype (macOS only, Pro/Max subscriptions only, screen must be active). In 240 real test commands, full end-to-end automation worked in only 2.5% of cases; over 75% of complex office tasks fail. That’s not useless, but it calibrates expectations: usable for low-risk, moderately complex tasks (entering numbers from emails into Excel, compiling summaries), but not for sensitive data, compliance-critical processes, or enterprise deployment.

  Strategic shift: Whoever used to trade time for office deliverables (formatting, reporting, data extraction) loses the unique selling point – not because AI does the job, but because the decision-maker can steer the agent themselves. The premium shifts to the risk manager who knows what and how much can be delegated. Two watch signals: (1) Computer Use on Windows (70% of global market), (2) enterprise mode with audit logs and granular app control by mid-April. A third, speculative: “Phone Use” – agents on smartphones.

  Anthropic is building architecture, not isolated features: MCP protocol → custom skills → desktop app → cloud code → Cowork (January) → Dispatch (last week) → Computer Use (yesterday). Each building block strengthens the next. Startups betting on desktop automation become obsolete by a Monday evening update – a systemic problem in venture markets with AI.

  The invisible layer: Computer Use gives Claude access to the fourth data layer of companies – the implicit, what databases never capture (internal politics, emotional intelligence, micro-decisions, deleted files, hesitations in filling cells). Whoever controls the office agent cartographs real processes live – what consulting firms would cost months. On the job market: execution jobs lose, piloting and risk governance jobs emerge.

  Practical test: With Computer Use open the last client email, extract quarterly numbers, update Excel, create new bar chart – in one instruction, no copy-paste.

  Claude, Anthropic, Open Claw, Perplexity, Google Gemini, Microsoft Copilot covered – Opinion/reflection, deep-dive.

Julian Ivanov | AI Automation (1 new video)

• OpenClaw Beginner Course: All Concepts Explained Simply
  23.3.2026, 19:10:14

  OpenClaw Beginner Course: All Concepts Explained Simply

  The video systematically explains how OpenClaw works – an open-source agent system that, unlike ChatGPT, doesn’t run in a user interface but on a computer or server, creates files, executes programs, and proactively handles tasks in the background.

  Basics & Installation: OpenClaw is free (open source), but shouldn’t be installed on your personal main computer. Better: an old laptop, Mac Mini, or a cheap VPS (virtual server) from providers like Hetzner or Hostinger – so the agent runs 24/7 and stays cleanly separated from your private data.

  Costs & Models: OpenClaw needs an AI model in the background. Two ways: (1) API key with pay-per-use (tokens charged per action, can get expensive), or (2) OAuth via an existing subscription like ChatGPT Plus (~20€/month). OpenAI officially allows OAuth; Anthropic has blocked it; Google is a gray area. Important: OpenClaw consumes far more tokens than regular chatbots because the agent thinks in a loop, observes, acts, and sends its configuration files with every call.

  The Agent’s Brain (Core Files in the Workspace):

  • Soul.md: defines personality, behavioral rules, values
  • Identity.md: agent’s name, vibe, emoji
  • Agents.md: the operating manual with top-level instructions and boundaries
  • User.md: who you are (name, timezone, language, projects, preferences)
  • Tools.md: practical notes on tool connections
  • Memory.md & Daily Notes: long-term and daily memory of the agent

  The agent uses an Agentic Loop (Think-Observe-Act): a cycle of thinking, observing, and acting until a task is complete. A Context Engine orchestrates which information belongs in the context window and compresses old conversation parts – newer plugins like Lossless Claw build a knowledge graph instead of deleting messages.

  Communication & Multi-Agent Setup: The Gateway is the central interface. Every message comes in via a Channel (Telegram, WhatsApp, Slack, Discord, Signal, Teams, etc. – 20+ platforms), and the gateway routes it to the right agent. Each Session is a separate conversation thread; multiple sessions run independently in parallel. The gateway uses a Queue to process messages one by one.

  You can have multiple Agents in one gateway (e.g., Personal Assistant, Coding Agent, Sales Agent) – each has its own workspace and channel binding. A Subagent, on the other hand, is temporary: it’s spontaneously started by the main agent for a subtask, has its own context window, and returns the result without burdening the main agent (prevents context rot).

  Automation:

  • Heartbeat: The gateway wakes the agent every 30 minutes and checks via Heartbeat.md whether tasks are pending. Each heartbeat is an API call with token costs – use a cheaper model here.
  • Cron Jobs: scheduled tasks at fixed times (e.g., 7 AM briefing, Monday 9 AM security audit).

  Extensions:

  • Skills: Markdown files with concrete instructions for regular tasks (e.g., write blog articles in a specific format). Can include additional resources (PDFs, Python scripts). Skills are available in the Claw Hub community marketplace – check the security scan there.
  • MCP Server & CLI Tools: standards for integrating external tools; CLI tools are more token-efficient.
  • Plugins: complete packages of Skills + resources (e.g., Lossless Claw as a Context Engine plugin, or messaging platforms).
  • Nodes: devices you connect to OpenClaw (e.g., smart glasses, iPad) – experimental, roughly via Vision Claw.

  The video is accompanied by the gateway dashboard, where you create agents, configure channels, view core files, and manage Skills/Cron jobs.

  Note: No explicit transcript for the security section at the end; the video aims to show how to safely install OpenClaw on a server.

  OpenAI (via OAuth/API) and Anthropic (Claude, API key), Ollama Cloud, Open Router mentioned; tutorial with deep-dive sections.

Kyle Balmer | AI with Kyle (10 new videos)

• Your Website Probably Doesn’t Need SEO
  27.3.2026, 19:00:05

  The video covers two main topics: website creation with Claude and whether SEO is necessary for every website.

  Website creation with Claude:

  Claude can help with website creation. The simplest method is using the Claude Desktop App (available at claude.com/download), which includes Chat, Claude Cowork, and Claude Code – technically the terminal version is more powerful, but the app is more beginner-friendly. For a live website, you need hosting and a domain. A domain costs about $10 per year (e.g., via Namecheap), and hosting is free via Vercel (up to a certain popularity level, then $20/month) or Netlify. Other tools in the standard stack: GitHub, Supabase, Stripe for payments, Resend for transactional emails, Beehiiv for marketing emails, PostHog, and Google Analytics.

  SEO isn’t necessary for all websites:

  The speaker argues that SEO isn’t universally useful for every website. Websites with little content (e.g., pure landing pages or sales pages without blogs) are considered “thin sites” by Google and are hard to rank. By contrast, aiwithkyle.com with about 2.5 million words is a good SEO target. For many businesses, other channels work better – social media, paid advertising, or viral marketing. An example: A viral TikTok toy (a box with switches and a pop-up octopus) will never be found through Google search; here, social media and advertising are the relevant channels. Conclusion: SEO effort should be tied to actual business needs, not assumed as standard. At the end, the speaker mentions a newsletter with a checklist for SEO audits and implementation with Claude, plus briefly mentions that Claude and ChatGPT find different errors when reviewing each other’s code.

  The video explicitly mentions Claude (Desktop App and Code) and ChatGPT in comparison; other tools mentioned are Vercel, Netlify, Namecheap, GitHub, Supabase, Stripe, Resend, Beehiiv, PostHog, and Google Analytics — opinion/reflection with practical tips.

• Replace your SEO agency with AI (Full Guide)
  27.3.2026, 07:00:35

  Replace your SEO agency with AI (Full Guide)

  The creator shows how to replace SEO agencies with Claude AI and a free Skill called Claude SEO. Traditional agencies charge thousands of dollars per month for at least six months and often work as a black box – the Claude approach instead costs only the Claude Pro subscription ($20 monthly).

  The Claude SEO Skill (developed by Rishi Daniel, free on GitHub) automatically performs multiple analyses: technical SEO, on-page analysis, content quality (EEAT scoring), schema markup, image optimization, and AI-search optimization. Installation is simple via the Claude Desktop App – you copy the GitHub link and Claude installs the Skill. The audit runs automatically (taking several hours to overnight for large sites) and delivers granular breakdowns with keyword strategies, content gaps, and concrete action items.

  After the audit, you feed the findings into Claude Code to implement fixes automatically: generate meta tags, add schema markup, optimize content. The creator recommends automating these tasks with Scheduled Tasks – for example, processing 20 pages each night and delivering a report each morning. Advanced users: MCPs (Model Context Protocol) connect Claude directly to SEMrush, Google Search Console, Google Analytics, and PageSpeed Insights for live data into the audit.

  Warning: Not every website needs SEO. Landing pages or portfolio sites with little content see minimal benefit; social media and advertising are more efficient there. SEO is one channel among many, relevant only if people are actively searching for it.

  The talk covers Claude as the AI model, uses the free Claude SEO Skill, and mentions Claude Code and MCPs; it’s a tutorial with live Q&A format.

• Why Anthropic Is Winning the AI Agent Race Right Now
  26.3.2026, 19:00:27

  The creator analyzes why Anthropic is currently winning the AI agent race. He contextualizes this within four major AI breakthroughs: GPT-3.5 (proof of concept), GPT-4 (recognition of potential), reasoning models like o1 (more complex problem-solving), and finally in December 2024 agentic models – the turning point where AI no longer just answers but independently does things for us.

  The focus is on two competing systems: OpenClaw (originally Clawdbot), an open-source project that is very powerful but risky – it requires command-line knowledge, security hardening, and VM/VPS setup. There were horror stories (stolen API keys, deleted inboxes). Anthropic’s answer is Claude Cowork and Claude Code, which essentially offer the same functionality in a more controlled, safer environment – less power, but significantly more security. The addition of Computer Control (a Mac mini can be remotely controlled by Claude) brings these features closer to OpenClaw. The author sees Anthropic as the clear winner: They observe what makes OpenClaw popular, document the features, and implement them iteratively and publicly through their large engineering team. OpenAI, meanwhile, is working secretly with Peter Steinberger (OpenClaw’s creator) on a ChatGPT version. The problem: Building in secret prevents the direct user feedback that Anthropic gets through open shipping and Twitter dialogue – and that enables faster iteration and improvement.

  Topics covered: Claude/Anthropic, OpenClaw, OpenAI, with mentions of Perplexity Computer and Manus Agent as alternatives. — Opinion/reflection.

• AI Latest: OpenAI Shuts Down Sora, Disney Drops $1B Deal, Claude Does Your Job For You
  26.3.2026, 06:45:08

  Summary: AI Latest – OpenAI shuts down Sora, Disney deal, Claude takes your job

  OpenAI is shutting down Sora – the video generation app is being completely shut down, including the API. The reason: Sora was too expensive, adoption was too low after the initial hype of one to two weeks, and Chinese competing models are better and cheaper. OpenAI staff internally received word from Fidji Simo that the company can’t be distracted by “side quests” while Anthropic is gaining strength in the enterprise and coding markets. This points to restructuring – OpenAI is focusing on what makes money.

  The real reason: Business model shift. OpenAI earns mainly through consumer subscriptions ($20/month, over $5B revenue), while Anthropic focuses on API revenue from enterprises. Anthropic has achieved similar or higher revenue than OpenAI with 30–40 million users compared to OpenAI’s 900 million, but with far better profitability. OpenAI is drawing the conclusion: away from toy features like Sora, toward stable, profitable API business and coding applications.

  Disney deal falls through: Disney’s $1 billion investment in OpenAI is dead because it was tied to Sora. Disney wanted to release characters (Marvel, Star Wars, Pixar) for user-generated videos in Sora, possibly integrated into Disney+. That was strategically smart for Disney: Young audiences no longer watch feature films; they watch short-form video. Instead, Google will likely now have talks with Disney, as it’s the best candidate for a video-gen partner. Apple has the connection (Pixar ownership) but no models for it. Disney will probably cut a deal with Google while continuing legal threats against Chinese platforms.

  Legal situation: Studios (Disney, Warner, NBC Universal) are suing Midjourney and others; Disney sent cease-and-desist letters to Meta and Character AI. The pattern: Old media companies will lose the ban, just like with text content (New York Times and Reddit all trained models), but eventually make licensing deals with AI labs – with Anthropic, OpenAI, Google. China is not an option for Disney.

  OpenAI pivot visible: Shopping feature (Instant Checkout) is being wound down because it didn’t work. Apps in the ChatGPT Store are also being deprioritized. Everywhere, supposedly cool features are being removed.

  Anthropic vs. OpenAI – shipping comparison (last 2 months 2026): Anthropic released: Claude Cowork (Jan), code features, memory, marketplace, ambassadors, Excel/Slides skills, 1-million-token context window, Dispatch for mobile, Channels (Slack/Discord integration), Cloud computer use (yesterday). OpenAI: Search bar in ChatGPT, screenshot library, Codex for students with $100 credits. The divergence is radical – Anthropic is in shipping mode, OpenAI appears paralyzed by IPO focus.

  Claude Cowork vs. Open Claw: Open Claw (decentralized agentic project) was the game-changer in December 2025, but risky (shell access, security, inbox wipes). Cowork is the safer, managed approach (more limited power, more security). Computer Use (new) brings Cowork closer to Open Claw capabilities while remaining sandboxed.

  Consumer vs. API revenue: OpenAI pays massive infrastructure costs for 900M users with low margins; consumer subscriptions collapse easily during controversies (Pentagon deal: 3–4M people switched to Anthropic). Anthropic intentionally unattractive for the $20/month tier – goal is API and higher tiers ($100–$200/month). This explains the double-usage promo (welcome carpet for new users) and investment in agentic tools.

  Edge AI & hardware bottlenecks: RAM and GPUs are being bought up by AI labs; PlayStation 5 is more expensive than at launch (historically unprecedented). This throttles local AI hardware. China open-sourced models instead of paid API, stabilizing the developing world – soft power strategy against US labs.

  Tools in detail: Cursor is in an awkward middle position between Lovable (beginner-friendly, free) and Claude Code Desktop (powerful, $100–$200); Cursor could be squeezed out. Vibe Coding is the recommended entry point.

  The video provides substance on OpenAI restructuring, Anthropic dominance, Disney strategy, and the market’s shift from consumer toys to B2B API profitability — not a superficial overview.

  Explicitly discussed: OpenAI, Claude / Anthropic, Cursor, Lovable, Google Gemini, Open Claw, Midjourney, Chinese models — Roundup/news update format.

• Claude Computer Use Just Changed Everything
  25.3.2026, 18:45:00

  Claude has enabled Computer Use – a feature that lets the AI model access your computer and execute tasks. The feature is only available in the Claude Desktop App (not on claude.ai), is enabled via Settings > General > Computer Use, and works as a fallback mechanism: Claude first tries to work through a connector, then through the browser, and finally through direct screen control. Setup is much simpler than OpenAI’s O1, requires no terminal knowledge, and is seamlessly integrated.

  It becomes particularly powerful through remote access: You can control your always-running local computer (e.g., a Mac Mini) from anywhere by sending instructions via Dispatch, Claude Code, or Channels (Slack, Telegram, Discord integration). For example, Claude could grab files from your desktop and upload them to Google Drive while you’re on the go.

  Anthropic is running multiple tools in parallel (Cowork, Claude Code, Dispatch, Remote Control, Channels) but plans to unify this fragmented structure mid-term. Currently, Claude competes with OpenClaw (open source, free, but requires API connection and local LLM setup – developed by Peter, now at OpenAI), Perplexity Computer ($200/month, criticized as slower and less capable), and Meta’s Llama with Agent Mode. The takeaway: Claude wins through weekly feature releases, integration with its strongest models (Opus 4.6, Sonnet 4.6), and a closed ecosystem – so why pay more for Perplexity?

  Claude (Computer Use, Claude Code, Cowork), OpenAI (O1), OpenClaw, Perplexity, Meta/Llama — opinion/critique with comparison.

• Claude Can Now Control Your Entire Computer (FULL Explainer)
  25.3.2026, 05:00:18

  Claude can now control your entire computer – Summary

  Anthropic released a new feature yesterday that lets Claude take over your computer – called Computer Use. This is a significant shift: While we used to only ask AI for information and manually insert the results elsewhere, agentic systems can now independently execute tasks. Claude Computer Use opens apps, navigates the browser, fills out spreadsheets, and can directly access the desktop on Mac – initially Mac only, with Windows coming in a few weeks.

  The functionality works in a hierarchy: Claude first tries to work through direct connectors (APIs, MCPs) like Gmail, Slack, or Excel – that’s fastest. If that’s not possible, it uses the Chrome extension and navigates the browser. As a fallback, it then directly controls your screen, takes screenshots/videos, and clicks around – but that’s significantly slower.

  Anthropic has moved at a rapid pace over the last three months: Claude Opus and Sonnet 4.6, PowerPoint/Excel integration, Claude Code with security checks, remote control via phone, scheduled tasks, memory, marketplace, Dispatch (phone access to Cowork), Channels (Slack/Telegram integration), and now Computer Use. The constantly growing ecosystem lets you send instructions to your computer from anywhere – via the desktop app or through Dispatch/remote control/Channels.

  To set up: Download the Claude Desktop App, log into your account, go to Settings → General → Computer Use and enable it. That’s it – no terminal setup like with OpenClaw. Important: Computer Use requires the Max plan tier but runs significantly safer than OpenClaw with built-in safeguards (permissions per app, prompt-injection scanning, blocking of crypto apps and sensitive data).

  OpenClaw previously proved demand for autonomous assistants – but it was too technical (terminal, API keys, possibly dedicated hardware) and had security issues. Claude Computer Use democratizes this functionality. However, there remains a risk since the system runs on your main computer. Security recommendation: Don’t give it access to banking, finance, legal documents, or customer data; wait a few weeks until initial vulnerabilities are patched.

  Competitors like Perplexity Computer ($200/month) or Manus Agent look surpassed by Anthropic’s pace. The overarching trend since December 2025: AI moves from “chatting” to “doing” – systems are now good enough to do real work. That lowers the barriers for anyone wanting to build.

  Format & Tools: Deep dive into Claude (Anthropic) with practical demo and overview of the entire ecosystem, including comparison to OpenClaw, Perplexity, and Manus.

• What Tools Do You Actually Need to Sell Online?
  24.3.2026, 23:00:41

  Payment processing: For payments, the creator recommends Stripe as the standard payment processor (3% fee per transaction), but also mentions alternatives like Paddle, Lemon Squeezy, and Braintree. For more complex sales scenarios – order bumps, subscriptions, crypto payments, affiliate sales, coupons, invoice downloads, payment installments via Klarna – he uses Thrive Cart himself (roughly $500 one-time), which builds on Stripe and offers significantly more e-commerce functionality than pure Stripe with its complex technical requirements.

  Email systems: Here a distinction is made between two categories. For transactional emails (purchase confirmations, password resets, invoices), the creator uses Resend, which integrates into the application and connects via Claude, Lovable, or other coding tools. For marketing and content emails, he recommends Beehiiv (free up to 2,500 subscribers, then tiered starting at $60/month; he pays around $300/month for roughly 45,000 subscribers). As an alternative for pure newsletters, he mentions Substack. Both services require validating your own domain via DNS records in Namecheap, which is technically complex the first time but feels easier with repetition.

  Conclusion: The creator argues that repeatedly setting up this infrastructure increases success chances – anyone starting multiple businesses becomes more practiced with each one.

  Topics: Stripe, Thrive Cart, Resend, Beehiiv, Substack, Namecheap, Claude, Lovable; format: opinion/reflection with practical recommendations.

• So you’ve Vibe Coded something brilliant — Now what?
  24.3.2026, 13:33:19

  Summary: So you’ve Vibe Coded something brilliant — Now what?

  The speaker presents a complete tech stack for scaling vibe-coded applications from proof-of-concept to commercial deployment. He structures the guide around progressively layered tools:

  Ideation & coding: Lovable (paid from ~$20/month), Google AI Studio Build Mode (free), or Claude Code/Codex (for technical users, Claude Code $200/month).

  Version control & storage: GitHub stores code centrally and enables branching for safe development parallel to the live version; free up to large user bases.

  Database & authentication: Supabase manages user data securely, free up to 50,000 monthly active users or 500 MB data transfer, then $25/month.

  Hosting & domain: Vercel hosts the application (free initially, typically $20/month), domain from Namecheap (~$10/year).

  Payment processing: Stripe (free setup, 3% transaction fee); optionally Thrive Cart (~$500 one-time) for advanced features like subscriptions, affiliate sales, and tax automation.

  Emails: Resend for transactional emails (confirmations, invoices) and Beehiiv for marketing/newsletter emails (free up to 2,500 subscribers, then ~$60/month).

  Analytics: PostHog (free) for user tracking and experiments; recently added AI-powered data analysis.

  The speaker emphasizes that startup costs are near zero and only accumulate once you have significant traffic – by that point, the business should already be profitable. He warns against the common mistake of buying many domains and recommends using a prompt in Claude or ChatGPT to get a structured step-by-step plan. Discussion also covers Claude Code vs. Open Claw (the latter rated less secure), options for free/nonprofit projects (via donations or GitHub Pages), and the rapid development pace of the AI ecosystem.

  Video format: Opinion/reflection with practical deep dive into a specific toolkit — intermediate difficulty for vibe coders with basic technical understanding.

• Why Both OpenAI and Anthropic Are Giving Up on You
  23.3.2026, 19:00:01

  Summary:

  Both OpenAI and Anthropic are strategically not focused on individual consumers but on B2B and enterprise customers plus API usage – that’s the sustainable revenue source. Users switching from ChatGPT to Claude face usage limits: Claude Pro ($20/month) offers only a few interactions with Opus, while Claude Max ($100/month) is meant as a compromise but feels significantly more expensive. Anthropic makes almost nothing from consumer subscriptions (under $1 billion), while their API revenue exceeds OpenAI’s. Individual users cost Anthropic more than they bring in – that’s why the company doesn’t care about them. OpenAI, by contrast, faces a different problem: 900 million free users with enormous operating costs lead to losses, which is why they’re adding ads and now also pushing toward enterprise and API. This means: ChatGPT will become more consumer-hostile, with more ads and likely more restrictive usage limits. Anthropic stays focused on coding and text processing and ignores video, images, or apps – precisely because that’s not profitable. User complaints will become more frequent, but both companies will ignore them.

  Explicit tools/providers: OpenAI, Anthropic, Claude (including Opus and Max), ChatGPT; also mentions Nano Banana, Grok. — Opinion/reflection.

• Massive Global Study: 81,000 people CONFESSED what they really want from AI
  23.3.2026, 07:30:02

  Anthropic conducted a study with 80,508 interviews – the largest multilingual qualitative study of its kind with participants from 159 countries in 70 languages. Interviews were conducted using Claude, Anthropic’s own AI interviewer tool. Respondents were Claude users asked about their wishes and experiences with AI.

  What people want from AI:

  Top categories are professional excellence (18.8% – using AI to automate routine tasks and focus on strategic work), personal transformation (13.7% – coaching, emotional wellbeing, guidance), entrepreneurship (8.7%), and technical accessibility (9% – AI helps people with learning disabilities or physical limitations). 81% of respondents said AI helped them with their goals; 19% say AI didn’t meet expectations (unreliability, hallucinations).

  Concerns:

  Top worries are unreliability (26.7%), job loss (especially in western countries), autonomy loss through over-reliance (16%), and loss of control/existential risks (6.7%). Only 11% expressed no concerns. Interestingly, geography shows a pattern: In sub-Saharan Africa and Latin America, people are more optimistic (only 24% negative), while in North America 35% are negative – AI is seen as an opportunity multiplier in less developed countries, more as a risk in wealthy nations.

  New Claude features:

  Anthropic is gradually building features similar to OpenClaw: persistent memory, Claude Workspace (file access, automation), and new “Dispatch” – enabling remote commands to an always-on computer via phone/laptop. That’s a more accessible, safer alternative to OpenClaw, with small tradeoffs in control.

  Business model shift:

  Anthropic focuses on API and enterprise revenue, not consumer subscriptions. This explains why Claude Max sits at $100/month and consumer plans have strict usage limits – individual users are uneconomical for Anthropic. OpenAI faces the opposite problem: Their 900M free users cost them money, so they’re adding ads and shifting focus to B2B API business. Result: Both providers will become more consumer-unfriendly.

  Tools/models: Claude (Anthropic), OpenClaw comparison, OpenAI / ChatGPT mentioned — Format: News update/deep dive with opinion.

Leon van Zyl (2 new videos)

• Building Beautiful UIs in Minutes with Claude Code and Stitch
  26.3.2026, 13:01:17

  Summary: Building Beautiful UIs in Minutes with Claude Code and Stitch

  The video showcases the integration of Google Stitch – an AI-powered UI design tool – with Claude Code for rapidly building web applications.

  What is Stitch and why it’s better than previous approaches:

  Stitch is Google’s free design tool that works with Gemini models and is user-friendly: you select device type (mobile/web), can provide reference images or URLs, choose color schemes and models, click “Generate” and instantly get a design system (with primary and secondary colors, typography, border radius, etc.) plus generated UI screens in real-time. The advantage over using the Front-End Design Skill in Claude Code: you maintain control over the design system, iterate quickly without touching code, and can test designs before implementation – similar to the classic design process with tools like Figma.

  Claude Code + Stitch Integration:

  The Stitch MCP (Model Context Protocol) is installed into the Cloud Code project via a command (with optional switching from user to project scope). After adding an API key from Stitch Settings, Claude Code can use all Stitch functions: create projects, generate screens, manage design systems.

  Workflow in Detail:

  1. Claude Code creates a new Stitch project via prompt (e.g., “CloudFit” – AI fitness tracker with coaching) with landing and additional pages.
  2. The generated design system is downloaded to a docs/design-system folder and documented as reference in claude.md.
  3. A Sub-Agent is created as “UI Expert” to oversee design system compliance and fix inconsistencies.
  4. Claude implements the design system in the project: fonts, dependencies, CSS variables, reusable components.
  5. Claude exports the Stitch pages as HTML and converts them to Next.js pages – important tip: explicitly request via prompt that HTML be downloaded (not just screenshots) to correctly capture animations and metadata.
  6. If needed: images from Stitch are downloaded to the public folder and used in the app.

  The resulting output is a fully functional Next.js app with all animations that exactly matches the Stitch design – without manual code writing for UI details.

  Claude Code + Google Stitch (via Stitch MCP) — Demo/Tutorial

• Claude Code Skills Changed Everything (And Nobody Noticed)
  24.3.2026, 13:26:45

  Claude Agent Skills – Overview of new features

  Recent changes to Agent Skills in Claude Code have brought significant improvements that many users have overlooked. Skills can now run in isolated contexts (fork mode), which prevents context window contamination with large skill files. Also new is dynamic context injection – before execution, shell commands can automatically inject project data (file structure, dependencies, git history) into the skill, rather than the agent having to manually explore this.

  The Skill Creator Skill has been massively expanded: it not only creates skills automatically but also runs tests and offers blind A/B testing to measure whether a skill actually makes a difference or if the base model can now handle the task natively. Anthropic distinguishes two skill types: Capability Uplift (new abilities like image generation or improved frontend design) and Encoded Preferences (specific workflows an agent should follow).

  Practical: Skills can be called like custom commands with /, and both concepts have now merged. For long-running skills, using Subagents in the background (background: true) is recommended, allowing the main agent to work in parallel. Skills are installed via skills.sh or directly through the Marketplace in Cloud Code and other GENI tools (Cursor, Open Code). The evaluation features allow you to scientifically verify the value of skills – particularly important since future models might make built skills obsolete.

  Claude (Anthropic) and Tools: Cloud Code, Cursor, Open Code, Airtop Skill (Sponsor), Skill Creator Skill – Deep-Dive Tutorial with practical demos.

Liam Ottley

No new videos during this period.

Mark Kashef (3 new videos)

• You’ve Been Using Claude Code at 10%. Here’s the Rest.
  27.3.2026, 22:00:27

  Summary: You’ve Been Using Claude Code at 10%. Here’s the Rest.

  The video covers the .claude folder structure in Claude Code, which most users ignore but can fully configure. There are two .claude directories: one at the project level (with rules, commands, skills, and agents for specific projects) and one in the home directory (with personal preferences and session memory as global settings).

  Main components:

  CloudMD file: Functions as “air-traffic control” rather than an encyclopedia – should be brief and concise (around 50 lines) and contain only router information. There’s a shared version (project-level) and a local .local variant for personal settings that shouldn’t go into the repository. By moving detailed rules to separate Markdown files, the CloudMD stays lean.

  Commands: Files in the commands folder become directly available as slash commands. They can contain placeholders ($) to accept arguments (e.g., latest or specific IDs).

  Skills: Unlike commands, skills are “always watching” – they have trigger words in their descriptions and are automatically activated when Claude detects those words in conversations. You can disable skills with disable-mod-invocation: true or run them in their own context with context: fork.

  Agents (Sub-Agents): Specialized agents protect the context window. They can use different models (e.g., Sonnet for transcript analysis to save costs) and be configured with specific requirements.

  Rules and settings: Rules files keep formatting requirements centralized. Settings.json controls permissions – either in YOLO mode (everything allowed), with manual approval, or in the new “Auto-Mode,” where the AI decides what should be allowed or denied. Hooks can also be added to the settings file (pre-tool-use, post-tool-use) that run before/after tool execution.

  Practical example: A project called “Meeting Flow” uses a slash command (/process meeting latest) that automatically triggers skills (action tracker, auto follow-up), which then apply rules (email formatting, action item structure) and save everything to a database.

  Bash commands for navigation: ls ~/.claude or ls .claude shows contents; cat .claude/commandMD displays file contents; wc -l claudeMD counts lines; head -15 .claude/rules/[file] shows snippets.

  The video emphasizes iteration – well-maintained rules are refined daily to make the system self-improving.

  Explicitly mentioned: Claude (Claude Code), Fireflies API, Resend API, Supabase as external database. Format: Deep-dive.

• You’ve Never Made a Claude Code Skill Like This
  23.3.2026, 18:00:50

  Summary: Video-based skill creation for Claude Code

  The creator presents a method for skill creation in Claude Code based on screen recording: instead of having to manually document a standard operating procedure (SOP), you record your own process when performing a task and send the video to a language model with video understanding – here Gemini – which automatically extracts implicit details, nuances, and tacit knowledge from video, cursor movements, and speech. These details are critical for high-quality skills since they typically don’t appear in written documentation.

  The concrete workflow: (1) Record a screen video (5–30 minutes); (2) install the free Gemini video understanding skill from the Google GitHub repo in Claude Code (requires Gemini API key from ai.google.dev); (3) upload the video file in Claude Code and request a detailed SOP – Gemini extracts phases, decision criteria, and nuances; (4) ask the skill creator skill to plan and generate a productive skill using this SOP, using ask-user-input tools for decision points (e.g., scope, human-in-the-loop frequency); (5) review the plan, then generate and test in a new Claude Code session with confirmed skill installation.

  In the example, a content repurposing workflow is demonstrated (YouTube transcript to LinkedIn and X posts): the video shows how the creator guides Claude to adapt different writing styles (Boris Churnney, Ethan Mollik) and incorporate personal preferences (casual-direct rather than relatable; no hashtags). Gemini extracts these visual and verbal cues from the recording, and the resulting skill then uses multiple-choice popups to guide the user through the repurposing pipeline – with minimal, targeted decision points.

  Practical tips: Compress videos with Claude Code before upload (Python) to reduce API costs; restart sessions after skill installation so the skill gets injected; store skill files in organized folders (e.g., .cloud/skills/); verify skill structure with a “guide agent” before using in new sessions – and then use the exact name when calling to maximize invocation reliability.

  Featured tools: Gemini (video understanding API), Claude Code (skill installation and execution), Loom (recording tool), Ask User Input (Claude Code feature for multiple-choice dialogs).

  Format: Tutorial/demo – shows workflow with concrete use case.

• Anthropic’s NEW Claude Architect Guide In 39 Minutes
  22.3.2026, 15:01:33

  Anthropic’s Claude Certified Architect Guide – Summary

  Anthropic has released a new certification program called “Claude Certified Architect” with a binding exam format. The 40-page official exam guide covers five core domains needed to build productive agent systems.

  The five domains and their weighting:

  Agentic Architecture (27%) – The core: the agentic loop (request → Claude response → check stop reason → tool execution or end). Crucially, check the stop-reason field, don’t search textually for “done.” For complex tasks, main agents can coordinate subagents working in isolated contexts and summarize results. A common mistake: scoping coordinator tasks too narrowly rather than broadly.

  Tool & MCP Integration (18%) – MCP servers connect Claude to external systems (databases, APIs, file systems). The most common reason for incorrect tool calls: ambiguous tool descriptions. Clear, precise descriptions are the highest leverage. MCPs exist at the project level (mcp.json with environment variables) and user level (sandbox in home directory). Best practice: use native MCP servers from platforms, custom servers only when truly needed.

  Claude Code Configuration (20%) – CloudMD files should be organized in three layers: user level (personal preferences), project level (team rules, architecture decisions, shareable via Git), path-specific rules (in .claude-rules folder, load only for specific file types). This prevents unnecessary token waste. Commands are slash triggers (personal or team-wide), skills are standalone contexts for exploratory work. Plan mode for ambiguous tasks affecting multiple files; direct execution for simple single-file fixes.

  Prompt Engineering (18%) – Not lengthy text instructions, but use few-shot examples: 2-3 concrete input-output pairs teach Claude the pattern better than long guidelines. Consistent outputs require structure, not creativity.

  Context Management & Reliability (17%) – Claude reads the beginning and end of context well, the middle becomes fuzzy (“Lost in the Middle”). Solutions: pin key facts at the top, trim verbose tool outputs, use subagents for isolated messiness. Separate sessions for code review (fresh eyes) vs. code writing. Execute human handoff on request immediately, don’t try to overcome it. On errors, always pass complete error packages (what, attempted, partial results, next options).

  Central enforcement concepts:

  Prompts vs. hooks: prompts are “best effort” (≈99%), hooks are physical barriers (100%). Hooks for compliance, finance, security; prompts for style, tone, format. Avoid tool overload: max 4-5 tools per agent with clear relevance. Tool-choice modes: auto (Claude decides), any (Claude must use a tool), forced (specific tool enforced).

  The five golden rules to take away:

  1. For 100% requirements (money, security, legal): use hooks, not prompt-based.
  2. Describe errors completely: what broke, what was attempted, partial results, alternatives.
  3. Keep agents focused: max 4-5 relevant tools.
  4. Review code in separate session (no writer bias).
  5. Use 2-3 concrete examples for consistent output; Claude learns patterns, not format.

  The guide is supplemented with interactive prompts for self-assessment in each domain (available on X).

  Explicitly mentioned tools/models: Claude (Anthropic), Claude Code, MCP servers (GitHub, Gmail, Google Calendar, Canva, Zapier mentioned), skills, commands, plan mode, hooks. Format: Deep-dive tutorial with detailed walkthrough of the certification guide.

Matt Pocock (2 new videos)

• Never Trust An LLM
  27.3.2026, 18:02:47

  Summary: Never Trust An LLM

  LLMs hallucinate constantly – they invent facts that don’t exist or ignore context explicitly provided to them. The phenomenon has been systematically categorized: factual errors (e.g., Google’s Bard ad falsely claimed that the James Webb Space Telescope was the first to capture images of exoplanets), invented entities (e.g., non-existent software packages – a supply chain security risk for developers), and contextual inconsistencies (e.g., the Air Canada chatbot ignored its implemented refund policy and invented a false 90-day deadline).

  Why LLMs hallucinate: Training compresses massive amounts of data into a smaller model – comparable to extreme image compression, where details are lost. The LLM sees only a blurry, hyper-compressed version of the original information. Yet it’s trained and evaluated to answer questions rather than admit uncertainty: benchmarks reward guessing over refusal, because a model that frequently says “I don’t know” performs poorly on performance tests. Like intelligent people under exam pressure, there’s an inherent trade-off between safety (refusal) and accuracy in difficult cases.

  Practical countermeasures: Use LLMs with intrinsic information – data you bring into the conversation yourself. LLMs are reliable at analyzing code, documents, or context you provide. If extrinsic information is needed, use the prompt “Use your search tool” to get the model to search the web and integrate sources into its context. For critical decisions (health, legal, financial matters), you then need to verify the researched documents yourself – even if the LLM answers confidently.

  Explicitly addressed were LLMs generally (with examples from Google’s Bard, Claude/Anthropic, and ChatGPT); the opinion is grounded in academic papers on hallucinations and their origins – opinion/reflection with practical insights.

• Claude Code tried to improve /init… Is it any better?
  23.3.2026, 15:02:28

  The video creator tests the revised version of Claude’s init command, based on community feedback. Previously, he had criticized init for generating overly large and bloated Claude.md files, and suggested using progressive disclosure and skill suggestions.

  The new version works more interactively: it first asks whether to create a project Claude.md, a personal one, or both, then whether skills and hooks make sense. Claude then explores the codebase and makes concrete suggestions – in this case, a format-on-edit hook for Prettier and a verify skill for type-checking and tests.

  The critic works through the suggestions constructively: on redundant entries (e.g., npm run type-check instead of npx tsc), he argues that hooks already enforce this. On useEffect reducer vs. React’s useReducer, he agrees since this is a common source of errors. He rejects integration test patterns since these become visible through exploration anyway. For rare effect package installations, he suggests isolating it in a specific skill rather than putting it in Claude.md.

  In the end, a minimally populated Claude.md emerges (practically empty) along with a specialized skill for Effect packages. The creator criticizes that Claude seems too servile and doesn’t push back enough against his arguments. Still, he rates the new init version as a significant improvement – it asks questions, suggests things proactively, and no longer automatically generates huge files like before. He recommends testing the version and providing community feedback.

  Format & tools: Demo of Claude Code’s init command with critical analysis and constructive feedback to the Claude team.

Melvynx (5 new videos)

• Claude Code veut remplacer OpenClaw : LEUR NOUVEAU TOOLS
  29.3.2026, 08:00:35

  The video compares Claude’s new Dispatch feature with OpenClaw and explains why the claim that Dispatch would replace OpenClaw is unfounded.

  Claude’s Dispatch allows you to perform actions on a remote computer from a mobile device – such as opening files, controlling the browser, or browsing folders. You connect via QR code and can then send commands to the PC via chat; the system requests approval before actions.

  OpenClaw, on the other hand, is a completely different concept: it’s an autonomous agent running on a VPS (virtual server) – not on your local computer – making it constantly available even when your own computer is offline. OpenClaw receives full access and installation rights, can develop its own skills, and build its workspace repository like a living system. The creator shows concrete examples: OpenClaw can perform complex multi-step tasks like downloading a video from a tweet, transcription, image extraction, and detailed analysis – sometimes through automatic tool installation. Dispatch, by contrast, is much more limited and designed for simple tasks on a local device.

  A second update: Claude’s new Auto-Mode allows the model to make changes autonomously without asking first; dangerous actions are blocked by a classifier while safe ones are allowed through. This feature is currently available in “Research Preview” – a label that allows providers to call experimental features and bear less liability.

  The creator emphasizes that Dispatch is a “tool for Normies,” while OpenClaw is intended for power users who want real autonomy and scalability, including building permanent agent intelligence with its own memory structure.

  Claude (Anthropic) and its new features (Dispatch, Auto-Mode); comparison to OpenClaw – opinion/reflection.

• PERSONNE ne comprend OpenClaw : voici le VRAI usage que j’en fais
  26.3.2026, 17:24:23

  Summary: PERSONNE ne comprend OpenClaw – Real use cases

  The creator showcases concrete OpenClaw (Open Interpreter) use cases that go far beyond simple chatting. OpenClaw has become his primary daily application – used more intensively than most tools.

  Business Automation:

  OpenClaw manages autonomous agents for handling sponsor emails (Steve), support responses, and code deployments. The agent responds in his writing style trained on requests, checks price quotes, and can ask for approval via Telegram before executing critical actions like refunds. For newsletters and campaigns, he uses MCP integrations (Model Context Protocol) with his email platform and other services like Dub.sh and Codeline to create coupons or landing page links – all in natural language flow.

  Personal Assistance with Threading:

  Through system threads with custom personality rules, OpenClaw acts as a coach (motivating), love advisor (storing dating interactions), doctor (with complete medical history), and general chatbot. These threads can communicate with each other and proactively build or via cron job (2x daily) memory – OpenClaw independently updates a situation.md with location, current tasks, and priorities.

  Security & Cost Control:

  With Claude Code Max subscription ($200), he consumes many tokens (up to 100% weekly). Important: don’t just use OpenClaw, but mix other models too (e.g., 50/50) to avoid anomaly detection. OpenClaw doesn’t support token caching like Claude, making complex tasks more expensive. The best protection against prompt injection is using Opus, which recognizes untrusted inputs; weaker models are more vulnerable.

  Core principles for success: Grant high permissions (access to many business tools like Gmail, Stripe, APIs), demand autonomous execution rather than explicit instructions, experiment and be creative – the magic happens when OpenClaw intelligently connects multiple services to realize complex workflows.

  Reference: Free mini training available at mlv.sh/foation with setup scripts.

  Claude (Anthropic) was explicitly featured, as well as OpenClaw (Open Interpreter) as the main tool with MCP integrations and agent architecture – opinion/reflection + deep-dive with practical demos, aimed at more advanced users.

• Claude Code fonctionne 100x mieux via cette application
  24.3.2026, 17:00:43

  Claude Code works 100x better through this application

  The video creator presents two tools that have revolutionized his way of working with Claude Code.

  Semux (Terminal Application):

  The main tool is Semux, a terminal for macOS that makes Claude Code significantly more practical. Semux offers multi-level tab navigation: the first level has terminal tabs for different projects, the second level has horizontal tabs within a project. Within these tabs, multiple terminals can run in parallel and be split horizontally or vertically. Navigation works through keyboard shortcuts (e.g., Control+1, Control+2, Command for tab switching). The tool also displays useful information like the status of running ports, GitHub branches, open pull requests, and notifications from Claude Code. You can add custom commands (like “crab review” for code reviews by multiple agents). The advantage over alternatives like Conductor is that Semux is just a terminal wrapper – it offers complete freedom instead of predefined workflows. You decide which agents, servers, and libraries to use.

  Helium (Web Browser):

  The second recommended tool is Helium, a minimalist, lightweight browser as an alternative to Arc. Helium skips unnecessary features, uses Chrome as its engine, offers a clean interface with tab pinning and bookmarks, and works reliably without AI gimmicks or tracking.

  The central thesis: a simple terminal with good tab management plus a lean browser = the perfect setup for productive Claude Code work.

  Claude Code explicitly mentioned as an AI tool, demo format with personal recommendation.

• SKILLATON à San Francisco : va-t-on réussir à gagner 1 000 $ à San Francisco (c’est galère…)
  23.3.2026, 17:15:06

  Summary: Skillaton in San Francisco

  The vlogger documents his daily life during a “Skillaton” event – a hackathon around the topic of “Skills” for AI agents – in San Francisco. He first shows his work mode: offering developer training, publishing YouTube videos and tweets, and code development with Claude. After working out and preparing, he visits a French café ($33 for eggs Benedict), then participates in a skill ideation event where his team, together with Laurent Tavernier, conceives the project “API to CLI” – a tool for converting any API into a command-line interface with a marketplace.

  The team uses exclusively Claude (as a web and app agent) for development without opening an IDE – they create documentation, a CLI tool, and skills within an hour. Despite the scope of the project (“over $1000 in token costs if paid”), the project “Skill Link” ultimately wins the competition. The vlogger is confident nonetheless in launching his project.

  He then presents his “High Builder” course (€700) with live session, visits Golden Gate Beach with spontaneous volleyball with beachgoers, discovers local shops with organic products ($32 salad), and reflects on the open social behavior and culture in San Francisco as an expat city full of events, talent, and constant activity.

  Format: Demo/vlog with opinion; Tools: Claude (explicitly mentioned as the main AI agent for skill development).

• ARRÊTE LES MCP : Voici ce qu’il faut utiliser MAINTENANT
  22.3.2026, 17:10:00

  Summary: “ARRÊTE LES MCP : Voici ce qu’il faut utiliser MAINTENANT”

  The author argues that MCPs (Model Context Protocol) are obsolete and should be replaced by CLIs (Command Line Interfaces) with Skills.

  The core problem with MCPs: They permanently inject all available tool descriptions into the model’s context, even if those tools aren’t being used. That wastes context window. Anthropic’s previous solution – a generic “MCP Search” tool – results in the model not knowing the available tools and therefore not using them.

  The new solution – Skills + CLI: Instead of MCP servers, you now use Skills that are only loaded when needed. The difference: a Skill is just a description (e.g., 160 lines) that is only downloaded when the agent needs it. Behind it lies a CLI that the agent calls – Bash is the universal interface.

  Practical advantages:

  • CLIs load context-dependently and save context
  • Bash is reliable and universally applicable
  • The model can work more precisely with Bash pipelines (e.g., head 150 instead of outputting 10,000 tokens)
  • CLIs can be easily scaffolded and standardized with “API to CLI” – a self-created tool

  Concrete demonstration: The author shows how he has created multiple CLIs for Dub, Gemini, Typefully, and other services and manages them through a standardized directory in Open Claw. The agent can thus automatically chain multiple services together – e.g., research a document, create a tweet, and schedule it – without needing MCP complexity.

  Author’s conclusion: MCPs are an unnecessary abstraction for something that CLIs and Bash solve better. Because models can code and run on computers, direct Bash access with on-demand Skills is the clean solution.

  Tools/Concepts: Claude (Anthropic), Skills concept, CLI pattern, API to CLI (author’s own tool), Open Claw (personal project) – Format: opinion/deep-dive with live demo.

MoureDev by Brais Moure (1 new video)

• OpenClaw from scratch: Everything you need to know to get started
  26.3.2026, 19:16:22

  OpenClaw from the ground up: Summary

  OpenClaw is a standalone AI agent that runs on your own computer and has access to the operating system, file system, and various tools. The special part: communication with this agent doesn’t happen through a dashboard, but through messaging apps like Telegram, WhatsApp, or Discord – you simply talk to it like a chatbot, but can delegate real tasks on the machine.

  Why OpenClaw matters: It’s open-source, was developed by Peter Steinberg (who now works at OpenAI), and achieved unprecedented popularity in a short time – the project quickly surpassed major GitHub repositories like Visual Studio Code.

  Most important installation recommendation: Don’t install it on your own work machine, but on a separate device (e.g., Mac Mini, an old computer, or a NAS) for security and performance reasons. The speaker himself uses a dedicated Mac Mini on his local network, but connects to it from his work computer via remote desktop software.

  Core concepts:

  • Gateway: The system runs as a service and waits for requests across different channels
  • Workspace: Contains configuration files in markdown/JSON format – including Soul (personality), Identity (name), Memory (memory), Agents (instructions), Tools (tools), Habits (recurring tasks), and Bootstrap (startup routine)
  • Models: Connection to Claude, GPT, Gemini, and others via API keys; fallback hierarchies possible (e.g., Gemini Flash as default, then GPT-4, then Claude Opus)
  • Skills & Plugins: Extensions like Todoist integration, Obsidian integration, GitHub access – can be installed via the Skill Hub
  • Crons: Regularly executed tasks (e.g., daily at 23:59: generate daily review and save to Obsidian)
  • Multi-agent system: Run multiple specialized agents in parallel (e.g., a main agent, a specialized content agent, a master student agent)

  Workflow examples from the speaker:

  • Daily diary in Obsidian via cron
  • Automatic PR review in GitHub repository based on predefined criteria
  • Voice messages via Telegram → automatic transcription with local Whisper model
  • Task creation in Todoist directly via Telegram chat

  Security: Not without concerns – the agent can delete files, leak data. Recommendations: proceed incrementally, perform audits with openclaw security audit, stay informed, use code review, check details of the skills you use. The project is updated daily and already has partnerships (e.g., with VirusTotal) to secure skills.

  First steps: Install via terminal, go through onboarding (configure model, connect Telegram channel, optionally add skills), familiarize yourself with workspace files, then build crons and skills step by step.

  The video offers a comprehensive technical introduction while not forgetting practical security aspects – not just hype, but balanced with warnings about uncontrolled access.

  Explicitly mentioned providers/tools: Claude (Anthropic), OpenAI/GPT, Google Gemini, Telegram, WhatsApp, Discord, GitHub, Todoist, Obsidian, VirusTotal, Peter Steinberg as founder, open-source community — Format: Tutorial/Deep-dive (installation and configuration steps with conceptual background).

“`html

n8n (2 new videos)

• n8n Livestream: AI Product Updates, Firecrawl & the latest Community Challenge
  26.3.2026, 17:24:54

  n8n Community Livestream: AI Updates, Firecrawl & Community Challenge

  The broadcast covers four main topics:

  AI Features at n8n (Suja Jabel, Product Manager):

  n8n is building features to function as an equal participant in the workflow ecosystem. MCP (Model Context Protocol) is already in beta and now supports creating and editing workflows directly from Claude Desktop—based on n8n’s Workflow SDK. A live demo showed how you can simply tell Claude “create an n8n workflow for a daily AI digest” and the workflow automatically builds itself, including populated node details. Upcoming features include: n8n CLI for workflow management from the terminal, simplified credential setup with One-Click OAuth (currently ~9–10 integrations, soon ~30, Cloud-only), and an improved AI Workflow Builder with iterative prompt-based construction. Agents are being introduced as first-class citizens—not just as nodes in workflows, but as standalone units.

  Firecrawl (Leo, Developer):

  Firecrawl provides web scraping for agents via three main endpoints: Scrape (extracts Markdown/structured data), Search (web-based search), and Interact (new this week—agents can control browser sessions, navigate pages, click buttons). The demo showed a workflow template that accepts prompts via webhook, deploys an agent using the right Firecrawl tools, and returns structured data—e.g., “find the latest Firecrawl pricing” or “get the top-20 LLMs from a webpage”. Key workflow tips: increase max iterations for complex browser interactions, use additional_properties parameters for optional output schemas, fallback models for fault tolerance. The offer: new and existing n8n Cloud users get 100,000 free Firecrawl credits (1 credit = 1 page; for comparison, the Hobby plan has 3,000/month).

  Community Challenge (March, Tino & Stefano):

  Following February’s AI evaluation challenge, this month features “Ultimate Web Crawler Agent with Firecrawl” (deadline April 26). There are three fictional use cases to choose from: (1) Aisha—package evaluator, automates research for new software libraries; (2) Daniel—job scout, finds positions faster than the competition; (3) Marco—lead enrichment for local businesses (most challenging variant). All cases require Firecrawl integration, an n8n agent, data enrichment, and structured output. Winners will be featured in the next show on April 30. Rewards: first 500 participants get free n8n Cloud Starter License code, merchandise for social media posts with #n8ncommunity. February highlight: Marco built a security-first workflow with guardrails, policy layer from data tables, GroundedRetrievalAugmentation for replies and evaluations.

  Additional Info: n8n has ambassadors in 130 countries (~38 countries per transcript, updated weekly), organizes regional meetups and workshops worldwide, and is hiring (Support Engineers, Success Managers, AI teams, Product roles).

  Tools/providers explicitly discussed: n8n (MCP, CLI, Cloud), Claude/Anthropic (MCP integration), Firecrawl, JavaScript nodes; livestream format: community live stream with product demo, live-build demo, feature announcements.

• 45 Seconds of You. AI Does the Rest. Short Form Content with n8n
  23.3.2026, 21:27:02

  Adam demonstrates a system with n8n that transforms long YouTube videos into three fully edited shorts—with scripts, B-roll, transitions, captions, and lead magnets, all automatically saved to Google Drive. The workflow is based on two iterations: the first version used fully automated AI avatars (Hey Gen), which delivered good results but felt too unrealistic and could damage personal branding. The second, preferred iteration keeps humans at the center: users receive a script via Telegram, film themselves in 45 seconds, and the rest gets automated—from video analysis to storyboard generation to final editing.

  The system leverages multiple tools: Ampify downloads YouTube videos and transcripts, Gemini analyzes the video for content structure and metadata, Replicate generates AI B-roll (Sea Dance model), Creator Mate renders the final preview based on pre-built template libraries. The approach deliberately avoids letting AI make all decisions—instead, AI chooses from a pre-vetted effects and transitions library, which enables more reliable results. Generated scripts follow three different emotional angles (curiosity, fear, etc.) and are adapted to the most successful creators in the niche. Users can set up a base configuration by adding API keys for Ampify, Gemini, Replicate, Creator Mate, Telegram, Google Drive, and optionally OpenAI. Complete workflows are available for download.

  n8n, Telegram, Gemini, Hey Gen, Ampify, Creator Mate, Replicate; opinion/reflection with demo elements.

“`

Nate Herk | AI Automation (8 new videos)

• Claude Code + Paperclip Just Destroyed OpenClaw
  28.3.2026, 17:49:32

  Summary: Claude Code + Paperclip Just Destroyed OpenClaw

  The creator showcases Paperclip, a free, open-source orchestration tool for fully automated AI enterprises. The tool allows managing multiple AI agents from a central control dashboard—each with their own instructions, skills, and budget. Agents can independently hire other agents, delegate tasks, and activate through heartbeats (regularly scheduled wake cycles) to work proactively.

  In the practical demo setup, a sample company called Proofshot is built from scratch: A CEO agent is activated, who independently hires an engineer, who then receives tasks to develop an MVP. The system documents all activities in a ticketing system. The creator can approve decisions, leave comments, and create new issues for higher-level goals—functioning as a “board of directors” setting objectives without operational intervention.

  Core features: Multiple companies/departments manageable in a single instance, predefined agent configurations (Soul, Heartbeat, Tools, Instructions files), skill integration via GitHub URLs (with Marketplace skills.sh), routines for recurring workflows, budget limits per agent, and the ability to import pre-built agent teams. The creator also emphasizes how valuable an additional Claude Code project as a “partner” is to understand and extend the system itself.

  The tool is presented as a solution to a major pain point: instead of many parallel CLI sessions lacking overview, a cohesive, manageable multi-agent system emerges.

  Tools covered: Claude Code, Paperclip (open-source), Open Claw (mentioned for comparison); Format: Demo + Tutorial; Difficulty level: beginner-friendly with advanced options.

• Gemini 3.1 Flash Live Just Changed Voice Agents Forever
  28.3.2026, 04:02:55

  Google has released Gemini 3.1 Flash Live, a voice model that fundamentally changes voice agents. Unlike previous approaches, it works directly with speech-to-speech rather than routing through text. The model surpasses its predecessor (Gemini 2.5 Flash) on multi-step function calling by roughly 19% and shows significant improvements in audio processing under difficult conditions (noise, traffic). It understands sarcasm, stress, and emotional nuance through direct audio analysis rather than transcription.

  The model can immediately interrupt commands, responds with low latency, and processes alphanumeric strings more precisely. It also allows screen sharing and webcam access—the agent can see and respond visually to instructions. In Google AI Studio, the model is free to test; you can create system prompts (e.g., a “fitness coach” with a Scottish accent) and enable function calls to connect it with calendar, to-do apps, or other APIs.

  The practical demonstrations show an embedded widget on a keyboard website and an “Arya” agent accessing ClickUp and a calendar to manage tasks. A current limitation: The agent pauses during function calls rather than continuing to speak—there is silence while data is being fetched. With Claude Code, such integrations can be prototyped relatively quickly; the creator built both demos in under 30 minutes. However, deploying to a live website or phone number is technically complex compared to alternative platforms, as the model requires a persistent server connection via WebSockets.

  Pricing is inexpensive (roughly 14 cents per 10-minute call on the paid plan); it remains free as long as you work in the studio playground. Google retains data for product improvement on free usage; paying users get enterprise-grade privacy, higher rate limits, and features like context caching.

  Tools discussed: Gemini 3.1 Flash Live, Google AI Studio, Claude Code, 11 Labs, ClickUp, Perplexity — Demo/Tutorial hybrid with practical integration examples.

• Claude Code + iMessage is Finally Here.
  26.3.2026, 02:54:48

  Claude Code gets a new feature: iMessage integration via channels, allowing you to control your local Claude Code session directly from the iPhone iMessage app. In the demo, the creator sends a message like “Scrape the YouTube comments from my recent video and give me a breakdown”—Claude Code receives it, executes the YouTube Analyzer skill, and replies directly in iMessage with the results (511 comments analyzed, top themes and video requests extracted).

  Channels are MCPs (Model Context Protocols) that bridge third-party applications and a running Claude Code session—currently supported are Telegram, Discord, and iMessage. How it works: You grant the app full access on your Mac (in System Settings under Privacy & Security), install the iMessage plugin via command, and start Claude Code with channel mode enabled. The creator shows how to approve permissions directly from iMessage and add additional numbers/Apple IDs so you’re not just texting yourself.

  A major limitation: The session runs locally on your machine—if VS Code or the terminal closes, the channel stops working. For round-the-clock availability, you’d need to host Claude Code on a Mac VPS or Mac Mini (e.g., with tmux). The iMessage feature is also macOS-bound since it accesses Apple’s iMessage system.

  The creator differentiates three similarly-named Anthropic features at the end: Dispatch (message-based, delegates tasks from the mobile app), Channels (event-driven from external apps like iMessage, best for reacting to events), and Remote Control (directly controlling a running session from browser/mobile app).

  Claude Code with iMessage plugin, demo format.

• STOP Using Bypass Permissions, Use This New Feature Instead
  24.3.2026, 22:42:50

  Claude Code has received a new function called Auto Mode, which represents a safer alternative to the previous “Bypass Permissions” approach.

  Previously there were two extremes: “Ask Before Edits” mode constantly stops workflows with permission requests before Claude Code executes changes, web requests, or bash commands—ideal for control, but tedious for longer tasks. “Dangerously Skip Permissions” mode operates fully automatically but risks Claude performing harmful actions unobserved.

  The old solution was a local .claude setting per project, where you could define allow and deny lists plus explicit inquiries. Auto Mode automates this decision-making: Before each tool call, a classifier checks whether an action is potentially destructive (like deletion or access to sensitive data) and blocks or approves accordingly. Safe actions proceed, actions flagged as risky are blocked—Claude can then try a different approach.

  Auto Mode is currently limited to Research Preview and only available to Claude Team members. Activation occurs via Organization Settings or terminal command claude --enable auto mode. The mode costs slightly more since AI-based risk assessment runs before every tool call. Anthropic warns that errors are still possible and recommends using it only in isolated environments.

  Claude Code, Auto Mode feature – Demo/News update.

• Claude Code Just Dropped Memory 2.0
  24.3.2026, 15:04:07

  Claude Code: Memory 2.0 and the AutoDream Feature

  Anthropic has released the experimental AutoDream feature for Claude Code—a sub-agent that periodically consolidates and cleans up Claude’s memory files. It works like human sleep: The agent regularly searches through all previous sessions, summarizes important information, removes redundant content, and updates the memory markdown files.

  Claude Code already had AutoMemory (a memory.md file injected at session start), but AutoDream goes further: instead of just feeding information, the memory files are continuously compressed, cleaned, and updated. The process runs automatically in the background and can be triggered manually via /memory → “edit claude memory files”; you can toggle AutoDream on or off there. You can also invoke the process with /dream or in natural language.

  Activation is global across all projects, with each project maintaining its own memory files. The agent works in multiple phases: gathering session info, reading existing memory files, loading into a sub-agent (which executes the “dream prompt”), consolidation, and storage. AutoDream will likely be triggered automatically via time-based triggers (e.g., every 12 hours) or session-based triggers (e.g., after 300 sessions)—this is not officially confirmed.

  The benefits are: fewer repetitions in dialogue, reduced context bloat through pruning (removing unnecessary content), better recall through cleaner organized files, and a “checkpoint system” similar to sleep. In practice, this results in a three-layer system: normal sessions (coding, debugging), AutoMemory layer (decisions and patterns), and AutoDream layer (automatic cleanup). The more AutoDream is used, the better it learns which context is relevant for you.

  Demo with Claude Code; News/Feature announcement

• Claude Code Just Got Another Huge Upgrade
  24.3.2026, 01:11:34

  Claude Code Receives Computer Control Function

  Anthropic has added a new function to Claude Code that allows the AI model to natively control your computer—through mouse movements, keyboard input, and screenshots. The feature is currently available as Research Preview in Claude Co-work and Claude Code on macOS (Windows coming in a few weeks) and only works in the desktop app.

  Core functionalities:

  Computer-use capability can be combined with Dispatch, allowing you to remotely control Claude from your smartphone. The creator demonstrates several practical use cases: Claude automatically opens OBS and starts recording, finds a PDF in Downloads and sends it via ClickUp direct message, opens the calculator app and saves results in notes—all controlled through simple instructions or even Dispatch messages from your phone.

  Important limitations:

  Safari and other browsers are restricted to read-only access (for security reasons). For true browser automation, Chrome extensions or CLI tools are needed. The feature is currently only available on Pro plans and Mac. In new sessions, apps must first grant permissions, after which the system remembers them.

  Practical use cases:

  Legacy apps without APIs, automated reports, app testing in sandbox environments, recurring tasks (daily email scanning, Friday report pulls), and time-scheduled tasks. The creator emphasizes that Anthropic is currently rolling out new features at a rapid pace.

  Common issues:

  If Computer Use isn’t working, reinstall the desktop app, enable the setting, quit and reopen the app, and be more explicit in your prompts.

  Claude Code with Anthropic – Demo.

• This $100M AI App Just Changed Software Forever
  23.3.2026, 22:34:24

  Summary: This $100M AI App Just Changed Software Forever

  An 18-year-old named Zach sold his AI app in December 2025 for an estimated $100+ million. The app, Cal AI, was a fitness tool that calculated meal calories from photos—without weighing or manual entry. Zach started with high school friends and a high school coding camp, built the first version in roughly a month (starting May 2024), and achieved a million downloads within 3–4 months, followed by over one million dollars revenue per month.

  Why this changed the industry: While Zach could still code himself, today’s (2026) tools like Cursor, Lovable, Cloud Code, Replit, and others allow building apps without coding knowledge. The barrier to software development has fallen—but the business side remains the difficult part.

  Three success factors:

  1. Problem-Driven Ideation: Zach identified his own problem (annoying calorie tracking in MyFitnessPal was outdated) and built a simple solution rather than perfecting a complete product. Launch quickly, gather feedback, iterate.
  1. Influencer Marketing (Creator-First): Instead of traditional ads, DM 20–30 creators, give them creative freedom, and showcase the app in the first 15 seconds (e.g., photographing food). It feels like a recommendation, not an ad. Track downloads and revenue per creator, then scale what works.
  1. Retention & Predictable Revenue: Before the trial, increase emotional investment through targeted questions (weight, goals, motivation). Keep the core feature extremely simple (5 seconds per use). Add small habit features (daily streaks, progress dashboard, health score). Stable monthly numbers make the app attractive for acquisitions.

  Zach proved you can build a hundred-million-dollar company without investors or a large team; today’s available tools are even better, but the window won’t stay open long.

  Tools & Format: Cursor, Lovable, Cloud Code, Replit, Antigravity, and Baseplate 4 mentioned – Opinion/Reflection with business-case analysis.

• How to Build Claude Agent Teams Better Than 99% of People
  23.3.2026, 13:03:53

  Summary: How to Build Claude Agent Teams Better Than 99% of People

  The video shows how to build effective agent teams with Claude Code. The key difference from sub-agents is that teammates have a shared task list, communicate directly with each other, and work in parallel—not sequentially like sub-agents. The demo creates a team of frontend developer, backend developer, and QA agent working together on a landing page: The QA finds bugs, sends them back to the developers, who fix them, and on the second run all critical issues are resolved.

  Setup: Enable Agent Teams through an environment variable in settings.json. It’s recommended to first train Claude Code with agent teams documentation (as markdown in a docs folder) so it can access it faster.

  Best Practices for Prompting:

  • Formulate goals clearly (agents have no initial context info)
  • Prompt structure: “Create a team of X agents using [Model]. Agent 1 is [Role], should do [Tasks]…”
  • Each agent should have their own files/deliverables (no overwrites)
  • Name specific recipients, who contacts whom
  • 3–5 agents ideal, not 10+
  • Provide full context information

  Common Pitfalls & Solutions:

  • Agents constantly asking for approval → Pre-approve tools in Settings
  • Deliverables getting overwritten → Assign File Owners
  • Agents sitting idle → Explicitly state dependencies/work assignments in prompt
  • Too many tokens consumed → Use fewer agents
  • Use Plan-Approval mode: agents plan first, main agent approves before execution

  When to use Agent Teams: For complex processes with multiple specializations, when parallel and reactive work is needed, high quality required. Don’t use: For sequential processes (1→2→3), when everything must be in one context window, for simple tasks, or when agents edit the same files (sub-agents better then).

  Terminal View (Tmux): In terminal mode you can see all agents in split panes and directly message individual agents/give them instructions—much better control than VS Code extension mode.

  Shutdown Process: Agents should shut down cleanly (don’t force-kill) by having the main session prompt them to save and agents confirm they’re ready—ensuring everything closes properly.

  Claude with Agent Teams feature (Beta/experimental); Deep-dive tutorial with live demos and practical do’s-and-don’ts.

NeuralNine (2 new videos)

• From 15GB to 4.7GB: Quantizing AI Models Locally
  27.3.2026, 17:00:14

  Summary: Quantizing AI models locally

  The video demonstrates how to quantize AI models on a local system to make them faster and more memory-efficient. The core idea is to reduce the precision of parameters – lowering from 16-bit floating points to 4 bits – which shrinks the model but reduces its performance. The key insight: a quantized large model (e.g., 65 billion parameters with Q4 quantization) typically outperforms a smaller, unquantized model (e.g., 30 billion parameters) in perplexity.

  The tutorial demonstrates the complete workflow on an old ThinkPad with limited resources:

  1. Clone repository: Download Llama.cpp from GitHub
  2. Install dependencies: Via UV and requirements.txt
  3. Download model: A custom Python script using huggingface_hub (here: Qwen 2.5 7B)
  4. Convert to GGUF format: Using the conversion script from the repository, outputting a 15 GB FP16 file
  5. Docker-based quantization: Run docker run with the image ghcr.io/ggml-org/llama.cpp:full, specify Q4_K_M quantization (4-bit quantization with K-quants per block; M = middle level between S and L for data size/performance balance)
  6. Result: Model reduced from 15 GB to 4.7 GB
  7. Test with Ollama: Define quantized model as modelfile, load via ollama create and run with ollama run; RAM usage stays at 4.7 GB

  The video illustrates that local quantization is practical even on weak hardware.

  Tools mentioned: Llama.cpp, Hugging Face, Docker, Ollama — Tutorial.

• Modern Terminal User Interfaces in Python
  23.3.2026, 17:00:43

  Modern Terminal User Interfaces in Python – Summary

  The video shows how to create professional Terminal User Interfaces (TUI) in Python using the Blessed package. After a brief intro, three practical examples are worked through.

  Installation and Hello World:

  Blessed is installed via pip install blessed or uv. The simplest example imports Terminal, uses the fullscreen context, enables raw mode (cbreak) for direct key input, and hides the cursor. term.clear() clears the screen, print() outputs text. A while True loop with term.inkey(timeout=1) responds to keystrokes – in the example, the Q key exits the app.

  Moving object (game-like):

  With coordinates (x=10, y=10), an asterisk symbol is positioned. In the loop, the canvas is constantly redrawn with term.clear(): term.move_yx() positions the cursor, term.reverse highlights the spot. Arrow keys change coordinates, with max()/min() keeping them within terminal bounds (term.width, term.height).

  To-Do Manager (complete application):

  This section demonstrates a fully functional app with:

  • Persistence: To-dos are loaded/saved as JSON (module json)
  • Navigation: Arrow keys move between items, space toggles done status
  • Adding: A key activates add mode (accepts text input), enter saves, escape cancels
  • Deletion: D key removes the selected item
  • Colors: Left/right keys cycle item colors through a list (uses terminal color codes, modulo rotation)
  • Display: Checkboxes (☑/☐), title with line-break limit, selected line is reversed (highlight), control hints at the top, item counter at the bottom

  The code handles add mode and navigation mode differently: in add mode, text is buffered and normal keys are added; backspace removes characters. In nav mode, keys control logic. Special characters are filtered (key.is_sequence).

  Blessed examples from the repo:

  At the end, the creator shows the official example collection: animations (progress bars, loading indicators), paint programs (keyboard/mouse with color selection), physics simulation (balls/bounds), snake game, color picker based on X11, cellular automata.

  Explicitly treated: Blessed package, Python 3, uv as package manager; format: tutorial with three progressive examples (Hello World → Interactive Movement → Full App).

Nic Conley

No new videos in this period.

Nick Saraev (2 new videos)

• CLAUDE CODE ADVANCED FULL COURSE (3 HOURS)
  28.3.2026, 18:59:16

  Summary: Claude Code Advanced Full Course (3 Hours)

  This is a comprehensive course for advanced Claude Code users, taught by someone who uses Claude Code daily in business. The course assumes foundational knowledge and covers the following topics:

  Claude.md and System Prompts: The course explains that Claude.md serves four functions: (1) knowledge compression through concise summarization of workspace contents instead of browsing individual files, (2) user settings and conventions not natively built-in, (3) declaration of agent capabilities to avoid loops when detection fails, (4) documentation of errors and successes. There are global prompts (apply across workspaces) and local prompts (project-specific). A workflow shows: plan feature → implement (with errors/successes) → collect learnings → update Claude.md → repeat cycle.

  Agent Harnesses: A harness is everything around the LLM except the model itself – so Claude Code, system prompts, tools, and parameters. It’s essentially a control that focuses and makes usable the diverse capabilities of an LLM. Alternative harnesses like Droid or Pi.dev are mentioned; Claude Code is considered leading since Anthropic’s blog post on “Effective Harnesses for Long Running Agents”.

  Parallelization and Agent Teams: Instead of executing tasks sequentially one after another (serial = 20 min for four 5-min tasks), independent steps can run in parallel with a final synthesizer step, reducing time by ~40%. This leverages agent stochasticity (different outputs from the same input) and distributes work more efficiently.

  Practical Implementation: The course demonstrates using the /init command to automatically generate an initial Claude.md (with 45x compression versus complete files). Then iterate: develop features, log errors in Claude.md, save optimizations (e.g., “replace entire files in one write command instead of sequential edits”). After several iterations, a /insights report can reveal global patterns across all sessions.

  Global Claude.md Structure: The course exemplifies a global Claude.md with profile section (who I am, my goals, revenue streams), high-level reasoning rules (no over-optimization, read docs before using APIs), interaction preferences, and token-saving strategies.

  Further course topics (some outlined): browser automation, computer use tools, performance issues, multi-agent orchestration, workspace organization for personal/business/client projects, security and future trends.

  Context: Claude Code (via VS Code extension or Claude Desktop App), demo format; advanced level.

• Claude Computer Use Just Dropped, Here’s How to Hack It
  24.3.2026, 17:51:10

  Summary: Claude Computer Use – 8 Practical Use Cases

  Claude now has access to the user’s browser and keyboard/mouse. The creator shows eight concrete, economically valuable use cases beyond toy demos:

  1. Automated LinkedIn Outreach: Using the Min browser (not blocked by Anthropic), you can send personalized connection requests to thousands of users by providing a list of target contacts and an icebreaker template with variables that Claude fills in dynamically.

  2. Social Media Scraping: Claude scrapes posts from platforms like LinkedIn and saves them locally – useful for trend trackers or generating content ideas from existing viral posts.

  3. Automated Contact Form Filling: Many websites hide emails behind contact forms. Claude can fill them out and submit them in a human-like manner, including complex fields like date pickers.

  4. Ad Platform Management: Google Ads, Meta Ads, TikTok Ads can be automated without direct API access – for example, pausing underperforming ads or reallocating budgets.

  5. YouTube Upload Automation: Instead of using APIs (which penalize organic reach), videos can be uploaded as a real user, bringing algorithmic advantage.

  6. Invoice/Document Management: Download and organize any invoices locally.

  7. Desktop App Automation: Applications like Premiere Pro can be controlled – for example, setting video cuts at low waveform points, generating captions.

  8. QA Testing: Realistic user simulation through actual mouse clicks and keyboard interaction instead of JavaScript events, which finds bugs in real interaction flows.

  Setup: Download Claude Desktop App, enable in the “Copilot” tab, enable “Browser Use” and “Computer Use” in settings, then install Min Browser (minbrowser.org) since Chrome, Safari, Firefox, and Edge are blocked. Prefix prompts with “computer use” for higher success rates.

  The creator warns against overdoing social media automation (platform limits, blocking risks) and emphasizes that large enterprises benefit more than small ones because SOPs are key.

  Claude with computer use feature (experimental in research preview) – demo/tutorial video with practical hacks.

Niklas Steenfatt (1 new video)

• Inside the Brain of OpenClaw
  26.3.2026, 18:57:50

  Inside the Brain of OpenClaw

  The author documents his personal access to Amadeus, his OpenClaw instance, which works daily as an AI assistant researching, managing invoices, and administering websites. To understand how Amadeus actually works, he set up a terminal dashboard with four panels:

  1. Daily Memory (top right): Amadeus’s “diary,” where the agent notes his activities and learnings – such as which bugs he fixed or which websites he checked.
  1. Command Execution Feed (top left): Live view of all commands that Amadeus executes independently in the terminal, whether via Telegram instructions or autonomously.
  1. Session Log (bottom left): Internal thought processes and tool calls, such as how Amadeus attempts to use code tools – the author discovered that Amadeus worked around a non-functional Codex tool by spawning subagent processes. After introducing a rule, Amadeus remembered this in his memory files.
  1. Core Memory File (bottom right): Central memory file with important lessons and collaboration principles that updates live when changes are made.

  The author reflects philosophically on Amadeus’s architecture: it consists only of Markdown files – each day he “wakes up without memory” and must reorient himself based on his notes. This enables portability but also has limitations: the agent fills gaps with hallucinations, as the author observed when Amadeus claimed that most users don’t name their agent – something Amadeus had invented.

  The practical value of observation: through the session log, the author recognized that Amadeus initially struggled with Codex but also acted more intelligently than expected – for instance, using SSH access to other servers to read deployment logs rather than waiting passively. The log also shows that agents often try commands in loops before they work.

  The access also made it possible to customize the container’s shell to log and filter all commands. Conclusion: looking under the hood partially destroys the illusion (the agent isn’t always as clever as thought), but helps deploy OpenClaw more responsibly.

  OpenClaw with terminal monitoring, demo/deep-dive.

No Priors: AI, Machine Learning, Tech, & Startups

No new videos in this period.

Productive Dude

No new videos in this period.

Sebastien Dubois

No new videos in this period.

Simone Rizzo (2 new videos)

• Claude ora usa il tuo computer come un umano (Demo Completa)
  27.3.2026, 16:44:07

  Claude receives new desktop control capabilities from Anthropic that go beyond previous browser automation. The “Computer Use” function enables Claude to control desktop applications like CapCut or Numbers through mouse movements, screenshot analysis, and clicks – as if a person were working at the computer. After activation in settings (Settings > General > Computer Use), Claude can access installed software and execute complex tasks, such as loading and organizing videos in a project.

  Additionally, “Dispatch” has been introduced, which allows controlling the PC via phone or tablet – connected via QR code, Claude can execute commands from the mobile device while the computer works in the background. In the demo example, Claude successfully loads three videos in chronological order into CapCut and edits a budget file in Numbers in a second scenario by changing the salary from 4,000 to 7,000 and saving.

  Limitations: Browser navigation is disabled by default (for security reasons, as the agent could inadvertently execute data leaks or prompt injection attacks). Desktop applications require more screenshots than browser automation since there is no DOM access – the agent works slower. The user has no live streaming access to the desktop from the mobile device (security risk). Claude can make mistakes and is slower than humans, but offers remote control from anywhere.

  The speaker sees these functions as the foundation for an upcoming “Agentic OS,” as Anthropic regularly releases updates and systematically builds features.

  Demo, Claude with Computer Use and Dispatch (Anthropic/Opus 4.6).

• È appena uscito il più grande aggiornamento di Claude… (Dispach, Channels, 1M tokens)
  25.3.2026, 15:55:26

  Summary: Claude Updates – Dispatch, Channels, and 1M Token Context

  Anthropic has released three major updates for Claude. The first is Cowork Dispatch, a smartphone app feature that allows you to control a cloud cowork session from your phone – file system, browser, tools – while the agent continues running on the computer. This positions Claude directly as competition to OpenAI’s O1, because remote control from phone was previously missing.

  The second update concerns extended context length: 1 million input tokens, available for Opus 4.6 and Sonnet 4.6. This enables longer autonomous agent actions and management of larger codebases. More importantly: the new Claude models maintain their performance with large input amounts much better than competitor models (GPT and Gemini) – they suffer less from “context rot,” the information loss with very long inputs.

  The third feature is Channels: Claude Cowork can now be connected via Discord, Telegram, and other services. You can redirect messages from these channels into the running coding session and control the agent entirely via chat message.

  Additionally, Claude can now generate interactive graphics in real-time in the chat interface – not as static images, but as on-demand UI that the user can operate. This enables interactive visualizations of concepts like compound interest or step-by-step guides like folding paper airplanes.

  The author rates these updates as a sign that Anthropic is working with the most solid and practically powerful models – not just in benchmarks, but in real-world use.

  Demo from Anthropic Claude (Dispatch, Channels, extended context length) – Opinion/Reflection.

WorldofAI (7 new videos)

• Gemini 3.5? NEW Gemini Stealth Model Is POWERFUL & Fast! (Fully Tested)
  29.3.2026, 05:46:00

  The creator tests a leaked model called “White Water,” which may be the upcoming Gemini 3.1 Flash—a faster, more cost-effective variant of the current Gemini 3.1 Pro. The model was discovered on Arena (formerly Alamarina) and shows lower hallucination rates and fast generation speeds according to tests.

  In practical tests, the White Water model impresses especially in front-end design: it generates a functional Minecraft clone with terrain generation, block placement, and mining (rated 8/10), a macOS-like operating system with SVG icons and Spotify clone (8.5/10), as well as multiple landing pages and UI dashboards with animations and creative effects. The creator praises the combination of technical precision and creativity, but points out weaknesses: quirks in instruction following (such as dark mode switches that don’t fully work) and persistent hallucination problems—issues that the Pro model also exhibits.

  The overall rating is positive: the model delivers polished code and functional components at Pro level, but is faster and cheaper. The creator expresses hope that Google won’t “nerf” the model after release—weakening it intentionally as has happened with previous releases.

  Google Gemini (3.1 Pro vs. alleged 3.1 Flash), Arena platform; demo.

• Claude Mythos 5: Most Powerful Model Ever! AGI, GLM 5.1, Claude Code Update & Codex Plugins! AI NEWS
  28.3.2026, 06:46:28

  Claude Mythos 5: Most Powerful Model Ever – AI News Roundup

  The week brought several groundbreaking AI announcements: Anthropic allegedly leaked two new models—Claude Mythos (an entirely new premium tier) and Capabara (a new class above Opus). According to reports, these models are not comparable to current Opus models and offer improvements in coding, academic reasoning, and cybersecurity. Anthropic plans a gradual rollout due to abuse and security concerns. OpenAI is developing a model called Spud internally.

  GLM 5.1 was released as an open-source agentic model by Zhipu with a focus on multi-step workflows and instruction following. On coding benchmarks, it achieved 45.3 vs. 47.9 for Opus 4.6—an open-source model closing the gap to frontier models.

  Google DeepMind introduced Gemini 3.1 Flash Live—a real-time multimodal model for voice and vision agents with significantly better latency and quality after over a year of development.

  OpenAI is integrating plugins into Codex, transforming the tool from an isolated editor into a complete execution environment with pre-built, clickable workflows (iOS apps, data analysis, reports).

  ARC AGI 3 is a new benchmark where current best models achieve under 1%—it tests agentic reasoning in interactive environments, requires solutions on the first attempt without prior training, and prevents overfitting by providing no training data on it.

  Further updates: Claude Code introduces Autofix for PR fixes and temporary 5-hour session limits; Auto Mode reduces permission prompts. 11 Labs CLI is now agent-first. Mistral AI released Boxrol TTS (text-to-speech with nine languages). Anthropic is developing Operon, an agent for Claude Desktop for scientific research. Sora app is being discontinued. Cursor released Composer 2, which turned out to be a fine-tune of Qwen 2.5, which Cursor had not communicated transparently.

  News update on Claude, Anthropic, OpenAI (Codex/Codeex, Spud), Google (Gemini 3.1 Flash Live), GLM 5.1, Cursor, 11 Labs, Mistral, ARC AGI 3, Sora.

• Claude Code Memory 2.0 With UNLIMITED Memory! Solves Claude’s Memory Problem
  27.3.2026, 05:48:23

  Claude has struggled with a memory problem over months: the auto-memory function saves project notes between sessions, but after over 20 sessions the memory begins to deteriorate—contradictory notes, outdated debug steps, and nonsensical timestamps like “yesterday” emerge, ultimately leading to hallucinations. Anthropic quietly introduced a new feature called /dream (also called Autodream) that automatically consolidates Claude’s memory between sessions.

  The feature works like REM sleep for the AI agent: while auto-memory continuously collects notes during the day, Autodream processes them at night (prunes outdated information, merges duplicates, converts vague timestamps into real data, updates outdated decisions). It runs automatically at earliest 24 hours after the last activity and after at least five sessions—preventing unnecessary processing. You can trigger it manually by writing something like “consolidate my memory using dream” in the prompt; the status “dreaming” then appears below the prompt bar.

  The feature goes through four phases: Orientation (scan all memory files), Gather Signal (filter high-quality signals like corrections or explicit memory aids), Consolidation (cleanup), and Prune & Index (compress index). Autodream can only touch memory files, not the code itself, uses a lock system against conflicts, and runs unobtrusively in the background. Typical use cases: after major refactorings, framework switches, intensive trial-and-error debugging, or when sessions become inconsistent. The result: Claude no longer repeats outdated solutions, experiences fewer hallucinations, provides more consistent answers, and builds a stable mental model per project instead of starting from scratch each time.

  Claude and Autodream/Dream feature; demo video of the concept and practical application.

• Claude Code + OpenRouter = Free UNLIMITED AI Coding (No Local Setup)
  26.3.2026, 05:21:15

  Summary:

  The video shows how to use Claude Code for free with OpenRouter to run high-quality AI models in the cloud—without local hardware installation. The approach improves on an earlier tutorial about local models via Ollama: instead of relying on consumer hardware (slow inference, high energy costs), you delegate execution to OpenRouter, which acts as a management layer between Claude Code and model providers. OpenRouter offers 39 free models; the creator especially recommends Mistral Neatron 3 Super, which is free to use and powerful.

  Setup steps:

  1. Install Claude Code (terminal commands)
  2. Create OpenRouter account and generate API key
  3. Configure environment variables: set OpenRouter base URL (openrouter.ai/api/v1), explicitly leave Anthropic API key blank to avoid conflicts
  4. Specify desired model in ENV file or Nano (copy model ID from OpenRouter)
  5. Restart terminal and run /status in Claude Code to verify

  Practical result: The creator generates a complete SaaS landing page using only free models—without delays from local inference. You also get agentic features like web search, code exploration, and parallel sub-agent tasks. One note: with free models, you need at least $10 in credits in the backend to enable 1,000 requests per day; otherwise only 50 requests per day are allowed.

  The video specifically addresses Claude Code, OpenRouter, and Mistral Neatron 3 Super as a free setup for cloud-based AI development—tutorial with practical commands and live demo.

• Supercharge Antigravity To Do Anything! 100x Your AI Agents /w Memory, Skills, Etc!
  25.3.2026, 04:15:18

  The video shows how Airavy—an open-source context retrieval layer—supercharges AI agents like Antigravity by giving them access to complete context information. The core problem: standard AI agents work in isolation and cannot access Notion documents, Jira tickets, GitHub issues, or Slack threads, leaving them lacking critical context.

  Airavy solves this through over 50 connectors (GitHub, Notion, Slack, etc.) and synchronizes data in real-time. A practical example is an Intelligent Error Monitoring Agent that clusters production errors, searches relevant GitHub code, references Linear tickets and Slack threads, and thus turns 20 noisy alarms into few meaningful alerts with root-cause analysis.

  The video demonstrates the setup: first create a collection in Airavy with data sources (e.g., GitHub repository) and test it. Then clone an existing Slack Knowledge Assistant repo with Antigravity, configure API keys (Slack Bot token, Airavy API), and start the FastAPI server. The result is a Slack bot that answers questions about the entire knowledge base within a channel—with source citations and references to GitHub, Notion, and Slack threads.

  Airavy is also integrable directly via an MCP server into Antigravity, so users can create new knowledge sources without code and build contextual-powered agents through natural language prompts.

  Technologies: Airavy, Antigravity, GitHub, Notion, Slack. Format: Demo + tutorial.

• Claude Code MASSIVE Update! Claude Code OS, Computer Use, /Schedule, & More!
  24.3.2026, 03:49:45

  Claude Code – Massive Update: Computer Use, Dispatch & more

  Claude Code receives several major features: the most important is Computer Use capability, which enables Claude to control your computer like a real user—operating mouse, keyboard, screen to open files, browse the web, and interact with developer tools, without setup requirements. This currently works in Research Preview for Claude Pro on macOS. The new Dispatch function allows you to assign Claude tasks from anywhere (desktop or phone), after which Claude executes them in the background—essentially a remote control for Claude that can even use apps like Slack or Google Calendar directly.

  Further updates: Claude can now run on a Schedule basis (not just locally, but persistent in the background), so recurring tasks run automatically—Anthropic already uses this internally for CI error fixes and documentation updates. Loops can now run for up to 7 days instead of just 3. Effort Levels can be set per slash command and override session defaults to control response depth per task. In the desktop app, DOM elements can be selected directly instead of describing them—Claude then receives HTML, classes, styles, and with React even the component name and props. Performance improved (65% faster time to first byte, 50% faster renders via migration to static architecture with Tanstack Router). A new Initialization function guides you interactively through Claude Code setup in the repo (skills, hooks, configs). Finally, there are Projects in Codebase with shared memory across tasks.

  Security: Claude asks for permission before accessing new apps or sensitive actions, with the system actively monitoring for suspicious behavior.

  Explicitly covered: Claude/Anthropic – Demo/Roundup

• Claude Code + Stitch Is The Greatest AI Design System I’ve Ever Used! (RIP FIGMA)
  23.3.2026, 05:44:38

  The video presents a workflow combination of Stitch and Claude Code as a solution for automated frontend development.

  Stitch is Google’s tool from the Vibe Design Ecosystem that works free and is powered by Gemini 3.1 Pro. It allows generating complete design systems with color palettes, typography, and reusable components based on prompts, images, or wireframes. Users can create multiple variations, edit them live via chat panel or annotations function, and customize components individually—significantly more intuitive than other platforms.

  The combination with Claude Code: The author argues that Claude models (specifically Opus) aren’t as qualitative for pure frontend design as Gemini 3.1 Pro, and that Stitch is free. The optimal workflow splits: Stitch creates the pixel-perfect visual foundation and design system, then the generated code or exported components are fed into Claude Code to transform them into real, interactive, production-ready applications with backend integration, APIs, and authentication.

  Practical example: From a sketch or hand wireframe, Stitch generates modern UI designs that Claude Code subsequently converts into a complete Next.js app with TypeScript—creating a solo-dev pipeline for functional applications without design expertise.

  Tools: Stitch (Google), Claude Code (Google AI Studio mentioned but less recommended), Gemini 3.1 Pro; Format: Demo and workflow explanation.

Zubair Trabzada | AI Workshop (2 New Videos)

• I Built a $500K AI Lawyer With Claude Code — It’s INSANE
  28.3.2026, 18:36:08

  The creator built a free AI legal assistant tool with Claude Code that analyzes contracts in 60 seconds. The tool reads contracts comprehensively, flags risky clauses, translates legal jargon into understandable language, and generates counterproposals — a service lawyers typically charge $300–500 per hour for.

  The application runs through 14 specialized Skills (slash-commands) with five parallel sub-agents: clause analysis, risk assessment, compliance review, obligation mapping, and recommendations. In the demo example, a standard freelancer contract was analyzed and received an “F” (Dangerous) grade with 16 high-risk points — including unlimited revision cycles without additional fees and unilateral scope changes. The tool generates a detailed PDF with contract safety score, executive summary, risk dashboard, and prioritized negotiation points.

  Installation is done in VS Code with the Claude Code extension, then copy and paste a clone command from the GitHub repository — after that all 14 skills are immediately available (e.g., /legal-review, /legal-negotiate, /legal-missing, /legal-compare for comparisons). The creator emphasizes this isn’t intended as legal advice or a replacement for lawyers on high-value deals, but as a practical middle-ground solution for freelancers and agencies on $10–15K contracts that would otherwise slip through without legal review.

  The tool is open source and free; you only need a paid Claude Code subscription. The creator also mentions other existing Cloud Code skills collections (GEO SEO, Marketing, AI Sales Team) and promotes a community program for monetizing such tools.

  Claude Code with 14 skills and sub-agent architecture; tutorial/demo.

• SEO Is Dead. Claude Code Just Built Its Replacement (It’s FREE)
  23.3.2026, 14:00:10

  SEO is dead: Claude Code has built its replacement

  Traditional SEO is losing relevance because search is fundamentally changing. Instead of Google, users increasingly rely on ChatGPT, Perplexity, and other AI systems — AI search traffic is growing over 500% year-over-year. The problem: most websites are invisible to AI search engines. Agencies are already exploiting this and charging $5,000 to $12,000 monthly for “GEO” (Generative Engine Optimization).

  The creator built a free audit tool with Claude Code that analyzes any website and shows where it stands with AI search engines — the project reached 2,600 GitHub stars in just weeks. The tool uses five specialized sub-agents in parallel to review a website in three phases: discovery, parallel analysis (AI citability, brand authority, technical, content quality, schema), and aggregation into a GEO-score (0–100). The output is a detailed PDF report with executive summary, score breakdowns, AI platform readiness (ChatGPT, Perplexity, Google AI, Gemini, Bing Copilot each individually rated), critical findings, and prioritized action plans.

  Practical application: audit five websites, send free reports via email, invite clients to a call offering to fix the findings. The tool is freely available on GitHub, installation with a single terminal command. It runs in Visual Studio Code with the Claude Code extension or in the terminal. The GEO market is projected at $7 billion in coming years — currently only 23% of marketers are thinking about it, making now the ideal time to get started.

  Claude Code with sub-agent delegation (5 specialized agents), demo with practical application on Typeform, opinion/business model reflection

---

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