Blog

GPT-5.5 vs. Claude Code: Two Camps, One Power Struggle Over the 2026 Coding Workflow

Sunday, May 3, 2026

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

Model Releases & Benchmarks

DeepSeek V4 Pro (1.6 trillion parameters, 49 billion active, 1 million token context) and the more compact V4 Flash dominated model discussion outside OpenAI: Simone Rizzo analyzes the technical innovations — Compressed Sparse Attention, Muon Optimizer, QAT — and finds that V4 Pro delivers equivalent quality at five to seven times cheaper than GPT-5.5 or Opus 4.7. Alejandro AO demonstrates V4 Pro via the Pi-Agent framework and sees it on par with GPT-5.4. Xiaomi’s Mimo 2.5 Pro (1.2 trillion parameter MoE, MIT license, $1/million input tokens) surprised WorldofAI in frontend and 3D tasks and reportedly beats DeepSeek V4 according to benchmarks. On the Google side, Arena tests show a quietly updated Gemini 3 Flash achieving quality close to Gemini 3.1 Pro; Gemini 3.1 Flash is expected to become generally available before Google I/O. Elon Musk’s xAI communicated an aggressive Grok roadmap: Grok 4.4 with one billion and 4.5 with 1.5 trillion parameters to follow within weeks, Grok 5 with up to ten trillion parameters directly linked by Musk to AGI potential.

Local & Open-Source AI

Nate B. Jones describes the personal AI computer as a paradigmatic inversion of cloud dependency: Ollama as the practical standard, MLX for Apple Silicon, vLLM for serious Nvidia deployments, Open Brain or Postgres with pgvector for local memory, MCP as the interface with permissions and audit logging. The hardware axis ranges from the Mac Mini M4 Pro (64 GB for knowledge workers) through the DGX Spark as an appliance to dual RTX-5090 setups for teams. Kyle Balmer adds a beginner’s introduction: LM Studio (GUI) or Ollama (CLI) suffice, Gemma 4 from Google runs on virtually any device, the real bottleneck is RAM. Tim Carambat and other channels argue that the increasing “enshittification” of cloud tools (GitHub Copilot on credit basis, Claude Code quota issues) accelerates the shift to local models. DevExpert tests Nvidia’s Nemotron 3 Nano against Qwen 36 and Yema 4 and reaches a clear conclusion: the Nvidia model hallucinates on long transcripts, fails agentic tasks, and crashes when building apps — both alternatives are far more reliable.

Claude Code & Anthropic Tooling

Cole Medin’s three-phase PIV framework (Planning → Implementation → Validation) is the week’s most precise instruction: a fresh Claude Code context per ticket, auto-generate Jira tickets from PRDs via Atlassian MCP, isolate Sub-agents for research to avoid overloading the main context window — and check all improvements into Global Rules and Skills in the repository. Nate Herk’s multi-hour course on Claude Code as a personal AIOS combines four layers (Context, Connections, Capabilities, Cadence) with concrete tools: Google Workspace CLI, Obsidian-based LLM wiki, Cloud Routines for always-on background tasks, and Loops for real-time iterations up to three days. Mark Kashef introduces “Claudeex,” a tool that alternates between Claude Code and Codex over multiple rounds to mutually review and refine plans. Ben AI demonstrates Live Artifacts — personalized dashboards in Claude that pull real-time data from YouTube, Stripe, and PostHog and combine it with integrated chat for direct actions. WorldofAI lists fresh Claude Code updates: Blender and Autodesk Fusion connectors, 67% faster slash-res function for large sessions, and MCP concurrent connectivity.

Coding Agents (non-Claude)

Alex Finn tests OpenClaw against Hermes Agent in a live showdown with ChatGPT and Opus: on dashboard creation, OpenClaw with ChatGPT wins on speed, Hermes with Opus on UI quality; on website recreation, OpenClaw with ChatGPT dominates on accuracy. Hermes Agent gains momentum as a result: Leon van Zyl delivers a complete setup tutorial (VPS installation, Telegram bot, 77 pre-built skills, self-learning skill creation, cron jobs) and explicitly positions Hermes as a more performant OpenClaw alternative that improves with each interaction. Melvynx adds ten practical everyday use cases — from sponsor management and automated customer support to business intelligence via Postgres API. Matt Pocock releases “Sand Castle,” a TypeScript library that orchestrates Claude Code and other agents in isolated Docker sandboxes and uses GitHub Issues as a backlog; multiple agents work in parallel and automatically merge commits.

Software Engineering & Dev Culture

Matt Pocock analyzes AI-accelerated software entropy and presents a method for codebase remediation: deep modules (much implementation behind a simple interface), clean seams and adapters as a foundation — combined with Claude’s “Improve Codebase Architecture” skill, which identifies improvement potential and guides incrementally. GitHub gets a harsh reckoning from Theo (t3.gg) and Fireship: measured uptime of ~86.75% instead of officially claimed, 2,804 spontaneously reverted merges on April 23, an RCE vulnerability, and NPM name-squatting abuse under the name “TanStack.” Mitchell Hashimoto (creator of Vagrant and Terraform) pulls his Ghosty project off GitHub after publicly documented daily outages. Theo also analyzes which tech stack Claude Code recommends across 20 project categories: GitHub Actions dominates CI/CD (94%), Vercel is the 100% choice for JavaScript deployments, Stripe leads payments (91%) — and on runtime questions, Claude Code hallucinates (Bun for Next.js) while Codex correctly suggests Node.

Personal AI OS & Agent Frameworks

Cole Medin’s Dark Factory experiment delivers production-ready results: 122 merged pull requests with no manually written code, an orchestrator checks for new GitHub issues every 30 minutes, and Archon workflows (Triage → Issue Handling → PR Review → Regression Testing) manage the entire cycle. Regression testing uses Agent Browser CLI to automatically check the live app for bugs. NeuralNine shows Agent Span as an open-source framework for durable agents in Python: state survives process crashes and long human-in-the-loop pauses, LangGraph workflows integrate without code changes. n8n presents two relevant updates: an official MCP server that creates workflows directly via Claude Code or other coding agents, plus a preview of “Agents as First-Class Citizens” with persistent storage, state management, and an integrated AI assistant.

AI Automation & Workflows

OpenAI Workspace Agents are, according to Nate B. Jones, the week’s most important automation release: integrated into ChatGPT, available for Workspace and Enterprise plans, replacing Zapier and Make for recurring cross-tool workflows — provided the job is clearly defined, weekly recurring, and anchored in two or three tools. The critical limitation: not suitable for unknown paths or long-term autonomous work. Julian Ivanov presents Mirofisch, an open-source project for AI swarm simulations of social dynamics: virtual personas with their own opinions simulate reactions to product launches or price changes across five phases, from knowledge graph to deep agent interaction. Productive Dude shows three levels of automation with Claude — from skill-based chat to a fully custom CRM platform with MCP server integration.

AI Business, Marketing & Freelancing

Nate B. Jones provides a directly actionable method for pushing better AI tools in corporate settings: instead of tool criticism, quantify the economic damage — run a job weekly in parallel with both standard and candidate tools, measure time and quality, scale up at the department level, then escalate with data instead of frustration. The Salesforce Filter framework from the same channel — five questions that separate infrastructure from feature traps — is directly applicable to procurement decisions. Zubair Trabzada shows a crypto analysis tool built with Claude Code featuring five parallel agents (On-Chain, Tokenomics, Sentiment, Technical, Fundamental) that runs as a Skills system in Visual Studio Code or Claude Code and generates PDF reports with scores and action recommendations.

PKM & Knowledge Management

Leon van Zyl demonstrates the Consensus MCP, making over 200 million peer-reviewed papers directly available in Claude Desktop and Claude Code — with a specialized medical mode for eight million professional publications. The result: every answer is backed by real source links rather than blog references, and developers can integrate a built-in research chatbox into their apps. Nate Herk’s AIOS course covers the Obsidian-based LLM knowledge wiki following Andrej Karpathy principles: markdown files as structured knowledge base that Claude searches and maintains, scaling to ~100,000 pages without classical RAG overhead. Melvynx explains prompt caching at the Claude API level precisely: cache writes cost up to 90% less than regular input tokens, TTL is configurable up to one hour — and tool sets should never be dynamically shown and hidden because every change completely invalidates the cache.

Prompting & AI Literacy

Tech With Tim sketches a five-stage Python-for-AI learning path that explicitly addresses tutorial hell: learn only the necessary Python subset, then immediately build a first 10-line script with OpenAI or Anthropic API keys, followed by three graduated projects (chatbot with memory, file summarizer, tool-using agent) — all taking a maximum one weekend per project. Kyle Balmer resets GitHub fundamentals for vibe coders: repo as single source of truth, GitHub Desktop instead of terminal, and the concrete use case of uploading transcripts to Claude Code to generate newsletters, scripts, and carousels. Google DeepMind’s multimodal Medical AI system, which reaches or exceeds general practitioner level in 68 of 140 aspects of clinical consultations, illustrates pragmatically where AI acts independently today — and where earlier conclusions still lead to errors.

AI Industry & Strategy

Salesforce’s “Headless 360” exposes all CRM capabilities as APIs and MCP tools, allowing external agents direct access to customer data without using the UI — the week’s underestimated infrastructure story according to Nate B. Jones. His separate deep dive into issue trackers (Jira, Linear) as accidentally perfect agent substrate explains why persistent records, state machines, audit history, and permissions models have since Bugzilla 1998 offered exactly what agents need for multi-run coordination — and why Atlassian’s Rovo MCP server strategically elevates this value. Apple CEO change to John Ternus (hardware engineer responsible for the Apple Silicon transition) and John Giannandrea’s promotion to Chief Hardware Officer are read as signals that Apple is not competing in cloud AI but positioning on-device inference with fixed costs as an alternative to variable cloud billing — with a vast untapped audience in compliance-sensitive industries. The Baseten CEO conversation (No Priors) illuminates the inference cloud layer: applications are protected by workflow-specific data, not models themselves; multi-chip worlds and long-horizon agent workloads are the next strategic investment frontiers.

AI & Society / Future of Work

The German Everlast AI roundtable with Pero Mitic, Andreas Moring, and Kim Isenberg discusses three scenarios for a post-labor society — horror scenario (social unrest), crisis scenario (transition difficulties), and abundance scenario — and reaches no consensus except the necessity of redistribution and broader societal debate. George Hinton’s “Jobless Boom” warning starting in 2026 (productivity growth without employment growth) is backed with concrete figures in the Datapizza video: Microsoft Quota-70 initiative, Meta plans 15,600 layoffs, Amazon and Oracle 30,000 each. Tech With Tim analyzes the 2026 software development market: entry-level positions fell 46–67%, 22–25-year-olds in AI-exposed jobs lost 6% employment since end of 2022 — the bottleneck shifted from code writing to code review, system design, and observability. Kyle Balmer formulates the practical consequence: the risk-reward ratio of a 9-to-5 has deteriorated so much through AI that the first independent income stream — even small — becomes structurally more important than ever before.

Briefly Noted

MCP ecosystem grows: MoureDev explains MCP (Model Context Protocol) as the “USB-C of AI” with a live demo of a Python MCP server and Beehive newsletter integration; Anthropic handed the standard to the Linux Foundation end of 2024. GLM OCR locally: Simone Rizzo shows GLM OCR (94.62% on OmniDoc benchmark, 2 GB via Ollama) for local PDF-to-Markdown conversion — ideal for compliance-sensitive documents without cloud upload. FastEmbed: NeuralNine introduces the FastEmbed Python library with ONNX runtime for local text and image embeddings, including Qdrant integration. SQLite history: Coding with Lewis tells the origin story of SQLite (Richard Hipp, 1998, today on every Android device) and the LibSQL fork as a reaction to its closed contribution model. MongoDB vs. Postgres: Melvynx argues sharply against MongoDB for 99% of projects and recommends Postgres with strict schema or Convex for reactive apps — especially because LLMs cannot self-correct without schema feedback. AI courses compared: Tech With Tim reviews 20 AI engineering courses and recommends DataCamp (interactive, production deployment), Deep Learning AI Short Courses (modular, Andrew Ng), and UC Berkeley’s free Full-Stack LLM Bootcamp (for advanced learners). OpenAI hardware leak: Reuters reports on OpenAI chips with Qualcomm and MediaTek for a possible AI smartphone 2028, contextualized by TheAIGRID with the $6.4 billion acquisition of Jony Ive’s IO firm — likely a screenless “quiet” device and later smartphone run in parallel. Nick Saraev shows how to run Claude Code with Open Router backends (DeepSeek V4 Flash, GLM 4.7, Gemma 4) at 2–5% of Opus costs. Niklas Steenfatt delivers a German-language OpenClaw beginner tutorial with Hostinger VPS, Tavily, Notion, and Deepgram integration.

AI Explained

No new videos in this period.

AI Foundations

No new videos in this period.

AI with Arnie

No new videos in this period.

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

• Anthropic Might Buy Atlassian For $40B. Here’s Why It Makes Sense.
  2.5.2026, 15:00:31

  Summary: Issue Tracker as Agent Infrastructure

  Core thesis: Issue trackers like Jira and Linear weren’t built as agent systems – but they’ve accidentally evolved into their perfect substrate infrastructure. That’s the bigger story of 2026: boring enterprise tools are becoming more strategic, not less.

  The paradox: The Linear CEO said in early 2024 that issue tracking was dead – the manual conversion of messy reality into tickets should become obsolete. A month later, OpenAI released Symphony, an open-source spec for autonomous coding agents, whose central idea is: Use an issue-tracker board (specifically Linear) as a control panel for agents. Not replacement – control layer.

  Why agents need issue trackers:

  • Persistent state: The context window is not a source of truth. Agents need state outside the model that persists across multiple runs
  • Clear ownership: The assignee field shows who’s working on what
  • State machines: Status defines legal transitions and handoff semantics (active, waiting for review, blocked, completed)
  • Audit history: Queryable logging: who changed what, when, from which to new state
  • Coordination at scale: Hundreds of agents need a system that manages locks, blockers, and priorities – not manual coordination
  • Permissions & governance: Agents shouldn’t be able to do more than the human assignee – permissions are built in

  Historical origin (since Bugzilla 1998): These structures (records, verbs like create/assign/resolve, dependencies, audit trail) were designed for human asynchronous coordination across time zones. Human weaknesses (memory loss, context drift) surprisingly mirror agent weaknesses. That wasn’t accident – or maybe it was, because we designed agents after human patterns.

  Why this recurs in CRMs, service desks, ERPs, etc.: Tools with persistent records, explicit ownership, state machines, verbs, and history become agent substrate everywhere – regardless of whether they were built for it:

  • CRM (Salesforce, HubSpot): Deals as state machine (Prospecting → Closed Won/Lost), ownership, history
  • Service desk (Zendesk, Service Now, Jira Service Management): Tickets, assignees, SLAs, escalation, permissions
  • ERP/Finance (SAP, Oracle, Workday): Business objects, approvals, audit trails for real business work
  • Source control: Pull requests as coordination, reviewers, status
  • Calendar, HR systems, procurement: All have the same underlying structure

  Weak candidates: Email and Slack are too conversational – the verbs are weak (Reply, Forward), state is implicit, not encoded. Agents can read Slack, but Slack itself isn’t a strong control panel. Spreadsheets are chaotic because schema is often undocumented and user-dependent.

  Strategic implication for Atlassian/Salesforce/Service Now: These companies own the largest installed bases of agent-readable workstate in the world. In May 2025, Atlassian launched its Rovo MCP Server (beta), making Jira and Confluence agent-readable and agent-writable – exactly the pattern Symphony takes with Linear. That’s not just integration – Atlassian is making its system agent infrastructure. The rumors about a possible Anthropic acquisition make sense: the control panels of enterprise are valuable.

  For product developers: Don’t start with chatbots in the UI. Instead, make the data model clean: expose records, define verbs, make ownership explicit, preserve history, build permissions into the model. Opaque products force web scraping and guessing (fragile). Clean state and clean verbs = real agent integration.

  For teams: Choosing between Jira vs. Linear is now also an agent infrastructure choice. Messy operations were a human problem (people compensate). Messy data is an agent problem – agents need readability. Clean workflows and enforced fields aren’t just hygiene, they’re AI-readiness.

  For leaders: The old ritual aspect of issue tracking is dying (Kari was right). But the substrate isn’t dead – it’s being promoted. Human handwriting work disappears, the underlying state layer becomes essential. Companies sit on unique patchworks of agent substrates (ERP + CRM + tickets + voice-of-customer). The real value lies in mapping these and connecting them through real connectors and agentic pipelines – not tearing them apart and starting over.

  Longer-term game: Greenfield agent platform stories are suspicious if the platform doesn’t own the records, permissions, history, and user habits themselves. They become wrappers around existing systems. Wrappers can be valuable, but substrate ownership is strategically better.

  Deep dive into enterprise tools and agent architecture with focus on strategy; no AI models or specific agent-level vendors explicitly discussed (only OpenAI Symphony and Anthropic mentioned).

• RTX 5090, Mac Studio, or DGX Spark? I tried all three.
  1.5.2026, 14:01:13

  Summary: The Personal AI Computer

  The central idea: The trend of the last 15 years was personal computing migrating to the cloud – files, apps, storage became managed elsewhere. AI agents reverse this because useful agents need local access to files, processes, permissions, and storage. That makes the local computer important again. Cloud models aren’t getting worse – they’re moving closer to your machine (e.g., through code editors with local repos) instead of further away.

  The ownership question gets sharper: When agents touch your files, run through your workflows, and store your decisions, you should control what you keep and what you rent. Open-source models are getting rapidly better – not as good as the best closed-source frontier models, but good enough for many private, sensitive tasks.

  The stack has multiple layers:

  1. Hardware: No universal answer – depends on workload. Mac Mini M4 Pro with 64GB unified memory is a good entry point for private writing, notes, local code assistance. Mac Studio for more memory. CUDA path (RTX 5090) for throughput and ecosystem support, but with maintenance overhead. Nvidia DGX Spark as appliance version. AMD Strix Halo as wildcard with still immature software.
  1. Runtime (software for model execution): llama.cpp is the base, GGUF the format. Ollama is the practical standard – clean CLI, local server, OpenAI-compatible API. LM Studio for testing and quantization, MLX for Apple Silicon, vLLM for serious Nvidia deployments at team scale.
  1. Models: No single model wins all use cases. Instead, a portfolio: small model for fast loops, stronger for local work, specialized models for code/media/embeddings, cloud models for edge cases. Mentioned options: Llama 4 Scout/Maverick (Mixture of Experts), GPT-OSS (OpenAI, under Apache 2.0), Qwen (for agents/coding/multilingual), Gemma (small, capable local models), Mistral (open alternatives).
  1. Memory (storage of your work): The most critical layer. Your memory should belong to you, not the model provider. Options: Open Brain (SQL + embeddings hybrid, with MCP), Obsidian (for documents in Markdown), Postgres with pgvector, SQLite with SQLite vec. The system must differentiate chunking strategies (PDFs different from Markdown, transcripts with timestamps, code with symbol indexing). Keep raw data and embeddings separate so you can re-index when better embedding models come out.
  1. Retrieval and tools: MCP (Model Context Protocol) as interface to your database, so Claude/ChatGPT/custom tools can query – but with permissions, logging, secrets management, not just “model has access to everything”.
  1. Interface: The model must live where you work – not just in the terminal. Open Web UI for chat, Anything LLM for retrieval-focused, LM Studio for direct model work. Continue for code editors, Aider for terminal coding. Voice is underestimated: Whisper for transcription, local/hybrid models for intent + routing. Many surfaces, one stack underneath – editor, note-taking app, browser, launcher, terminal, voice should all use the same local runtime and memory layer.
  1. Workflows: Personal RAG, private code assistance with repo access, meeting capture (Whisper + summarizer locally), long-running agents (economical with local inference), hybrid research & synthesis (local models for retrieval/prep, cloud for heavy synthesis tasks).

  Three persona examples:

  • Local-first knowledge worker: Mac Mini M4 Pro 64GB or Mac Studio 128GB, Ollama, LM Studio, MLX, Whisper, SQLite/Open Brain, Continue. Keeps a cloud API for hard calls.
  • Local maximalist: High-memory Mac Studio or DGX Spark, Postgres + pgvector, MCP with permissions & audit logs – complete local control.
  • Developer/small team: Dual RTX 5090 or DGX Spark, Ollama for prototyping, TensorRT LLM for production, focus on batch jobs and high-volume inner loops.

  Key principles:

  • Ownership > dependence: Cloud models are visitors to the system, not its rulers.
  • Extensibility requires boundaries: Agents should have permissions (write agent has no shell access, code agent no bank data).
  • Memory must be auditable: You should be able to inspect, delete, trace what was stored.
  • Hybrid is realistic: Rare, hard, high-value work goes to the cloud, repetitive/private/context-heavy work stays local.

  Why a personal AI computer makes sense now: Not to “beat the cloud,” but as inversion of cloud dependence. Instead of cloud providers owning your memories and workflows, you own them. Frontier models stay relevant for the hardest tasks, but daily assistance, memory, tools, workflows belong to you. That’s long-term not about cost savings (though those are real) but about condensing your knowledge over time – PDFs, notes, transcripts, code repos, media files remain your source of truth, embeddings and databases can improve, but your work isn’t trapped in a proprietary app anymore.

  No transcript version available – summarized from video text.

  This video covers a deep dive into local AI infrastructure beyond cloud APIs and frontier models, with concrete hardware, runtime, model, and memory recommendations plus personal use cases. (Opinion/deep dive; no specific AI tool/vendor mentioned – conceptual overview of local stack architecture, references to cloud models contextualized throughout.)

• Microsoft Is Testing Claude Against Its Own Copilot. Here’s Why.
  30.4.2026, 14:00:29

  Summary: How to push better AI tools in your organization

  The speaker addresses a core problem many organizations face: The company approved a standard AI tool (typically Copilot, Gemini, or similar), but it doesn’t meet actual work needs. Teams know this, use better alternatives quietly, yet whoever voices the standard’s inadequacy looks disloyal or picky – instead of trying to get work done.

  Why criticism fails: The mistake is criticizing the tool itself (“Copilot is bad”). That reads as personal preference and gets ignored. Instead, you must quantify the economic damage – not the feeling, but lost time.

  The right reframe: Not “rip out the default,” but: “For this specific job class, the standard costs us four hours a week extra. I can prove it.” That’s a performance claim, not an opinion. The question becomes: Which specialized add-on license costs less than saved time?

  The measurement: Pick one recurring weekly job (at least 30 min., with real output audience – not private), run it in parallel through standard tool and candidate tool. Measure: processing time, needed rework, quality, whether you’d actually send the result. After one week you have 5–15 data points – real, comparable evidence.

  Extrapolation: Talk to colleagues in similar roles, recognize the pattern org-wide, multiply the hours. Suddenly it’s not a personal opinion but a recognized productivity loss across a whole department.

  Escalation by role:

  • To your manager: “I have data. Here’s the protocol. Claude saves me 4 hours. Can I get a license?”
  • To the director: “Three people measured this. Can we pilot it for this job class a quarter?”
  • To the executive: “How would we know if our default tool costs us? We should measure – and know: talent leaving over poor tools is real.”

  Common objections & responses:

  • “We already paid for it” → Sunk cost; the question is only the incremental benefit per hour.
  • “That’s Shadow IT” → No, Shadow IT is hidden; here you’re bringing it into process.
  • “We have to standardize” → Yes, but smarter: standard where it fits, specialist where needed – like Excel/Tableau in analytics.
  • “We don’t accept new vendors” → Ask what the real blocker is (data residency? admin control?). If the answer is just “no,” you’re facing talent flight.

  The broader truth: Firms with real AI-native culture don’t have this problem – they give ICs budget and freedom to choose the right tool, then standardize after on real usage. Traditional procurement breaks under AI; this guidance creates cracks in the process that lead to better decisions.

  This week: Pick one job, one measurement, gather data. Then ask precisely for what the data supports. Don’t argue from frustration – argue from evidence.

  The video illustrates with a concrete example: sales ops lead where Copilot takes 90 min for pipeline reports, specialist tool 15 min with better quality – basis for a data-backed request.

  Core message: Talent is already concentrating at firms with better AI tooling. If you don’t implement this measurement, you lose people.

  Note: Video without provided transcript; summary based on title and plotted voiceline of author. – Discussed without naming specific tools: talk about Claude, GPT, Codex, etc. as examples of specialist vs. standard; no deep dive in specific tool – opinion/reflection with structured how-to.

• Salesforce Killed The Browser. Every Agent Runs Your CRM Now.
  29.4.2026, 14:01:07

  Summary: The practical filter for AI agent releases

  The core message: The agent landscape is no longer “which product is best,” but “which agent fits which task and which infrastructure.” The speaker introduces five filter questions to distinguish relevant launches from hype:

  1. Does it fit into existing tools or force migration? – Infrastructure improves your current environment; features are migration traps.
  2. Can other agents build on it or is it closed? – Openness creates composability; closed products stay one-offs.
  3. Does it access data that matters to you? – A middling agent with your context beats a brilliant one with an empty window.
  4. Is an ecosystem forming? – Marketplaces, SDKs, consistent updates signal staying power.
  5. Can you stack agents on it? – Composition multiplies; new agents only add.

  The five releases through the filter:

  • OpenAI Workspace Agents: Strong for shared, recurring cross-tool workflows in ChatGPT and Slack; less advantage if work natively lives in Salesforce or Microsoft 365.
  • Salesforce Headless 360: The underestimated infrastructure story – exposes all Salesforce capabilities as APIs and MCP tools, so external agents can access CRM data directly without touching the UI.
  • Microsoft Copilot Wave 3: Strong on Microsoft 365 native teams (mail, SharePoint, Teams, PowerPoint) via Work IQ data access and permissions; weak on cross-ecosystem workflows and enterprise composability.
  • Moonshot Kimmy K 2.6: Technically impressive with 300-agent swarms; but for enterprise mostly irrelevant – only relevant for dev teams wanting to build self-hosted agent infrastructure with open-weights.
  • Perplexity Personal Computer: Good for research-heavy work that ends in an artifact (market analyses, sales prospectuses); weak on team-shared, recurring processes with governance requirements.

  The reframe to layering: Claude, ChatGPT, Copilot and others are no longer either/or choices. Claude now appears at least three different ways: as a direct product (claude.ai), embedded in other products (Perplexity, Salesforce, Microsoft), and as managed agent infrastructure (Claude Managed Agents). The right question isn’t “Which model do I switch to?” but “Which wrapper around which model fits this task and this data environment?”

  The practical routing logic:

  • Direct agent for model-centric work (coding, novel reasoning)
  • Wrapped agent for data-/workflow-centric work (Microsoft Graph, Salesforce CRM, research artifacts)
  • Different model if the product ecosystem creates more value than the model margin

  Demo, news roundup; no specific AI vendors themselves reviewed, but five current enterprise releases (OpenAI, Anthropic, Salesforce, Microsoft, Moonshot, Perplexity) analyzed through an infrastructure-filter framework – practically oriented, less benchmark focus.

• GPT-5.5 vs Claude vs Gemini: The Real Difference Nobody’s Talking About
  28.4.2026, 14:00:14

  Summary: GPT-4.5 – Reset of performance standards

  The author argues GPT-4.5 isn’t just marginally better than the previous version, but redefines the fundamental capabilities of AI models – particularly an improved ability to carry complex, multistep work across longer contexts. The real novelty isn’t improved benchmarks alone, but how that changes what you can reasonably delegate to a model.

  To demonstrate, the author conducted three demanding tests beyond typical simple tasks:

  • Dingo & Company (87.3 of 100 for GPT-4.5): A business case for a fictional Dingo litter box startup requiring 23 deliverables (decks, spreadsheets, PDFs, interactive dashboards). GPT-4.5 created real, production-ready artifacts and demonstrated correct legal and ethical understanding of the complex situation. Claude Opus 4.7 scored 67.0, earlier Sonnet models 65.0, Gemini 49.8.
  • Splash Brothers (data migration for a car wash company with 465 files): GPT-4.5 was the first model to deliberately catch planted errors (Mickey Mouse as customer, fake $25,000 payments, duplicates) and got 186 out of 192 target customers correct. However, it showed weakness here: the model missed backend hygiene details like enum normalization and service code conflicts – even a regression versus GPT-4.4 in some areas.
  • Artemis 2 (interactive 3D visualization of NASA’s Artemis 2 mission): Claude Opus maintained an advantage in visual composition here; GPT-4.5 was denser in information but appeared more cartoonish. Both models lacked precise control.

  Practical implications for workflows:

  The author doesn’t recommend one single model, but routing by task:

  • GPT-4.5 in Codex for complex, multistep execution work with files, code, tools, and browsers – this is where the biggest improvement shows
  • Claude Opus 4.7 for visual design from scratch, aesthetics, and blank-canvas frontend work
  • Images 2.0 + GPT-4.5 for UI work with visual reference material rather than invention from nothing
  • Validation and review for data work, financial, legal, and production data requires human review

  A crucial practical point: GPT-4.5 in Codex is the decisive difference, not ChatGPT. Codex enables real agency – file access, code editing, browser control, self-iteration – which multiplies model quality.

  OpenAI’s product strategy appears synergistic: GPT-4.5 delivers reasoning, Images 2.0 visual direction, Codex the environment. Also: availability is product quality – OpenAI currently shows higher uptime (three nines) than Anthropic (one nine), which is critical for productive use.

  The core argument: The model itself didn’t just get incrementally smarter – the underlying pretraining is more robust. Both fast mode and thinking mode benefit. That doesn’t show in pure benchmarks but in real-world scenarios with incomplete briefs, messy files, and contradictory sources – exactly where earlier models broke down.

  Two anecdotal business ideas to illustrate: Palm reader apps (Images 2.0 + Codex) or custom Lego designers (same stack) are now achievable as solopreneur projects.

  Essence: 5.5 isn’t perfect (still not suitable for uncontrolled production data), but it’s the highest level for what a single model can carry in real work. The old question “Can the model answer this?” is too small; new: “What ambition can I now trust to the model?”

  Explicitly mentioned tools/models: GPT-4.5, Claude Opus 4.7, Claude Sonnet 4.7, Gemini 3.1 Pro, OpenAI Codex, Images 2.0, ChatGPT — Opinion/reflection + deep dive based on private benchmarks.

• OpenAI Just Gave Every Team A Free Employee. Here’s The Catch.
  27.4.2026, 14:00:47

  OpenAI Workspace Agents: A new automation layer for teams

  Core claim: OpenAI launched Workspace Agents as a direct competitor to established automation platforms like Zapier, Make, or N8N – but with a critical difference: the first useful automation now takes just an afternoon instead of months if the job has the right shape.

  What’s in the product: Workspace Agents are integrated into ChatGPT, available for Workspace, Enterprise, and Education plans (in research preview from April 22). You describe a workflow in English, the agent builder helps assemble tools (Google Calendar, Drive, Slack, SharePoint, custom MCP servers), write instructions, and preview before publishing. Agents run on schedule and directly in Slack – not in a separate tab, which is psychologically crucial: if the tool works where work happens, it doesn’t stay optional.

  Why this differs from Custom GPTs and Projects: Custom GPTs are basically “a prompt in a suit” – quality depends heavily on the prompt writer and helps only marginally with coordination-intensive tasks like ticket triage. Projects added shared workspace and context, but required massive manual coordination. Workspace Agents can automate multiple steps, navigate between systems, use files, and integrate work into team context – they “carry more of the process” rather than just generate text.

  Where Workspace Agents work (the right shape): The job repeats (typically weekly), has clear outputs (good vs. bad), fits in one paragraph, and crosses at least two to three tools. Examples:

  • Sales: Opportunity-brief agent (research + Gong summary + deal brief in Slack = 5–6 hours/week saved)
  • Coordination: Overnight-feedback synthesizer (reads team channels, extracts themes/blockers, posts morning brief)
  • Product: Feedback router (monitors Slack/support, deduplicates, groups by product area, weekly digest)
  • Customer success: Support-ticket router (deduplicates, tags, checks against known issues, drafts or escalates with context)

  Where it doesn’t fit: Not suitable for novel research, one-off artifacts, or long-horizon autonomous work where the path changes over days. The critical distinction: “If the path is known, it gets really interesting. If the path is unknown, be careful.” Wrong is to test the agent on the hardest task (invent Q3 strategy) – instead test a known recurring weekly job.

  Governance as key: This is where OpenAI will sell enterprise. Admins can control who builds/publishes, which apps are allowed, which actions need approval. There’s version history, audit logs, and API coverage for compliance. Critical: role-based controls for agents with personal connections – if someone publishes an agent with their own account, others can execute data/actions through those connections. Least-privilege principle recommended (service accounts, restricted scopes, audit).

  Strategic context – who gets displaced: Not primarily other AI models, but the automation layer of Zapier, Make, N8N, and internal ops workflows. Workspace Agents become the default answer for recurring workflow automation before switching to dedicated platforms. That changes ops roles too – away from fragile automation management toward design, testing, and agent governance. Broader pattern: independent agent framework builders integrate into large AI platforms (e.g., OpenClaw founder to OpenAI). OpenAI’s strategy is clear: position Workplace Agents as the standard OS for corporate work, with Codex as the execution layer. That differs from Claude’s more vertical strategy (Figma-killer for design, etc.).

  How to start (free before May 6): Pick a job running 5–6 hours/week, with clear outputs, crossing 2–3 tools, and with a human reviewer. Write it out concretely (e.g., “every Monday read support tickets from the week, group by product area, identify top issues, post digest in Slack”). Use the builder, connect only necessary tools, optimize instructions an hour, push to Slack channel, run a week. Then don’t ask “Is it impressive?” but: Did it save time? Did review burden stay under saved time? Would the team miss it if gone? That’s real signal. Iterate, don’t chase perfection – 60% first time is okay.

  Warning against promises: Big hurdle for AI adoption: when leaders promise “will get easier” and teams find it “gets harder.” Focus is on load-lifting for teams, not impressing.

  OpenAI (Workspace Agents), Zapier/Make/N8N (as competitors), Claude (mentioned as strategic contrast) – deep dive with practical orientation for beginners and teams of medium complexity.

• Apple Just Positioned Itself for the Next Trillion Dollars
  26.4.2026, 17:00:36

  Tim Cook steps down as Apple CEO and is replaced by John Ternus – a hardware engineer who led Apple’s Intel-to-Apple-Silicon migration on Mac. Beneath him, John Giannandrea, longtime head of Apple’s chip design, is promoted to Chief Hardware Officer. This staffing signals Apple won’t fix the cloud AI competition gap through faster software iteration, but by redefining the game itself.

  The core problem in the cloud AI industry: The biggest frontier labs lose money on their premium subscriptions (OpenAI with ChatGPT Pro, despite $200/month). Capable AI for serious users costs more to run than any consumer price covers. Investor capital currently obscures this, but GPU capacity and power are real constraints. The result is two-tier AI: large enterprises with seven- to eight-figure contracts get real AI; everyone else gets throttled, metered consumer-tier access.

  Apple’s alternative: on-device. On-device inference has fixed costs (the chip was paid for with the phone); a thousand queries cost the same as one – essentially nothing per request. Cloud inference has variable costs that eventually pass to users. Apple echoes a historical parallel: in the 1970s, computing was a service you rented (mainframe). The Apple II moved useful computing capacity onto a device you owned – and afterward cost nearly nothing per use. Power users invented new categories on it (VisiCalc); the same might happen now with AI.

  One specific overlooked buyer group makes this bet bigger: law firms, medical practices, tax offices, financial firms, therapists – all with high data-protection standards (attorney-client privilege, HIPAA, fiduciary duty). They can’t use cloud AI without compliance risk. Many now just buy Mac Minis retail and run local models – a makeshift solution to a large, unsolved problem. Apple hasn’t built enterprise form factors, clustering software, HIPAA BAAs, or a regulated model ecosystem. That’s a trillion-dollar market (US alone), and a massive unoccupied opportunity remains for Apple or a startup wrapping Apple hardware in an enterprise layer.

  Different consequences emerge for different audiences: Executives should learn that under structural disadvantage you don’t optimize the system – you change it. Builders should make native AI products, not just AI-enabled – categories where inference costs must be zero. Pro users should question their cloud token limit dependence and explore local AI, plus prioritize data hygiene; hardware generation (M-chip iterations) will increasingly matter for their work.

  The race Apple resets isn’t a retreat – it’s an inversion: the industry runs the cloud meter higher (more data centers, more capex). Apple quietly suggests the device in your pocket could be what counts. The same company that put useful computing power in private hands 50 years ago might do it again with AI.

  Explicitly mentioned: OpenAI, Sam Altman, Anthropic, Claude, Qualcomm (indirectly as competing ecosystem); Format: Opinion/deep dive with structural industry analysis and multiple perspectives.

Alejandro AO (1 new video)

• DeepSeek V4: SOTA Coding Agent at 12x Lower Cost
  28.4.2026, 09:43:58

  The video introduces the new DeepSeek V4 Pro and DeepSeek V4 Flash models from DeepSeek, a major Chinese AI company that sparked the open-source revolution for large language models in 2025 with its R1 model. The new models are Mixture-of-Experts architectures that operate more efficiently through selective parameter activation. Comparisons with other state-of-the-art models like OpenAI’s GPT-5.5 and Cloud’s Opus 4.7 show that DeepSeek V4 Pro performs exceptionally well across various benchmarks including coding, general reasoning, and agentic capabilities, sometimes even outperforming GPT-5.4 and coming close to GPT-5.5. Particularly noteworthy is DeepSeek’s significantly more affordable pricing compared to closed models. The video also demonstrates installing and using DeepSeek V4 Pro via the Pi Agent-Harness, a minimalist agent framework, and shows creating a web application as an example of practical implementation.

  The video explicitly covers the models DeepSeek V4 Pro and V4 Flash as well as GPT-5.5, Opus 4.7, Gemini 3.1 Pro, Kimi K 2.6, GLM 5.1, and Minimax M 2, and is aimed at intermediate users.

Alex Finn (5 new videos)

• LIVE: OpenClaw vs Hermes Agent: The ultimate showdown
  1.5.2026, 20:48:54

  The YouTube video showcases a live stream comparing different AI agents in a head-to-head matchup. The main competitors are OpenClaw and Hermes, each running with the ChatGPT and Opus models. The stream is divided into multiple tests that evaluate the agents’ capabilities across various task categories.

  1. Test 1: Real-time Stock Dashboard
  • OpenClaw with ChatGPT: Fastest completion, but with an unattractive user interface (UI). Functionality was rated as solid.
  • Hermes with ChatGPT: Slower and crashed the computer, resulting in a poor rating.
  • OpenClaw with Opus: Slower than the ChatGPT version, but with a slightly better UI and additional features like Trading View integration.
  • Hermes with Opus: Best UI and functionality, but slower than OpenClaw with ChatGPT.
  1. Test 2: Game Development
  • OpenClaw with ChatGPT: Fast, but unplayable game.
  • OpenClaw with Opus: Playable, but not particularly entertaining.
  • Hermes with ChatGPT: Unplayable and poor graphics.
  • Hermes with Opus: Best graphics and playability, rated as actually entertaining.
  1. Test 3: Website Recreation (Apple.com)
  • Hermes with Opus: First to finish, but below-average accuracy.
  • OpenClaw with Opus: Better than Hermes with Opus, but not perfect.
  • OpenClaw with ChatGPT: Most accurate, nearly perfect.
  • Hermes with ChatGPT: Perfect recreation using screenshots, but ethically questionable.

  The stream ends with Hermes with Opus in the lead, followed by OpenClaw with Opus and OpenClaw with ChatGPT. Hermes with ChatGPT falls significantly behind. The remaining tests will continue in the next live stream.

  Final Comment: The video explicitly covers AI models Claude (Opus), OpenAI (ChatGPT), and specific tools like OpenClaw and Hermes Agent. It’s aimed at intermediate and advanced users interested in the performance and comparison of AI agents.

• ChatGPT 5.5 Codex is the greatest AI coding tool ever. Here’s how to use it
  30.4.2026, 17:54:13

  The video demonstrates how to build a complete stock investment app from scratch using ChatGPT 5.5 Codex. The creator starts by building the user interface (UI) using the integrated Image Gen 2 model, which generates five UI options. The app is then developed with a Convex database backend, implementing various features such as live data queries via APIs and portfolio tracking. The creator leverages Codex’s multitasking capabilities to simultaneously work on app development, create marketing videos using the Remotion Skill, and conduct stock research. The video also showcases automation features that perform regular code quality checks. The video ends with the challenge of expanding the app further and going live.

  The video explicitly covers ChatGPT 5.5 Codex and is suited for intermediate to advanced users.

• 🔴LIVE: The new Claude Code plugins are incredible…
  29.4.2026, 20:12:35

  Summary: Anthropic Creative Plugins – Live Game Development with Claude and Blender MCP

  The stream showcases live development of a third-person shooter game using Claude’s new Creative Plugins, specifically the Blender MCP (Model Context Protocol). The moderator starts with a simple game prototype (local test environment) and uses Claude with Blender MCP to build 3D assets – without being creatively or artistically talented.

  Core Steps:

  • Humanoid character generated by Claude and integrated into the game
  • Character rigging with custom armature adjustments (arms, legs, animation)
  • Goblins created as 3D models and added to the game as enemies
  • AK-47 rifle built from Sketchfab references as a low-poly model
  • Hamburgers designed as loot items and placed in the game
  • Animation improvements: walk cycles, knee joints, realistic leg movement
  • Hit markers and haptics added

  Side Topics (discussed extensively):

  • OpenAI vs. Anthropic comparison: OpenAI has more compute capacity and focuses on expansion, while Anthropic risks falling behind in computing power (despite better models up to Opus 4.5)
  • GPT-4o vs. Claude Opus 4.7: 4o rated as functionally superior, but Claude perceived as more pleasant to interact with
  • Codex used as a superior coding tool with unlimited access and performs better than Claude for this project
  • Retro gaming collection (SOCOM 2, Pokémon, Game Boy Color)
  • Working with AR/VR headsets to display code in real time

  Tool Insights:

  Anthropic’s new Creative Plugins (especially Blender MCP) enable non-3D artists to generate and animate complex 3D assets by having Claude prompts directly control Blender operations – what normally takes hours or days now works in minutes. This demonstrates the potential of MCPs as an interface between LLMs and specialized software.

  Explicitly mentioned tools/providers: Claude (Anthropic), Blender MCP, GPT-4o (OpenAI), Codex (OpenAI), Hermes Agent, Sketchfab — Format: Demo/Live tutorial with a playful approach and real-world challenges (camera orientation, animation bugs, performance).

• Hermes Agent w/ ChatGPT 5.5 is literally magic
  28.4.2026, 22:13:21

  Summary: Hermes Agent – Setup and Use Cases

  Hermes Agent is an AI agent that runs as a virtual 24/7 employee on your computer and handles automated tasks – similar to OpenClaw, but with some differences. Hermes’s main advantage is continuous self-improvement: with each use, the agent automatically develops new Skills and gets better. Additional advantages over OpenClaw include higher performance over extended periods (OpenClaw slows down with increased use), more reliable updates, its own affordable portal ($20/month), multi-agent capability, and fast team support.

  Setup: You install Hermes via a terminal command, select GPT 5.5 as the model (recommended due to high rate limits with only $20/month ChatGPT plan, compared to $200/month for Claude Opus), and optionally connect Telegram to communicate with the agent.

  Concrete Use Cases:

  1. Building app prototypes: Request complex apps on-the-go via Telegram (e.g., 3D rocket simulator with Three.js) that build on your computer. Use /steer to modify instructions while the agent works.
  2. Cron jobs and recurring tasks: Have the agent automatically perform stock research every 24 hours at 9 AM.
  3. Content creation: Create a YouTube Short video with Remotion in a single instruction – the agent researches the unfamiliar library, develops a new Skill, and even delivers a thumbnail.

  Self-Improvement in Action: On the Remotion task, the agent initially stumbled multiple times, corrected itself without errors, and saved a new “Remotion YouTube Short” Skill for future use – all without further input.

  Finding Personal Use Cases: Use reverse prompting (ask the agent: “What are three time-saving use cases for me?”) or note daily manual tasks and ask which ones Hermes can automate.

  Multi-Agent Strategy: Rather than choosing between Hermes and OpenClaw, use both. They have separate roadmaps, can run on ChatGPT 5.5, and can communicate via ACP protocol.

  Demo and tutorial on Hermes Agent with GPT 5.5; also explicitly covers OpenClaw, Claude Opus, Remotion, and Telegram.

• 🔴LIVE: ChatGPT 5.5 Pro greatest AI model ever?
  27.4.2026, 20:35:48

  Summary: ChatGPT 5.5 Pro Live-Stream Demo

  The streamer tests ChatGPT 5.5 Pro live against Claude Opus in multiple practical tests to prove that 5.5 Pro is currently the best coding and simulation model. By his own account, he consistently recommended Claude Code for a year, but has now switched to ChatGPT 5.5 with Codex.

  Tests Performed:

  1. 3D Solar System Simulator: Both models build functioning simulations with planets, moons, and orbital information. ChatGPT 5.5 Pro requires refinement for better lighting, then runs smoothly. Claude Opus shows flickering issues and missing features (e.g., Earth-Moon not displayed) – the streamer hints that Anthropic may be experiencing compute bottlenecks.
  1. Grand Theft Auto Simulator: ChatGPT 5.5 Pro creates a playable GTA game in one shot that works immediately. Players can pick up weapons, hijack cars, shoot. Claude Opus clearly fails – assets don’t load, the demo is unusable.
  1. Clicky AI Agent Demo: The streamer installs and live tests Clicky, a voice-controlled AI agent for macOS that accesses the screen via hotkey and can autonomously complete tasks (create websites, generate PDFs, render 3D scenes). The agent apparently uses Claude Opus 4.7 in the background. Criticism: The agent constantly monitors the screen (55% CPU load), representing a massive privacy tradeoff. The streamer recommends the open-source alternative Flicky (MIT license, local API keys) instead, which works cross-platform.

  Key Takeaways:

  • ChatGPT 5.5 Pro clearly beats Claude Opus in code generation and 3D games
  • Opus still has advantages in frontend design, but that’s the only relevant edge
  • 5.5 Pro costs $200/month (Pro plan in Codex), but worth the investment
  • The streamer recommends using both systems ($100 Claude + $100 ChatGPT optimal)
  • Clicky is impressive, but privacy-wise questionable – Flicky as a local alternative is better

  The stream lasted 2.5 hours, with the streamer also discussing his new hobby (retro Game Boy collecting), sleep optimization, Windows vs. macOS, and stock investments (Micron, Nvidia, Google).

  Explicitly covered providers/tools: ChatGPT 5.5 Pro, Claude Opus, Codex (desktop app), Clicky, Flicky (open-source), OpenClaw, Cursor, Cline, Creator Buddy (streamer’s SaaS), Henry (internal AI agent) — Format: Demo/Live test with opinion elements; Difficulty: Standard.

Andrej Karpathy

No new videos in this period.

Bart Slodyczka

No new videos in this period.

Ben AI (1 new video)

• Live Artifacts Just 10x’d Claude Cowork (Real Use Cases)
  27.4.2026, 11:02:09

  The video showcases Claude’s new Live Artifacts feature, which enables users to create personalized dashboards with real-time data from various software tools. The creator shares examples of dashboards he’s built for different business departments, such as marketing, sales, customer support, and competitive analysis. These dashboards pull data from tools like YouTube, Bitly, PostHog, Stripe, and Circle to deliver personalized insights and strategic recommendations. Additionally, users can ask questions about the data through an integrated AI chat function and, in some cases, execute direct actions such as composing and sending messages.

  The benefits of Live Artifacts lie in the centralized presentation of data from multiple sources, dashboard personalization, and the ability to integrate AI-powered insights and actions. The creator emphasizes that this feature has the potential to fundamentally transform how work is organized and executed by serving as a central interface for data visualization and automation.

  Current limitations include limited ability to execute actions, inability to share dashboards with others, and performance issues when using multiple connectors. The creator demonstrates how to create Live Artifacts by clearly communicating to Claude which data is needed and what actions the AI should perform. He recommends converting existing scheduled tasks to Live Artifacts to boost efficiency.

  Final note: The video explicitly focuses on Claude and is intended for intermediate to advanced users.

Brian Casel (1 new video)

• Multitasking With Agents: My 2026 Workflow
  April 29, 2026, 12:01:10

  The video compares the AI platforms Claude and OpenClaw in terms of their suitability for building business processes. Claude is described as trustworthy and mature, particularly for creative and strategic tasks. OpenClaw, on the other hand, is portrayed as immature but innovative, with shortcomings in setup, documentation, and reliability. Despite these weaknesses, OpenClaw has advanced the concept of agent hiring and could play a significant role in the long term. The choice of platform depends on priorities: trust and maturity (Claude) or innovation and potential (OpenClaw).

  The video explicitly addresses Claude and OpenClaw and is aimed at intermediate and advanced users who want to leverage AI tools for business purposes.

Coding with Lewis (1 new video)

• The Code Inside Everything (That Gets Zero Credit)
  30.4.2026, 14:34:52

  The video tells the story of SQLite, the most widely used yet least known software in the world. SQLite was created by Richard Hipp, a contract engineer who grew frustrated with the frequent outages of the Informix database on the USS DDG 79 warship where he worked. He decided to write his own database that wouldn’t require a separate server instance, but could read directly from a file. SQLite was born.

  The software was initially released as an open-source project and quickly gained popularity, especially after it was adopted on devices like the PalmPilot and later on Motorola and AOL mobile phones. A critical moment came with SQLite’s integration into the Android operating system, which led to explosive growth. Despite this enormous success, the team behind SQLite remained small, consisting of just three people managing all development and maintenance.

  The video highlights SQLite’s unique philosophy, which aims to avoid dependencies and maintain control over the project. This led to a strict policy of not accepting external code contributions, seen by some as both a strength and a weakness. While this ensured SQLite’s stability and reliability, it also prevented the integration of new features requested by the community.

  Some developers, including Glauber Costa and Pekka Enberg, decided to fork SQLite and create their own version called LibSQL, which pursues a more open contribution model. They argue that SQLite’s rigid structure hampers its further development. Richard Hipp, however, stands by his philosophy, emphasizing that he wants to continue developing SQLite his own way.

  The video explicitly focuses on SQLite and its developers, particularly Richard Hipp. It’s geared more toward intermediate and advanced users, as it delves into technical details and the software’s history.

Cole Medin (4 new videos)

• 🔴LIVE – Full AI Video Generation Workflow Using Claude Code + Remotion + Archon
  3.5.2026, 03:33:47

  The video is a refined version of a live workshop on AI transformation conducted jointly with Leor Weinstein. The focus is on creating a foundational system for reliable and repeatable results with AI-coding assistance. The process is divided into three phases: ideation with coding agents, building an iterative loop (PIV-Loop), and progressively advancing coding agents over time.

  1. Ideation with Coding Agents:
  • Unstructured conversations with the coding agent to gather ideas and clarify requirements.
  • Using tools like Claude Code and Jira to manage and organize work.
  • Creating a Product Requirement Document (PRD) through specific commands and skills that structure the conversation.
  1. PIV-Loop (Plan, Implement, Validate):
  • Plan: Analyze the codebase and create a detailed plan for implementing a Jira ticket.
  • Implement: Delegate coding to the coding agent based on the created plan.
  • Validate: Automated validation by the coding agent, followed by manual code review and manual testing.
  1. System Evolution:
  • Retrospective analysis after each PIV-Loop to improve systems and processes.
  • Adjusting rules, commands, and skills to prevent future errors and increase efficiency.

  The workshop emphasizes the importance of maintaining control over the process by handling planning and validation yourself, while delegating actual coding to the AI tool. It shows how to work efficiently with tools like Claude Code and Jira to boost productivity and automate repetitive tasks.

  The video is better suited for intermediate and advanced users, as it assumes viewers already have basic knowledge of software development and project management. It addresses specific tools like Claude Code and Jira.

• FULL Guide to Becoming a Principled Agentic Engineer (Build Anything with AI)
  30.4.2026, 00:00:50

  Summary: Foundational system for reliable AI-coding results

  The workshop presents a three-phase framework for AI-coding without over-engineering:

  Phase 1 – Ideation & Planning:

  Start with unstructured conversation (brain dump) about desired features, ask the AI clarifying questions to reduce assumptions. The result is a PRD (Product Requirements Document) with structured documentation. Afterwards, the AI automatically generates Jira tickets from the PRD using the Jira-MCP server – no manual ticket creation needed.

  Phase 2 – PIV Loop (Planning → Implementation → Validation):

  For each individual ticket: Execute a prime command to analyze the codebase. Use sub-agents for research (to avoid overloading context windows). Create a structured plan with planned files, task list, and validation strategy. Then start a new, fresh conversation with the AI for pure implementation – this reduces bias and increases focus. The AI writes code, runs tests, linting, and type checking itself. Afterwards, manual code review and testing follow.

  Phase 3 – System Evolution:

  Every ticket is an opportunity for improvement: analyze what went wrong and optimize your AI layer (global rules, commands, skills). Check these improvements into the repository – your whole team benefits. Over time, the system becomes more reliable and specialized to your own codebase.

  Core principles:

  • Engineer as planner and validator, not as coder
  • Separate planning at project level (PRD/features) and task level (individual ticket)
  • Artifacts (PRD, Plan.md) as single source of truth between sessions
  • Commands & skills for repeated workflows – no manual prompts
  • Human control remains over planning and review

  The example uses Claude Code, Jira, and MCP servers; the concept works with GitHub Issues/Linear/other tools though.

  Explicit tools/models: Claude Code, Jira-MCP server, Atlassian-MCP, sub-agents, agent browser — tutorial/deep-dive with live demo.

• The Complete AI Transformation Blueprint – Live Workshop
  29.4.2026, 04:46:07

  Summary: AI Transformation Workshop

  The 2.5-hour live event with Cole Medina (AI educator and former software engineer) and Lior Weinstein (fractional CTO, founder of CTO X) addresses two central themes: organizational optimization through AI (Lior’s part) and practical development with AI-coding assistants (Cole’s part).

  Lior’s Vision: “The End of Boring Work”

  Lior introduces the AAA framework – three levels of how AI affects organizations:

  1. Automation (Hands): Complete offloading of repetitive, rule-based, high-volume tasks with low judgment (e.g., weekly reports, data entry, email management).
  1. Augmentation (Suit): AI amplifies human expertise. Example: consultants with AI complete 12% more tasks, work 25% faster, produce 40% higher-quality results (Harvard/BCG study). The focus shifts from “doing” to “managing AI”.
  1. Autonomy (Brain): Digital employees – specialized agents that make decisions and act independently (with error handling and output generation).

  Critical concept – “Front Stage vs. Backstage”: Front stage is core competency (relationships, decisions, empathy, creative work); backstage is administrative work. About 60% of an employee’s time goes to backstage. No-go zones for AI: relationships, judgment calls, physical presence, empathy/creativity remain human.

  Lior shows a working operating system (CTOxOS) where specialized agents are organized by department. Each agent has an identity (prompt, knowledge, memory), skills (SOPs, playbooks), and limited tools. He presents do.ai, a discovery tool that analyzes email, Slack, and calendar to automatically identify 40–60 evidence-based agent opportunities per person.

  Core idea: Don’t replace employees one-for-one with machines, but make every team member 10x more productive. Historically: when ATMs came in the 80s, the number of tellers didn’t drop – banks opened more branches, tellers shifted to advisory work.

  Cole’s Practical Three-Step: Planning → Pivot Loop → System Evolution

  Cole teaches a simple, adaptable process for AI-powered development (not an all-in-one framework like GitHub Spec Kit, which is over-engineered):

  1. Planning (PRD creation)

  • Brain Dump → Clarifying Questions: Unstructured ideation (with voice input) → AI asks questions to reduce assumptions.
  • Create-PRD command: Generates structured document (executive summary, mission, target users, in-scope features).
  • Create-Stories command: Breaks down PRD into Jira tickets with Atlassian-MCP server (no manual ticket creation).
  • Human review: Validate artifacts before proceeding.

  2. Pivot Loop (per Jira ticket)

  • Prime command: Loads codebase context + Jira ticket.
  • Exploration: Unstructured ideation, optionally sub-agents for research (to avoid context overload).
  • Plan command: Generates structured plan markdown (summary, decisions, file changes, task list, self-validation strategy).
  • New Claude session: Fresh context for implementation (prevents bias from planning phase).
  • Implement command: Writes code, loads plan, performs validation (unit tests, linting, type checking, optional browser automation).
  • Human code review & testing: Before production.

  Cole demonstrates live a poll builder app: from brain dump (live presentation mode, QR code, multi-question polls) through automatic Jira ticket generation to working feature in a new Claude session.

  3. System Evolution

  When errors occur: don’t just fix them, but review the AI layer (global rules, commands, skills) and improve it. Goal: future agents don’t make the same mistake. Check these improvements into version control, so the entire team benefits.

  Sub-agents technique: Specialized agents for research/exploration (tens of thousands of tokens input, only summary back) keep the main agent focused.

  Q&A highlights

  • Stack Overflow collapse: From 200k questions/month (2014) to ~3,800 total (last December). But trust and community could be a comeback factor.
  • Specialized vs. monolithic agents: Specialized agents are like LEGO (interchangeable, debuggable); monolithic agents are brick walls (everything breaks if one thing fails).
  • Memory management: Less is sometimes more. Save after task, not everything. Claude MD files should be small (Anthropic research).
  • Hiring for the AI era (Lior): Look for “pilots in the cockpit,” not manual code writers. Junior devs with AI-first mindset beat senior engineers without AI adoption.
  • Reducing friction: Start with ideation/planning with the coding agent (not with writing code). The dopamine hit from good responses drives adoption.

  Message: AI isn’t the end of work, it’s the end of boring work. With clear planning, specialized agent design, and iterative system evolution, any organization can make its teams 10x more productive – without job losses, just better work.

  Claude, do.ai, and Atlassian integration (Jira MCP) were explicitly covered; format: live workshop with demo and Q&A, intermediate to advanced level (foundational knowledge of coding agents helpful, but also relevant for product managers).

• Shipping the AI Dark Factory’s First Real Application Live
  28.4.2026, 03:44:28

  Summary: Live stream on dark factory and Archon

  The streamer presents the first production-ready application of his “dark factory” experiment – a RAG chatbot that answers questions about his YouTube content and Dynamus community content. The distinguishing factor: the code was created entirely by AI, without human code reviews or code writing.

  Dark Factory setup:

  The system is based on Archon, an open-source harness builder that orchestrates workflows for AI-coding agents. To date, 122 pull requests have been merged without the streamer personally writing any code. The infrastructure runs on a DigitalOcean droplet, with an orchestrator checking for new issues every half hour.

  Archon workflows:

  Four workflows govern the entire process: triage (labeling and prioritizing issues), issue handling (from ideation to pull request), PR review, and regression testing. Regression testing uses Agent Browser CLI to automatically test the live application and identify potential bugs on its own.

  Model experiences:

  The streamer experimented with Minimax M2.7 and Claude K 2.6. Claude K 2.6 showed solid code quality but reliability issues with structured output and API timeouts. Claude Code (Anthropic) remains his top choice, though he mentions rate limits (5-hour window, $200 plan). He briefly explains that Gemini works well for RAG (large context windows) but isn’t optimal for AI-coding.

  Live demo of features:

  The app was tested live – two bugs were filed directly as GitHub issues during the stream (scroll issues with streaming, unnecessary transcript snippets), whereupon the factory automatically converted both into pull requests. Both PRs were open shortly after.

  Archon and comparisons:

  Archon differs from other tools like Open Router harnesses in that it was built specifically for orchestrating AI-coding workflows. It supports Claude, Codeex, and Pi as coding agent providers and allows mixed model usage within a workflow (e.g., Haiku for classification, Opus for complex steps).

  Dynamus community:

  The streamer noted that Dynamus celebrates its one-year anniversary today – with over 50 weekly workshops, three courses (AI agents, AI-coding, second brain), and 1,400+ members. An anniversary discount (10% lifetime) was offered.

  Further discussion points:

  • Local models and fine-tuning were briefly mentioned (Claude-distilled Qwen models already exist).
  • Eval systems for the RAG app are planned (with Langfuse, LLM-as-Judge).
  • Archon benchmarking for harnesses is on the roadmap.

  Archon workflows are configured via YAML, prompting is central, and integration with skills/MCPs works the same as direct Claude usage.

  Explicit tools/models in video: Claude (Anthropic), Claude K 2.6, Minimax M2.7, Gemini 3 Flash, Codeex, Pi, Archon (open source), Open Router, DigitalOcean, GitHub, Aqua Voice, Langfuse, Agent Browser CLI, BAML. Format: live Q&A with live demo of the dark factory system; technical level for advanced users (Archon, workflows, API integration).

Datapizza (1 new video)

• GPT-5.5 e il “Jobless Boom”
  28.4.2026, 18:05:51

  Summary: OpenAI releases and job losses in the AI industry

  OpenAI released several major products and models this week: GPT-5.5 (with agentic capabilities for autonomous task execution), Images 2.0 (enhanced image generation with coherent text and targeted editing), Workspace Agents (automated workflows across multiple platforms via chat-based configuration with MCP integration) and the Privacy Filter (locally-running open-source model for anonymizing sensitive data in texts).

  GPT-5.5 demonstrates strong benchmark performance (82.7% on Terminal Bench 2.0, 58.6% on SWE Bench Pro), but costs twice as much as 4.5 and is classified as a high-risk model with security concerns (biological and cyber capabilities). Images 2.0 competes successfully with Nanobanana Pro and produces high-quality infographics – though without watermarks or metadata marking like Google’s C34. The Privacy Filter achieves 97.43% F1-score in detecting and masking eight categories of personal data and runs locally, but doesn’t automatically validate GDPR compliance.

  In parallel, OpenAI has massively shifted its internal strategy: Sora was discontinued, Bill Peebles (Sora inventor) and Karina Wild (former CPO of OpenAI for Science) have left the company. OpenAI is now focusing more on the enterprise segment and pure product development rather than fundamental research – a pattern that once led Dario Amodei to found Anthropic.

  Meanwhile, headcount is thinning across the industry: Microsoft executed the Quota 70 initiative (offering generous severance packages to employees whose age plus tenure exceeds 70), Meta plans 15,600 layoffs by end of May with 6,000 additional hiring freezes, Amazon cut 30,000, Atlassian 1,600, Block 4,000 and Oracle 30,000 as well. These companies justify the cuts with massive investments in AI infrastructure (Microsoft plans $120 billion for summer 2026 alone). Even George Hinton, a deep learning pioneer, warns of a “jobless boom” starting in 2026 – productivity growth without employment growth. The thesis remains open as to whether AI is truly triggering a structural transformation of labor markets or if this is just classic reallocation following over-hiring phases.

  Featured providers: OpenAI (GPT-5.5, Images 2.0, Workspace Agents, Privacy Filter), Anthropic (Claude/Opus), Google (Gemini, Nanobanana Pro), Microsoft, Meta, Amazon — Format: Roundup (news update with multiple stories).

Dave Ebbelaar

No new videos in this period.

David Shapiro

No new videos in this period.

DevExpert – AI for Developers (1 new video)

• Nvidia’s new model: does it live up to the hype?
  30.4.2026, 15:01:11

  Summary: Nemotron 3 Nano vs. Quen 36 and Yenma 4

  The video evaluates Nemotron 3 Nano OVNI (30B variant in Q4 quantization), an open-weights model from Nvidia with mixture-of-experts architecture that activates only 3B of the 30B total per inference. It’s compared against Quen 36 and Yenma 4 through identical standardized tests.

  Main Results:

  Positives: Comparable speed (~63-64 tokens/second), adequate vision for simple images, functional translation, basic conversational interface.

  Critical Negatives: Fails at summarizing long transcriptions (generates hallucinations like “recipe images” out of context). Cannot download and transcribe YouTube videos, gets stuck in infinite reasoning loops. Fails to extract YouTube chapters from transcriptions (a task both other models handled excellently). Unable to count emails in inbox (returns zero incorrectly). Gets trapped with complex images without finishing. Crashes during web app creation test. Generated code doesn’t work, unappealing interface.

  Agentic Analysis: The model goes “round and round” for simple tasks, invents non-existent tools, confuses contexts between conversations, doesn’t understand what Nemotron is (thinks it’s a data management tool). In agentic tasks with skills, requires excessive iterations with no success guarantee.

  Conclusion: Despite similar requirements (32GB RAM/VRAM), Nemotron is clearly inferior to Quen 36 and Yenma 4 in consistency, complex reasoning, and agentic tasks. Recommendation: choose one of the other two models.

  Nvidia Nemotron compared against Quen 36 and Yenma 4 — Demo/Benchmark of open-weights local models.

Everlast AI (4 new videos)

• AI News: Codex “Goal” works for DAYS, Claude takes over ADS, Opus 4.7 hacked & OpenAI “Goblins”
  3.5.2026, 08:15:00

  The video covers various current developments and trends in AI technology. It starts with the introduction of Project Deal from Anthropic, which enables trading between AI models and allegedly crashed eBay. Additionally, the new objective function Codex Goal is presented, which allows AI agents to work autonomously for several days. New features of Gemini and Claude Code, which are directly integrated into CAD software, are also mentioned. The token problem of Claude Code is highlighted, which has been officially confirmed, while OpenAI Codex is heavily subsidized.

  Another focus is on the security of AI systems. Johann Rehberger, a renowned AI security researcher, demonstrates how to manipulate the memory of Claude Opus 4.7 using a ChatGPT image. He also discusses security vulnerabilities in Claude Cowork and other attack vectors.

  The video also introduces the new Meta CLI, which allows ads to be completely controlled and managed through AI agents. It shows how to use this tool to analyze campaigns and create new creatives.

  Additionally, updates in Microsoft 365 and open-source alternatives to American AI tools such as MicS for the legal sector are presented. The video concludes with a discussion of AI job losses and the impact of AGI on the job market, based on statements from Demis Hasabis and a discussion with Professor Peromitsicit and Professor Dr. Andreas Moring.

  Final comment: The video addresses OpenAI, Claude Code, Gemini, Codex and specific tools such as Meta CLI and is more suitable for intermediate and advanced users.

• The End of Work: Why 80% Will Lose Their Jobs & What Comes Next (Post-Labor Economy)
  30.4.2026, 15:15:00

  The video is a discussion about the impact of AI and automation on the world of work and society. The participants are Professor Dr. Pero Mitic, Professor Dr. Andreas Moring and Kim Isenberg, moderated by Leo.

  The discussion begins with the thesis that AI and robotics will massively replace jobs in the coming years, potentially leading to a post-labor society. It argues that this affects not only entry-level jobs but also highly qualified professions such as lawyers and doctors. The participants discuss various scenarios, including a horror scenario with social unrest and a permanent underclass, a crisis scenario with transition difficulties, and an abundance scenario in which AI and robotics lead to a life of plenty.

  Various solution approaches are discussed, including universal basic income (UBI), universal basic services, robot taxes, and promoting worker ownership. The participants agree that wealth redistribution is necessary to prevent social unrest. They also discuss the role of AI in science and the possibility that AI will gain new scientific insights.

  The discussion ends with the question of how to get the topic out of the AI bubble and into broader society. It is suggested that each individual should take the first step and discuss the topic in their environment.

  AI Tools/Models/Providers: Claude, OpenAI, Gemini, Open-Source, specific tools such as Cursor, Lovable, Cline, n8n etc.

  Target audience: Intermediate to advanced.

• Dr. Anne Greul: Claude, AI in Enterprise, Compliance, Hallucinations & the Future of Software
  29.4.2026, 15:15:00

  Anne Janzer, founder of Liehm AI (an AI-powered compliance platform), discusses simplifying product compliance through a combination of generative AI models and symbolic AI. The core problem: companies must meet thousands of individual regulatory requirements for each market – from material specifications to packaging regulations. Liehm AI creates a digital twin of the regulatory landscape and links it with company data to identify relevant requirements on a daily basis.

  Janzer emphasizes that LLMs alone are not sufficient: they additionally use rule-based symbolic AI to limit hallucinations and make results traceable – every answer is provided with source citations and direct links to legal texts. The classic problem of LLMs (a Stanford study showed that specialized AI tools hallucinate on every sixth query) is not solved this way, but made controllable.

  Compared to competitors like Harvey (more geared toward law firms), Liehm positions itself on product compliance for manufacturers that export. She sees the US as a more attractive market because regulation is more complex there and many manufacturing companies operate there. Janzer criticizes German corporations for too much skepticism and too lengthy decision-making processes – in the US, companies experiment faster and learn iteratively rather than discuss.

  On the job question in the legal/compliance field: not fewer, but different work – less copy-paste, more strategic decisions. Compliance could shift from brake blocks to enablers for more sales markets. Janzer applies her research on cognitive biases (confirmation bias, loss aversion, default bias) in her own product design and pricing. New: Christian Lindner has invested and brings regulatory perspective.

  AI models in general were discussed (LLMs vs. symbolic AI); specific tool names were not mentioned; format: in-depth conversation/interview.

• Crazy: This is What GPT-5.5 Can Do with Codex! OpenAI’s New Super-App TESTED (All Examples & Use Cases)
  28.4.2026, 15:16:00

  Summary: GPT-5.5, Codex and the Future of Agentic Coding

  The video covers the latest developments at OpenAI with a focus on GPT-5.5 and Codex as tools for automated task solving on the computer.

  GPT-5.5: Core Strengths

  GPT-5.5 masters coding tasks with less token consumption than previous models, works precisely with up to a million token context, and automates complex computer or browser tasks independently. OpenAI researchers report that the model independently completes multi-week research tasks – for example, running through complete experiment variants without humans needing to write code. On OS World Verified, GPT-5.5 achieves nearly 80% in automating computer applications (the average for human testers is 72%).

  Codex: The Central Agent OS

  Codex is not just a tool for programmers, but a central interface for every computer user. The user demonstrates live use cases:

  • Website Generation: Codex creates landing pages with design and animations via Paper MCP.
  • Mobile App Development: React Native apps with barcode scanner, reading lists and community features emerge from a single prompt.
  • Browser Automation: The Browser Use MCP enables direct control of websites – faster and cheaper than screenshot-based approaches because it uses Chrome Developer Tools.
  • Steering: A special feature of Codex: you can inject prompts during the agent’s work and adjust running tasks in real time (e.g., optimize button design live).

  Skills and Plugins: Codex accesses local folders with skills (like PDF creation, presentations) and integrates apps like Slack, Gmail, SharePoint – similar to Claude Code, but with folder upload instead of ZIP requirement.

  Codex vs. Claude (Opus 4.7): Practical Conclusion

  In direct comparison (Link-Tree website): Opus 4.7 was about 5 minutes fast and precise; Codex took 10–15 minutes, iterated more, but missed the design-skill goal. The user still prefers Opus 4.7 and Claude Code for faster, more pragmatic results – but sees Codex as a more beginner-friendly entry point into agentic coding.

  OpenAI Agents (ChatGPT Business Plan)

  New feature: Cloud-based agents directly in ChatGPT, connected with Slack, Microsoft Tools and custom MCP servers (e.g., Hugging Face). Agents can upload skills, store memories and proactively send Slack messages – further development of Custom GPTs.

  Strategic Background: Why OpenAI Discontinued Sora and Launched Imagen 2

  Sora and Prism were distractions. The real strategy: OpenAI is concentrating all computing power, talent and capital on agentic coding – the goal is to build AI systems that become AI researchers themselves and automatically train the next model. Imagen 2.0 is central to this because image generation is essential in the agentic loop: designers and product managers must visually prototype their work (mockups, websites, presentations) before backend code is written. This eliminates the classic communication need between designers, front-end and backend developers – everything runs through a single agent prompt.

  Anthropic sees image generation as a “consumer feature” and ignores it; OpenAI sees B2B core value for enterprise workflows in it.

  Central Thesis

  In 5 years, working with agentic coding (Codex, Claude Code, Skills, Agent Workflows) will be what working with Word/Excel was 20 years ago. Those who master it will be 10–1000x more productive in every task. The workplace of the future: not do the work yourself, but coordinate a “fleet” of agents like a CEO or fleet commander.

  Tools/Providers: OpenAI (GPT-5.5, Codex, ChatGPT Agents, Imagen 2), Anthropic (Claude Opus 4.7, Claude Code), Browser Use (MCP), Paper, Expo, Hugging Face (MCP). Format: Deep-dive with live demos and comparison.

Fireship (1 new video)

• GitHub is having some major issues right now…
  30.4.2026, 16:37:31

  The video “It’s 10 p.m. Do you know where your children are?” from The Code Report addresses the current problems and challenges facing GitHub, the leading platform for software development. It highlights that GitHub has been experiencing major reliability issues lately, including frequent outages, missing pull requests, and search functions that no longer work. The video creator attributes this to increasing load from AI agents using the platform as a free resource. An example cited is Mitchell Hashimoto, creator of tools like Vagrant and Terraform, who is removing his open-source projects from GitHub after struggling with outages for months. The video also mentions alternatives such as GitLab, Codeberg, and Source Hut that could serve as potential workarounds. In conclusion, it’s emphasized that despite GitHub’s problems, developers still have many options for hosting their projects.

  The video covers GitHub and Microsoft, and is aimed more at intermediate and advanced developers.

Greg Baugues

No new videos in this period.

AI and Strategy | Le SamourAI (1 new video)

• AI costs 85% less this week. You need to act on it.
  27.4.2026, 14:59:21

  The video analyzes strategic movements in AI infrastructure and models, particularly the impact of the introduction of Deepseek V4 in collaboration with Huawei. It draws a historical parallel to the Swiss watch industry and Japanese quartz technology to illustrate current dynamics in the AI market. Deepseek V4 is an open-source model specifically optimized for Huawei’s Chinese hardware, representing an alternative to US-dominated solutions like Nvidia and CUDA. The video discusses the strategic implications of this development, including potential impacts on OpenAI and Anthropic, as well as long-term effects on the AI market and the workforce.

  The video explicitly covers Deepseek V4, Huawei, OpenAI, Anthropic, Nvidia, CUDA and Google. It is designed more for intermediate and advanced viewers.

Julian Ivanov | AI Automation (1 new video)

• Peek into the future with this AI swarm intelligence (MiroFish)
  26.4.2026, 14:04:17

  The video introduces the open-source project Mirofisch, a tool for simulating social dynamics with AI agents. The 20-year-old developer from China created a platform within 10 days that enables the creation of virtual people with their own personalities, opinions, and behaviors that interact in a simulated world. Mirofisch leverages uploaded context data (e.g., market research reports, product information) and simulates reactions to events like price increases or product launches. The simulation runs in five phases: creating a knowledge graph, generating virtual personas, simulating social media interactions, analyzing results, and deep interaction with agents. The video demonstrates Mirofisch’s application using a fictional app called “Mealmate,” which automates meal planning for families. The simulation shows how different target groups react to the product, including price acceptance and potential improvements. The creator also explains how to install and configure Mirofisch locally or on a virtual server, including the use of OpenAI models and the Z-Cloud database.

  AI Tools/Models/Providers: OpenAI (GPT-4, GPT-4.1 Mini), Z-Cloud, Cloud Code, Hostinger, Open-Source (Mirofisch) – rather for intermediate users.

Kyle Balmer | AI with Kyle (4 new videos)

• GitHub for Beginners: Set Up, Connect AI Tools & Never Lose Work Again
  30.4.2026, 05:00:48

  GitHub for Vibe-Coders: A 101 Guide

  The video explains GitHub as a central solution for managing projects when working with multiple AI tools. At its core, GitHub is a shared file system — a “repo” (repository) that serves as the single source of truth for all your projects and syncs them across different tools and computers.

  Why GitHub matters: Without GitHub, you end up with multiple versions of the same project scattered across different tools (Lovable, Codex, Claude Code, Cursor), on different devices (laptop, desktop) — a mess of v1, v1.1, v2, v3. With GitHub, you have a central repository that syncs everything. This is especially critical for solopreneurs and AI developers who work across multiple tools and devices.

  Core concepts:

  • Repo: Your project folder
  • Commit: A save point; you mark changes as “done”
  • Push: Upload your local changes to the cloud repo
  • Pull: Download the latest version from the repo to your device
  • Branch: A separate copy of the codebase to test new features before merging them into the main project
  • Clone: Create a copy of an existing repo (especially relevant for open-source)

  Practical setup: Sign up for free on github.com, install GitHub Desktop (to avoid terminal commands — just write a commit message and click a button), create a private repo, then connect it to your AI tool (via the GitHub icon in Lovable, Cursor, etc.). Locally create a folder under Documents/GitHub/[ProjectName], sync it with GitHub, and open it in your AI tool.

  Beyond coding: GitHub isn’t just for code — you can also store content creation, notes, personal knowledge bases (like Obsidian vaults), book projects. The presenter uses a GitHub repo for daily content processing: transcripts are uploaded to Claude Code, generating newsletter drafts, video scripts, and carousels.

  Best practices: Don’t commit after every line, but also don’t wait until you’ve finished multiple features — each commit should be a self-contained, moderate chunk of work with a descriptive message. AI can help you build the initial folder structure and establish best practices.

  Starter task: Create a GitHub account, install Desktop, make a repo, connect it to an AI tool, create a simple draft (like a homepage) and commit it, then pull it on another device — all in 15–20 minutes. More complex features can be learned later.

  The video covers GitHub in the context of Claude Code, Lovable, Cursor, and ChatGPT Codex — a tutorial and practical guide for beginners.

• Local LLM Beginner Guide: You Can Actually Run AI For Free (No More $20/Month AI Subscription)
  29.4.2026, 05:00:48

  Summary: How to Run AI Locally on Your Devices

  The author debunks the misconception that running large language models on your own computer is too technical. He shows it only requires installing software and a model — basically a few clicks.

  Why local models make sense:

  • Privacy: Data never leaves your device, no dependence on cloud services
  • Cost: Essentially free after initial setup, instead of subscription fees
  • Offline use: Works without internet, like on flights
  • Learning benefit: Builds confidence through hands-on experience

  Practical implementation:

  The author recommends LM Studio as an entry tool — it’s free to download and has a user-friendly interface (alternative: Ollama via command line). Models typically come from Hugging Face. For beginners, Gemma 4 by Google is recommended — lightweight, runs on basically any device, even iPhones.

  Critical factor: RAM

  The decisive factor is RAM. Rule of thumb: you need roughly as many gigabytes of RAM as the model has parameters (plus two). A 27-billion-parameter model needs about 27 GB RAM. LM Studio shows a green bar indicating whether a model will run on your system. RAM gets expensive as AI demand rises; quantization (model compression) helps run powerful models on less RAM.

  Realistic expectations:

  For hobbyists: absolutely doable and recommended for experimenting. For production environments: costly — a specialized machine for $10,000+ only pays off if you’re spending thousands monthly on API credits. Smaller local models work fine for everyday chats; they typically lag state-of-the-art models by six months.

  Alternative for mobile: apps like “Locally AI” run on iPhones and iPads (e.g., with Gemma 4).

  Author’s takeaway: The biggest step is just trying it — the technical barrier is lower than you think, even if full production scenarios are more complex.

  Opinion/reflection; mentions: LM Studio, Ollama, Hugging Face, Gemma 4 (Google), DeepSeek, Qwen, Locally AI.

• Your Company Will Replace You With a $100/Month Bot. Plan Accordingly
  28.4.2026, 06:30:07

  Summary: “Jobs Are No Longer Safe — What You Can Do Now”

  The video argues that traditional 9-to-5 jobs are massively threatened by artificial intelligence — not just through direct automation of individual tasks, but also through business competition, industry disruption, and collective technological pressure. The speaker backs this with statistics: extreme youth unemployment (around 25% in London), lowest US hiring rates since 2020, 63% of US managers expect entry-level job losses, and employment rates for 20-25-year-olds in AI-exposed jobs have dropped 6% since late 2022. Even if individual tasks aren’t fully automatable, overall demand for positions shrinks when a large part of the job disappears.

  The central argument revolves around shifting risk-reward: the 9-to-5 once offered low risk + low reward. Today it offers low reward + higher risk (job, company, or industry risk), while entrepreneurship still means high risk + high reward — bringing the two options closer together. Gen Z sees this and is turning to entrepreneurship because they can’t find traditional jobs; examples include a new founder rejected by Google (now uses Claude Code) and a 22-year-old who built an AI-powered dating app and raised over $9 million in venture capital.

  The speaker addresses common objections: “Not everyone wants to run a business” — true, but if the alternative is unemployment, you’re better off taking control. “My job is creative/requires human judgment” — most jobs are 70-80% routine work, not pure creativity; AI has repeatedly broken barriers (Chess → Go), and human judgment is often flawed. “I’ll go into trades” — legitimate as self-employment, but vulnerable to oversupply and eventually robotics.

  His recommendation: keep your job (they’re getting rarer), but build a side income stream — freelance work, small services, products, whatever works. It’s not about becoming a millionaire, it’s about control and financial resilience. AI drastically lowers the barrier to entrepreneurship: website, product, marketing, customer service, checkout — all can be built today with AI help in minimal time, instead of requiring years of programming or capital raising. The psychological turning point comes with your first euro/pound earned from a stranger — that fundamentally shifts your perception of what’s possible.

  Resources: He points to his free website (aiwithkyle.com) with over 100 guides on business building, a free AI business course, and a paid $7 “Freedom OS” with structured 30-day onboarding. A daily newsletter (free) offers condensed video versions, written notes, and bonus materials.

  The video mixes data-driven concern (labor market statistics) with personal conviction: the speaker emphasizes agency and empowerment over paralysis or denial. It’s not motivational in the classical sense, but “awakening” — stirring you to action through productive discomfort.

  Format and context: Opinion/reflection with requested data evidence and case examples; references Claude and general AI tools as startup aids, but names no specific tools beyond Claude in one example; addresses a broad audience with focus on generating constructive concern, not panic.

• GPT-5.5 Released: Everything You Need to Know
  27.4.2026, 06:00:17

  Summary: GPT-5.5 Release and the Importance of “Harnesses”

  The video doesn’t focus primarily on GPT-5.5’s technical improvements, but rather on a paradigm shift: away from pure chatbot use toward AI-driven autonomous workflows supporting knowledge workers in daily tasks. OpenAI positions 5.5 with the tagline “a new class of intelligence for real work” — the model should excel at writing, coding, research, data analysis, document creation, and software operation, and independently plan and execute multi-step, ambiguous tasks.

  Core thesis: Raw model intelligence increasingly matters less. What matters is the “harness” — the ecosystem of tools, permissions, storage, iteration capability, and external system integrations (Google Drive, Notion, CRMs, ad platforms) built around the model. Claude Code and Codex are currently the best harnesses; Gemini doesn’t fail due to lack of intelligence but due to weak harness integration.

  Practical application: The speaker demonstrates giving Claude Code or Codex complex tasks (e.g., a 64-page annotated PDF with change requests) overnight and getting them completed by morning — with self-checking, iterative corrections, and a report. That’s an employee working productively while you sleep.

  Market competition: OpenAI indirectly attacks Anthropic through Sam Altman’s tweet: OpenAI emphasizes democratization (free Codex, generous limits even on the $20/month plan), while Anthropic removes Claude Code from cheaper plans and reserves expensive Opus models elitistically for governments. OpenAI also works closely with OpenClaw developer Pash to make GPT models more functional in OpenClaw.

  Criticism of Anthropic: For one month (March 2024), Anthropic reduced Claude’s default reasoning from High to Medium, making Claude Code weaker — supporting rumors about Opus 4.6 degradation and strategic 4.7 release.

  Action recommendation: Start with Codex (free on GPT plan or $20 plan), experiment with different harnesses (Codex, Claude Code, OpenClaw), don’t get too fixated on benchmarks or model versions.

  Tools/models discussed: GPT-5.5, Claude Code, Claude Opus 4.6/4.7, Codex, OpenClaw, Gemini, Anthropic; categorized as: opinion/reflection with news updates and action recommendations, technically knowledgeable but accessible to non-coders.

Leon van Zyl (2 new videos)

• Consensus MCP: Give Claude 200 Million Research Papers
  29.4.2026, 11:01:10

  The video demonstrates how to get scientifically-backed answers using Consensus MCP (Model Context Protocol) – instead of relying on unreliable AI hallucinations or surface-level Google searches. The problem: Claude and ChatGPT often confidently produce wrong answers or link to blog posts instead of actual academic literature.

  The Solution – Consensus MCP:

  Consensus is a free tool (with optional Pro plan) that searches millions of peer-reviewed papers. It offers two modes – “all” with over 200 million papers or “medical” with 8 million medical research articles. You can use it directly on consensus.app or integrate it as an MCP server in Claude Desktop App or applications.

  Setup in Claude Desktop: Plus button → Connectors → add “Consensus” – done.

  Two practical applications are demonstrated:

  1. Research-Backed Planning in Claude Code: When planning a sleep-optimization app, the agent independently researches the science behind sleep cycles and circadian rhythms via Consensus. The result: A feature list (chronotype assessments, smart bedtime calculators, CBT-I for sleep disorders) based on real studies – not model speculation.
  1. Built-in Research Chat in the App: Users can open a chatbox and ask questions; the agent responds only after researching via Consensus in peer-reviewed papers. Setup: Install AI SDK, add OpenRouter API key in .env, complete Consensus OAuth authentication in browser. Every answer is linked to actual source articles.

  Example: The question “What does research say about screen time and sleep quality?” delivers evidence-backed answers with direct links to scientific papers – not paywalls or unvetted blog posts.

  Consensus MCP + Claude Code, demo format with focus on practical integration for AI developers.

• Hermes Agent Just Killed OpenClaw (Full Tutorial)
  28.4.2026, 11:19:38

  Hermes Agent – Complete Setup Tutorial

  The video shows comprehensive setup and features of Hermes Agent, an open-source tool with over 120,000 GitHub stars, positioned as an alternative to OpenClaw. Main advantage: Hermes learns from interactions, creates its own skills, and self-improves – while OpenClaw can degrade under unfavorable conditions.

  Installation and Basic Configuration:

  Hermes should be installed on a Virtual Private Server (not locally, since agents can modify file systems). After VPS provisioning, configuration happens via web interface where you select an LLM provider. The creator recommends using an existing subscription (e.g., ChatGPT plan) via OpenAI rather than API key, as it’s cheaper. Anthropic’s Claude subscription is deliberately avoided since Anthropic blocks OpenClaw users.

  Messaging Integration:

  Hermes supports Telegram, Discord, Slack, WhatsApp, Signal, Email, and SMS. The tutorial configures Telegram: create a bot via BotFather, get an access token, and define authorized user IDs – important to prevent public access.

  Core Features in Action:

  • Browser Access: Pre-installed, works for scraping Amazon listings (supports BrowserBase, BrowserUse, FireCrawl, CamoFox, local Chrome/browser)
  • Speech-to-Text: Free via local Whisper, Telegram voice messages auto-transcribed
  • Text-to-Speech: Edge model free and pre-installed, configurable to 11Labs for more natural voices (with API key)
  • Skills Management: 77 skills immediately available (including Claude Code, architecture diagrams, DevOps, gaming), more installable from Hermes repository
  • Skill Creation: Agent can independently create new skills – example shows YouTube title generator skill for a 95,000-subscriber channel
  • Cron Jobs: Time-triggered tasks, e.g., reminders after 5 minutes or recurring research reports

  Special Features:

  The agent displays tool calls transparently (unlike OpenClaw), updates its own memory files during conversations, and continuously adapts. If errors occur (e.g., gateway issues), users can ask the agent to troubleshoot itself.

  The tutorial is practical, demonstrates functionality live, and shows how to integrate third-party providers like 11Labs.

  Featured Tools/Models: Hermes Agent, OpenAI (GPT-4.5), Claude, Anthropic, 11Labs, Telegram, BotFather, Osingr (VPS sponsor) – Tutorial (suitable for intermediate users).

Liam Ottley

No new videos in this period.

Mark Kashef (2 new videos)

• You Can Make Claude + Codex Plan Together. Here’s How.
  28.4.2026, 19:00:35

  The video introduces a tool called “Claudeex” that automates collaboration between Claude Code and Codex to create detailed and thoughtful project plans. The process involves multiple rounds where Claude Code creates a plan and Codex reviews it, identifies errors, and suggests improvements. Claude Code integrates these suggestions and the process repeats until a predetermined number of rounds is completed. The tool also offers features like “/review” for manual review, “/cancel” to stop the process, and “/rollback” to reset completely. A practical example demonstrates how Claudeex is used to create a detailed plan for building a specialized webpage that tracks user activity. The comparison between a plan created with Claude Code alone and one created with Claudeex shows the improved depth and robustness of the latter.

  The video explicitly addresses Claude Code and Codex and is geared more toward intermediate or advanced users who already have experience with these tools.

• You Can Run Claude AND Codex Together. Here’s How.
  26.4.2026, 19:30:32

  The video demonstrates how to combine the strengths of the AI models Claude Code and Codex to achieve better results. It presents an OpenAI plugin that enables using Codex as a kind of “sidekick” for Claude Code. The author explains that each model has its own strengths and weaknesses, and combining both models leads to better results. The plugin offers various commands, such as code review, adversarial review, and code rescue, that allow you to review and improve Claude Code’s code. The author demonstrates using the plugin in various scenarios, such as reviewing an existing codebase, planning new features, and reviewing code before deployment. He emphasizes that combining both models leads to more efficient and effective development.

  Final comment: The video explicitly addresses Claude Code, Codex, and OpenAI and is geared more toward intermediate to advanced users.

Matt Pocock (2 new videos)

• I Open-Sourced My Own AFK Software Factory
  30.4.2026, 13:28:38

  The video demonstrates how to orchestrate AI-coding agents in isolated sandboxes using the TypeScript library “Sand Castle” to run them completely autonomously (AFK). The author explains that he tried various solutions but encountered issues with Docker sandboxes. That’s why he developed Sand Castle, which enables controlling agents with simple TypeScript functions. The video shows setting up Sand Castle in a repo, selecting an agent (e.g., Claude Code) and a sandbox (e.g., Docker), and using GitHub Issues as a backlog manager. It demonstrates creating a Docker image, setting required environment variables, and creating a GitHub Issue that gets processed by the agent. The author explains the structure of the main.ts file, which orchestrates multiple agents (Planner, Implementer, Reviewer, Merger), how these agents work in parallel, and how they merge code commits together. At the end, it shows how the agent creates a TypeScript template with tests and CI scripts and merges the changes into the main branch.

  The video explicitly covers Claude (Anthropic), Docker, and GitHub and is aimed at intermediate or advanced users.

• How To De-Slop A Codebase Ruined By AI (with one skill)
  29.4.2026, 15:09:12

  The video addresses the problem of AI-accelerated software entropy, where codebases decay faster because changes are often made without considering the entire codebase. The speaker presents a method to rescue such codebases by relying on software fundamentals and improved codebase architecture. He explains key concepts like modules, interfaces, implementations, deep and shallow modules, as well as seams and adapters. Deep modules, which hide substantial implementation behind a simple interface, are highlighted as advantageous. The speaker demonstrates applying these concepts to a real codebase using Claude’s “Improve Codebase Architecture” skill. This skill identifies improvement opportunities and guides the user through a process to structure and test the codebase. The speaker emphasizes the importance of tests and deep modules for the long-term health of a codebase and recommends applying the skill regularly.

  The video explicitly covers Claude and is aimed at intermediate to advanced developers.

Melvynx (3 new videos)

• Hermes Agent : 10 VRAIS usages quotidiens que je fais avec mon Agent IA
  30.4.2026, 16:01:05

  Ten practical use cases for autonomous AI agents

  The video presents ten concrete use cases for autonomous AI agents (like Hermes or Open Claw) that are controlled via Telegram as a chat interface and have access to various tools and systems.

  Main use cases:

  1. Email Management: The agent manages emails independently — for example, it was able to identify an unwanted payment request, contact support, and request a refund.
  1. Tool Integration and Invoice Generation: The agent receives access to APIs (Stripe, Front, code systems) and automatically creates invoices. In doing so, it learns “skills” independently to solve recurring tasks more quickly.
  1. Travel Planning: The agent independently researches flights and creates travel plans — delegation in the background while the user handles other tasks.
  1. Content Creation: It analyzes videos, transcribes them, extracts the style, and generates LinkedIn posts or content ideas based on that.
  1. Sponsor Management: The agent negotiates with sponsors autonomously, filters requests, and sends a daily summary instead of all individual communications.
  1. Customer Support: Automatic handling of errors, refunds, and access issues; when uncertain, the agent asks for clarification.
  1. Medical Management: The agent maintains a detailed medical history with allergies, medications, and symptoms — and can thereby answer questions comprehensively.
  1. Programming and Debugging: The agent maintains repositories, creates pull requests, and debugs code — successfully in 99% of cases with the necessary environment variables.
  1. Business Intelligence: With access to databases (Postgres, APIs from YouTube, Twitter), sales data, and email, it can perform in-depth analysis and identify trends.
  1. Automated Routines (Cron Jobs): Daily/weekly automated tasks such as LinkedIn scheduling, calendar digests, checking money transfers, workspace backups, email cleanup, and storage consolidation.

  System Characteristics: The agent works with a Markdown-based memory architecture instead of randomized storage, creates skills on-demand, can learn independently, and adapts when the user encounters new requirements.

  The video primarily demonstrates Hermes as an agent framework, but also mentions Open Claw and Claude — it’s a practical demo focused on automating complex workflows.

• N’UTILISE PAS MongoDB : voici pourquoi
  28.4.2026, 16:15:51

  Why I don’t recommend MongoDB — four arguments against NoSQL as a standard

  The creator argues with four main points against using MongoDB for typical projects:

  1. NoSQL is rarely necessary

  85% of all applications have structured data and benefit from SQL. NoSQL only makes sense for very specific use cases: extremely high-frequency event logs, highly variable product catalogs without structure, big data and analytics (here he recommends Tinybird as a specialized tool), or offline-first scenarios. Examples of legitimate SQL applications: SaaS apps with users/projects/billing, e-commerce, blogs, marketplaces, CRMs. Even with millions of events (like in the email business), SQL works great. The real boundary: are you processing over one million inserts per second? If not, use SQL.

  2. SQL errors are valuable

  MongoDB allows schema-less work optionally — that’s fatal. Wrong field names, types, or typos are silently accepted. With SQL and strict schema (like PostgreSQL), the system throws errors immediately. This is critical for AI models: without schema, AI can’t learn that something is wrong — it thinks everything works. With schema, AI gets feedback and corrects itself. The comparison to TypeScript vs. JavaScript: TypeScript forces error messages that help.

  3. Too much flexibility leads to chaos

  Without enforced schema, each team member develops different field structures. After six months, a “users” collection has 14 different formats (sometimes name, sometimes first_name/last_name, sometimes is_admin). In PostgreSQL that’s structurally impossible — if the column doesn’t exist, AI can’t add it. The result with MongoDB: defensive code everywhere, type checks, data duplication, no joins, impossible migrations, and production bugs.

  4. Better alternatives exist

  Convex (reactive, live subscriptions, optimistic updates, strict schema with validation — especially for collaborative apps) and PostgreSQL (simple, supported everywhere, migratable, mature ecosystem with Prisma, Supabase, Neon, has transactions, foreign keys, constraints). ChatGPT scales with PostgreSQL to millions of queries per day. Firebase/Firestore for mobile/prototypes. MongoDB is almost never justifiable for him; Atlas licensing is proprietary and pricing gets expensive long-term.

  Additional Insights:

  Professional apps use multiple specialized databases in parallel: PostgreSQL for core data, Redis/Upstash for caching/real-time, Cloudflare R2 for file storage. With Convex, most problems (data inconsistency, over-fetching, cache invalidation) disappear because real-time keeps everything automatically synchronized. He recommends cost-effective hosting options: Neon, Supabase, or Convex (free with low usage), later Render (fixed pricing).

  Conclusion: This talk rejects MongoDB for 99% of cases and recommends PostgreSQL with strict schema + AI feedback as the standard solution.

  No specific AI tool vendors were explicitly mentioned; format: opinion/reflection with technical argumentation.

• Prompt Caching : Tout savoir sur l’optimisation des coûts IA via le cache
  26.4.2026, 15:49:28

  Summary: Caching with Claude models

  The video explains the caching concept in large language models, specifically in the context of Claude APIs and their cost structure.

  Basic Concept: When an agent (e.g., Cloud Code) works with a model, each request goes through multiple rounds. In each round, the same context (system prompt, previous messages, tools) is sent to the model again. Caching stores these repeated input tokens to avoid processing them multiple times.

  Technical Process: Processing consists of two phases — prefill (preparing the model for the context) and decode (generating the response token-by-token). Only the prefill phase is cacheable, since decode is unique for each request. Caching eliminates the expensive prefill repetition.

  Pricing: Basic input tokens cost significantly more than cached tokens (e.g., $5 for regular tokens vs. $0.50 for cached over 1 hour). This results in savings up to 90% for reused contexts.

  Practical Implementation: With the cache_control parameter in the API call, you can explicitly enable caching. There are different cache levels — global caching (system instructions, tools), project-level (documentation, memory), session-level (chat history), and message-level (individual messages). The TTL (Time-To-Live) is 5 minutes by default or configurable up to 1 hour. Important: Changes to the system prompt or tool set completely invalidate the cache; all tools should always be available, not dynamically hidden/shown, to avoid cache invalidation.

  Claude APIs, specifically with prompt caching; opinion/deep-dive.

“`html

MoureDev by Brais Moure (2 new videos)

• MCP desde cero: Conecta tu IA a cualquier dato
  29.4.2026, 17:41:29

  Summary: Workshop on Model Context Protocol (MCPs)

  The channel provides a comprehensive explanation of what MCPs are and how they function in modern AI-powered software development.

  The core problem: When developing with AI agents (Claude, VS Code with Copilot, etc.), every connection to external systems (databases, GitHub, Figma, newsletter platforms like Beehive) required custom integrations. This was inefficient and not scalable.

  MCPs as standard solution: MCP (Model Context Protocol) is an open standard created by Anthropic in late 2024 and transferred to the Linux Foundation in December 2025. MCPs function as the “USB-C of AI” — a unified protocol instead of many proprietary connections.

  Architecture:

  • Host: The application (Claude Desktop, Cursor, VS Code)
  • Client: Component within the host for each server
  • Server: Process that exposes capabilities (locally via Stdio or remotely via HTTP)

  Three primitives of an MCP:

  1. Tools: Functions that the AI can execute (create, modify, send)
  2. Resources: Data for reading (files, database entries, metrics)
  3. Prompts: Predefined task templates

  Practical examples in the video:

  Beehive MCP as remote server: The presenter connects Claude Desktop with a custom connector to the Beehive newsletter MCP. After authentication, 51 tools are available. The AI can independently invoke tools like “list_publications” or “get_post_stats” to identify top newsletters by engagement metrics — without manual API calls.

  Dashboard creation: Based on data provided by the MCP, the agent automatically creates an HTML dashboard with real metrics, all in seconds.

  Local MCP with Python: The presenter demonstrates how quickly you can create your own MCP server with the Python SDK — just a few lines of code to expose a tool called “hello,” then test locally with the Inspector and use directly from the editor.

  Configuration: MCPs are configured in JSON files (e.g., .vscode/mcp.json). Integration happens through simple URLs for remote servers or CLI commands for local servers.

  Result: MCPs enable AI agents to safely and standardly access external data sources without writing new integrations for each system. Developers get access to larger context and can prototype faster.

  Tools explicitly covered: Claude (Desktop, API), Cursor, VS Code with Copilot, Beehive (newsletter platform), Python MCP SDK; brief mentions of GitHub, Supabase, Figma, Stripe, Notion — Format: Tutorial/Live demo with practical examples, emphasis on beginner level with deep concept explanation.

• La IA subvencionada terminó y esto es lo que viene
  28.4.2026, 14:00:30

  Summary: The end of “unlimited” AI tools for development

  GitHub Copilot just announced a pricing model change: abandoning the flat $10/month subscription for “unlimited” access in favor of a monthly credits system ($10 in credits spent according to actual token consumption). This is not an isolated case: Anthropic recently tried to remove Claude Code access from the Pro plan (though backtracked after public pressure), and tools like Cursor and Windsurf have already cut request limits and implemented daily/weekly quotas.

  The video argues this was inevitable. The real economic background is that training and running AI models is extremely expensive: companies have been massively subsidizing access (example cited: users paying $20/month when the actual cost to the company was $200). Anthropic signed a $25 billion agreement with Amazon for 5 GW of computing capacity; Microsoft, Anthropic, and OpenAI now need to justify billions invested. The “gift” model for capturing users and gaining market share has ended.

  The pattern is always the same: launch cheap or unlimited → quietly raise caps → move to hourly/weekly limits → finally, charge by token consumed. We’re now in the final phase.

  Proposed reflections: developers must learn to optimize token consumption (don’t use AI without criteria), explore more economical local models (Llama, DeepSeek, Qwen) for non-critical tasks, adopt a hybrid approach (premium models only where justified), don’t lock into one specific tool, and maintain understanding of fundamentals above dependence on tools. What remains irreplaceable is developer reasoning and design, not access to cheap tokens.

  The video concludes by emphasizing that developers who understand what’s happening, how to optimize costs, and how to use these tools well during the transition will have a clear advantage over those who just copy-paste without criteria.

  Tools and providers mentioned beyond GitHub Copilot, Claude, OpenAI, Anthropic, Cursor, Windsurf, Llama, DeepSeek, and Qwen — Opinion/reflection.

“`

n8n (2 new videos)

• n8n Livestream: Product Updates, Community Creator & the latest Community Challenge
  30.4.2026, 16:30:56

  The video shows a live stream session with various updates and presentations around the N8N platform, a workflow automation tool. Here are the key points:

  1. Product Updates from Nick and David:
  • MCP (Multi-Cloud Platform): A tool for creating N8N workflows that is currently in beta phase and continuously being improved. It enables the integration of Coding Agents and other tools.
  • Agents as First-Class Citizens: Agents are treated as standalone entities alongside workflows, with enhanced features such as long-term storage, state management, and routing strategies.
  • AI Assistant: A new AI assistant that can create, test, and iterate workflows. It has access to various tools like browser, file system, and multimodality, and is designed to make proactive suggestions.
  • N8N Connect: A feature that enables direct consumption of AI tokens within N8N and facilitates access to various services such as web search, web scraping, and OCR.
  1. Community Member Zayn Khan:
  • Presentation of a customer project that automates support ticket management with N8N. The workflow uses JotForm for input, AI agents for classifying tickets by severity and sentiment, and integrates databases like Airtable and Slack for notifications.
  1. Community Challenge:
  • Introduction of the monthly Community Challenge, where participants can solve real-world use cases with N8N. Winners will be featured in the next live stream and their workflows will be published in the official N8N template collection.
  • The current challenge focuses on “Human-in-the-Loop” automation, where human review steps are integrated into the workflow. An example was the review of social media content by various team members.
  1. Additional Information:
  • Fridays for AI Days: A weekly initiative where users can share their workflows and receive rewards.
  • Job Opportunities: N8N is hiring new team members, particularly for community teams.
  • Newsletter and Events: Information about the monthly newsletter and upcoming community events, including a special event for women in automation.

  The video explicitly focuses on N8N and its various features and tools, particularly MCP, Agents, AI Assistant, and N8N Connect. It is designed for intermediate and advanced users who already have experience with workflow automation and want to deepen their knowledge.

• Create n8n Workflows With Agents | Official MCP
  29.4.2026, 14:18:27

  The video demonstrates how to use the new MCP interface (Multi-Tool Calling Protocol) from n8n to create and edit workflows with the help of AI models like Claude. The MCP interface enables you to create workflows directly in n8n without manually copying and pasting JSON code. The process includes connecting n8n with Claude via the MCP interface, configuring access permissions, and using Claude Code to create workflows. The video also shows how to set up the MCP interface with other coding agents like Open Code. The video is a tutorial for setup and provides a preview of future applications.

  The video explicitly focuses on n8n, Claude, Claude Code, and Open Code and is designed for intermediate users.

Nate Herk | AI Automation (3 New Videos)

• Build & Sell Claude Code Operating Systems (2+ Hour Course)
  1.5.2026, 07:30:47

  Summary: Build your own AI Operating System with Claude Code

  Nate demonstrates in this comprehensive tutorial how to build a personal AI Operating System (AIOS) with Claude Code – an integrated AI environment that centrally manages all your business data, connections, and workflows.

  The Core Idea

  An AIOS acts as an intelligent central hub: Instead of switching between many apps, you work primarily in Claude Code, where the AI has access to all relevant data (Google Workspace, ClickUp, YouTube, Fireflies, etc.), connects it all, remembers everything, and runs automated tasks in the background—while you sleep.

  The Three M’s of the Approach

  Mindset: Develop the “Default Shift” habit—before every task ask: “How could AI handle 30–75% of this?” Learn to break tasks into small chunks (Function Breakdown) and treat AI as a mentor, not a machine.

  Method: Define what’s worth automating and to what extent.

  Machine: The technical implementation in Claude Code.

  The Four C’s – AIOS Foundation

  1. Context (The Brain): Your AIOS knows your business, priorities, and voice
  2. Connections (The Arms): Access to ClickUp, Gmail, Slack, YouTube, Stripe, QuickBooks etc. via APIs, MCPs, or CLIs
  3. Capabilities (The Skills): Skills – reusable recipes/SOPs that your AIOS executes
  4. Cadence (The Independence): Tasks that run fully automated in the background (Routines, Loops)

  You build these in this order.

  Practical Setup Steps

  1. Structure your project: Open VS Code, install Claude Code Extension, create folder structure with .claude/skills, /context, /references etc.
  2. Start with a repo: Clone the provided GitHub template (includes onboarding skill)
  3. Identify seven Tier-1 domains: Revenue, Customer, Calendar, Comms, Tasks, Meetings, Knowledge – and note which tools you use for each
  4. Build connections: Add API keys for ClickUp, Google Workspace (GWS CLI), Fireflies etc., create reference documentation
  5. Build skills: Document repeated processes as Markdown guides that Claude executes

  Key Tools & Features

  • Google Workspace CLI (GWS CLI): Enables access to Gmail, Drive, Docs, Sheets, Calendar – all via a single CLI command. Particularly powerful for automations (e.g., dynamically creating and populating Docs/Sheets).
  • Skills: 500-line Markdown files with front-matter (Name, Description) + step-by-step flow + optional reference files/scripts
  • Cloud Routines: Cloud-based scheduled automations that run even when your laptop is off (GitHub repo + environment variables for API keys)
  • Loops: Session-based real-time loops for up to 3 days (e.g., “check every 5 min”)
  • Artifacts: Quick web dashboards to visualize data (ClickUp, QuickBooks, etc.)

  LLM Knowledge Wiki (Obsidian + Markdown)

  An optional hack inspired by Andrej Karpathy: Markdown files in Obsidian as a structured knowledge base that Claude searches and maintains – simpler than traditional RAG, more token-efficient, scales to ~100k pages.

  Daily & Weekly Usage

  • Morning: “Help me plan my day” → AIOS checks Calendar, Tasks, ClickUp
  • Daytime: Work primarily in Claude Code, invoke Skills, no new browser tabs
  • End of Day: Note which Skills worked well, where feedback is needed
  • Fridays: Run /audit, identify gaps, plan next week

  Success Indicators

  • Your team prefers asking the AIOS over you
  • You rarely open new tabs/apps
  • Knowledge leaves your brain (documented in the AIOS)

  Explicitly covered tools: Claude Code, Google Workspace CLI, ClickUp, Fireflies, YouTube Data API, Stripe, QuickBooks, Obsidian, GitHub, Glido (Voice-to-Text), VS Code, Nano Banana 2 (Image Generation), Anthropic Routines, Trigger.dev, Modal — tutorial format with live demos and Skill-Builder walk-through.

• Claude Design 2 HOUR COURSE (Beginner to Pro)
  30.4.2026, 01:10:14

  Claude Design Masterclass – Summary

  This masterclass video shows the complete workflow for using Claude Design to develop professional digital products in record time – from brand development through Pitch Decks and websites to mobile app prototypes and launch videos.

  Core Concept: Four Concrete Projects from One Brand Concept

  The creator demonstrates an end-to-end example: From a vague idea, a complete brand concept (name, positioning, visual identity) is first developed using regular Claude. Then a Design System for this brand (e.g., “Tally”) is created in Claude Design, which serves as the foundation for all subsequent projects. Using this system, the following are built in sequence:

  1. Pitch Deck – Investor presentation with market research, roadmap, founder profiles
  2. Landing Page – Single-page product marketing with animated video in hero section
  3. Mobile App Prototype – Complete onboarding and feature flow with Dark Mode
  4. Launch Video – 25-second promo with motion graphics and hyperframes

  Workflow and Token Management

  Important: Claude Design has its own separate usage limit – not part of regular Claude or Code limits. The price/performance ratio is the central theme of the video:

  • Brainstorming/planning belongs in regular Claude Chat (saves Design tokens)
  • Upload sketches, brand files, specification markdown in advance (prevents repeated iterations)
  • Build design system first, then repeat rather than five different systems
  • Model switching: Opus 4.7 for complex vision tasks, later downgrade to Sonnet
  • One visual change per prompt (rather than mega-prompt with many changes at once)

  Burn-rate examples: At Pro Plan ($20/month), after one design system + one website, ~80% of weekly limit is already used; Max Plan ($200/month) enabled the full workflow to ~95%.

  Concrete Features and Workflows

  Canvas Interaction:

  • Comments on individual elements, Draw tool for imprecise requirements, Inline edits (adjust text/size directly)
  • Tweaks Panel: Predefined variations (color palettes, typography, spacing, layouts) that can be played through live without burning new prompts

  Video Integration:

  • Upload external videos (generated via Key.ai/Kling) as MP4 and embed in hero/background
  • Parallax scrolling or infinite loop possible
  • Note file size limit ~30–40 MB

  Export & Deployment:

  • Export as HTML/ZIP → Claude Code takes over → GitHub repo → Vercel deployment (live URL in ~2 min)
  • Or: Export to Figma/Canva for final manual tweaks (saves tokens)

  Inspiration & Catalogs:

  • Motion Sites (.ai) for pre-built website concepts (copy/prompt directly to Claude Design)
  • Hyperframes catalog for motion graphics elements (transitions, notifications, phone animations)
  • Claude Design can crawl URLs and analyze GitHub repos

  Common Issues and Workarounds

  Logos often get distorted, especially icons with fine details (e.g., Tally stroke gets reconstructed rather than kept exact). Provide feedback, but costs extra tokens.

  Draw function occasionally buggy, Comments input field can get obscured.

  Mobile optimization not automatic – Desktop design must be explicitly reworked with guidance toward mobile responsiveness.

  Context window pollution on long threads – With many iterations in one session: export and start fresh chat with already-built artifact can be more efficient.

  Best Practices Summarized

  • Design System = investment, but pays off (consistency across all projects)
  • Visual references instead of vague descriptions (screenshots, specific color codes, real websites as templates)
  • Specify negatives (what you don’t want)
  • Use Tweaks feature instead of back-and-forth prompting
  • Switch between Claude Design (high visual quality) ↔ Claude Code (iterative development) as needed
  • Sketches upfront save tokens

  The video demonstrates that professional designs no longer need to be built “by hand” – but strategy, brand clarity, and feedback precision are critical to avoid wasting budget.

  Explicit tools/providers: Claude Design, Claude (Brainstorming), Claude Code, GitHub, Vercel, Opus 4.7 (Model), Sonnet, Key.ai, Kling, HeyGen (Hyperframes), Motion Sites, Figma, Canva, ChatGPT Image-2, Linear 2023 (as reference), Glydo (Voice-to-Text), Lovable (comparison) — Format: Masterclass/Tutorial with deep dive into features and live demo; for intermediate to advanced creators with practical requirements.

• 32 Tricks to Level Up Claude Code in 16 Mins
  27.4.2026, 13:04:56

  Summary: Claude Code Hacks – From Beginner to Power User

  The video presents 32 practical tricks for Claude Code, structured from beginner to advanced techniques.

  Beginner Hacks (1–10):

  • Run /init to scan existing projects and generate a cloud.md file documenting architecture and conventions
  • Set up status line to see model, context percentage, and costs live
  • Use native /voice input to code by speech
  • Keep context small – provide only relevant files for current tasks
  • Use /context to break down token usage by source
  • Around 60% context, use /compact to compress conversation history; use /clear to restart between tasks
  • Start in Plan mode (Shift+Tab) so Claude plans steps before making code changes
  • Treat Claude like a junior developer: pose problems rather than give direct commands
  • Have Claude ask clarifying questions until it’s 95% confident it understands the requirement
  • Build verification steps into to-do lists (screenshots, DevTools checks)

  Intermediate Hacks (11–22):

  • Deploy Sub-Agents for parallel work – isolated contexts that research/test in parallel and report back
  • Create custom Skills in .cloud/skills (e.g., techdebt.md, codereview.md) for reusable workflows
  • Use Haiku model for Sub-Agents to cut costs (e.g., for data processing)
  • Update cloud.md regularly with new insights, gotchas, and patterns (optimal 150–200 lines)
  • Keep cloud.md lean by having it reference separate files for style guides, business context
  • Exit early and re-prompt if Claude goes in the wrong direction
  • Aggressively challenge outputs and set higher quality standards
  • Use /rewind for quick undos
  • Use /hooks for notifications (e.g., sound alert after session ends)
  • Use screenshots – Claude can visually analyze errors, design inspiration, and layout issues
  • Use Chrome DevTools for app functionality and browser interaction
  • Clone inspiration websites – feed screenshots of designs, Claude recreates patterns without “AI Slop”

  Advanced Hacks (23–32):

  • Use Git Work Trees for parallel sessions in the same project – multiple isolated branches simultaneously without conflicts
  • Use API endpoints instead of MCP servers in token-critical scenarios (e.g., read only one Notion database instead of loading all MCP tools)
  • Use /loop for recurring tasks (e.g., check deployment every 5 minutes); runs max. 3 days
  • Host on VPS for always-on sessions – remote SSH access, even via Telegram
  • Remote control of smartphone/browser – manage local sessions from anywhere
  • Integrate CLI tools like BigQuery and ask questions in English (Claude translates to SQL)
  • “Ultra Think” for tough problems – allocates max. 32,000 tokens to think before responding
  • Set permissions explicitly – instead of dangerously_skip_permissions, only allow safe commands, deny-list destructive ones (deletes)
  • Agent Teams instead of Sub-Agents – Agents communicate with each other, share task list, can delegate work to each other
  • Install Context 7 MCP – pulls current documentation (Next.js, React, MongoDB etc.) instead of relying on outdated training data

  The video covers Claude Code with practical workflows around context management, parallel agents, custom skills, and token optimization — opinion/reflection with strong practical focus.

NeuralNine (2 new videos)

• FastEmbed: Local AI Embeddings in Python
  1.5.2026, 16:00:07

  The video introduces FastEmbed, a Python library for working locally with embedding models, optimized for speed and simplicity, even on systems without dedicated GPU. It’s particularly suited for lightweight and fast embedding generation, uses ONNX Runtime, and offers specific, high-performance models, though not all state-of-the-art models.

  The tutorial section demonstrates the installation and usage of FastEmbed for text and image embeddings. For text embeddings, example sentences are created, embedded, and similarities are calculated. For image embeddings, two images are embedded and results are displayed. Additionally, the integration of FastEmbed into Qdrant is demonstrated, a vector store that uses FastEmbed for embedding data.

  Finally, the use of FastEmbed with GPU support is explained, showing installation and configuration for CUDA GPUs. The video concludes with the observation that FastEmbed is well-suited for prototyping and lightweight use cases, but doesn’t support all state-of-the-art models.

  Final comment: The video explicitly covers FastEmbed and Qdrant and targets Intermediate users.

• Agentspan: Building Durable AI Agents in Python
  27.4.2026, 16:01:15

  Durable AI Agents in Python with Agent-Span

  The video shows how to build fault-tolerant (durable) AI agents in Python using the open-source framework Agent-Span. “Durable” means that the agent maintains its state – even if the process crashes or human approval takes days.

  Key Concepts

  Agent-Span decouples agent logic from execution: the agent state is stored on a server instead of in the executing process’s RAM. This allows interrupted workflows to be seamlessly continued without starting over. The framework is fully open-source, self-hostable, and free.

  Three Practical Examples

  1. Crash and Resume: The agent is demonstrated with two mock tools (chunk analysis and result aggregation). When the script is interrupted, Agent-Span saves the execution ID to a file. On restart, the agent automatically reconnects to the saved state and resumes interrupted tool calls – without repeating already completed steps.

  2. Human-in-the-Loop with Delay: A refund agent requires human approval for a tool call (with the parameter approval_required). The state is held on the server while the approval form (here command-line input, in practice an admin dashboard) is pending. Approval can be delayed indefinitely without data loss. The script can even crash during this time and simply be rerun.

  3. Existing LangGraph Workflow: An existing LangGraph agent is extended with Agent-Span durability without code changes. You simply wrap the runtime with agent_runtime and use runtime.deploy(), runtime.serve(), and the same crash-resume logic – the LangGraph code itself remains unchanged.

  Technical Implementation

  The setup requires only import os for execution ID management, imports from agent_span.agents (Agent class, tool decorator, start function, runtime, AgentHandle). The ID is persisted in a file; on restart, the script checks if this file exists and resumes execution if needed instead of starting a new one. Agent-Span also offers a web dashboard at localhost:6767 for runtime monitoring.

  Agent-Span, open-source framework for durable agents; tutorial.

Nic Conley

No new videos in this period.

Nick Saraev (1 new video)

• How to Use Claude Code for FREE (2026)
  2.5.2026, 01:02:11

  The video shows how to use Claude Code for free by using an open-source alternative called “Free Claude Code”. This alternative enables the use of the same Claude Code interface, but with cheaper backend models that offer about 80-90% of the quality of Opus 4.7 at 2-5% of the cost. The creator demonstrates the setup and usage of this alternative by building a simple habit-tracking app. Various models and platforms such as Open Router, NVIDIA NIM, and Ollama are introduced, which can serve as backends for the free Claude Code alternative. The creator also shows how to set up and use these models, as well as how to optimize quality and costs by combining different models. The video is aimed at intermediate users who already have experience with Claude Code and are looking for a cost-effective alternative. Specific tools and models like DeepSeek V4 Flash, GLM 4.7, and Gemma 4 are discussed.

Niklas Steenfatt (1 new video)

• OpenClaw für Dummies
  26.4.2026, 18:21:37

  The video demonstrates step-by-step how to set up your own OpenCore AI assistant, starting with installation on a Hostinger server, connecting it to various tools, and configuring email and Google services. The creator recommends treating the assistant like a new employee and granting it only the necessary access to minimize security risks. Tools like Tavily for web research, Notion for databases, and Deepgram for voice message integration are introduced. The video also explains how to set up recurring tasks and subagents, as well as how to keep costs under control. For advanced users, there are tips on troubleshooting and using the command line.

  The video explicitly covers OpenCore, Hostinger, Anthropic, Tavily, Notion, Deepgram, Google Cloud, Excalidraw, and ChatGPT, and is suitable for intermediate to advanced users.

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

• Baseten CEO Tuhin Srivastava on Custom Models, and Building the Inference Cloud
  1.5.2026, 15:07:25

  This video is a conversation with Tuhin Srivastava, founder and CEO of B10, an AI inference cloud. The main topics are capacity constraints for AI compute, the importance of inference, the development of workloads, the future of open-source models, and scaling B10.

  Tuhin Srivastava explains that demand for AI inference has surged as companies deploy AI across more and more domains. He emphasizes the importance of the application layer, which is protected by specific workflows and user signals that only certain companies can capture. He sees great potential for AI applications, both for new startups and for enterprises deploying AI in-house.

  Another focus is the development of open-source models. Srivastava stresses that customers want the best models and that cost optimization comes after capability. He views the adoption of open-source models from China positively, but warns against dependence on a single vendor and emphasizes the need for the US to develop its own open-source models.

  Srivastava also discusses challenges in procuring compute capacity and the strategic importance of inference. He highlights the significance of the software layer for the stickiness of inference services and the necessity of closing the loop between inference and post-training.

  He also mentions the importance of multi-chip worlds and the need to understand which workloads to invest in, such as code agents and long-horizon agents.

  Closing note: The video explicitly covers open-source models and specific tools like Bridge, Cursor, and Open Evidence. It is geared more toward intermediate and advanced audiences.

Productive Dude (1 new video)

• Claude Automated My Entire Workflow (Results Shocked Me)
  29.4.2026, 13:01:22

  The video demonstrates how to automate your business with Claude at three different levels: from basic Claude chat usage to integrating Claude into a custom platform. The three levels are:

  1. Level 1: Basic Chat Skills
  • A skill is created in Claude by building a folder structure with a skill.md file, reference files, and examples.
  • The skill is uploaded and used in Claude to automate tasks like lead scoring and email drafting.
  • Example: A lead qualifier skill that scores leads and creates email drafts.
  1. Level 2: Routines with Skills and Connectors
  • Skills are stored in a GitHub repository and used in routines triggered on a schedule or by events.
  • Example: A routine that every Monday at 8 AM scores all leads from the previous week and creates email drafts.
  • Integration with tools like Google Drive and Gmail to read leads and create email drafts.
  1. Level 3: Custom Platform
  • Building your own CRM platform that communicates directly with Claude.
  • Using a Model Context Protocol (MCP) server or direct API calls to score leads and create emails.
  • Example: A custom CRM platform that reads leads from a form, scores them, and creates emails.

  The video walks through how to implement these levels step by step, from creating a simple skill to integrating it into a custom platform.

  Final note: The video explicitly focuses on Claude and is geared toward intermediate to advanced users.

Sebastien Dubois

No new videos in this period.

Simone Rizzo (2 new videos)

• GLM-OCR in locale: ti mostro come convertire PDF in Markdown
  28.4.2026, 18:27:46

  The video demonstrates how to convert complex, messy PDFs with tables and infographics into clean Markdown – the preferred format for AI agents and knowledge-base systems.

  OCR models overview:

  The video compares several open-source and commercial OCR models: Paddle OCR 3 (76,000+ GitHub stars), DeepSeek OSAR 2 (with Visual Reading Order – reconstructs reading flow like the human eye), DotS OCR, and Mistral OCR from the French company Mistral, which is currently considered the strongest model. The focus, however, is on GLM OCR – a new, lightweight multimodal model with 6,000+ GitHub stars, 285,000+ downloads on Ollama, and 8 million downloads on Hugging Face last month. It achieves 94.62% on the OmniDoc benchmark and outperforms Paddle, DeepSeek, and DotS OCR.

  Practical implementation:

  The creator shows step by step how to load and use GLM OCR locally via Ollama (2 GB model size). With the help of a coding agent (Cursor, VS Code, etc.), a web app is built that converts PDF pages to images, applies GLM OCR locally, and displays the Markdown output. On the left you see the original PDF (page by page), on the right the extracted Markdown with correct tables and formatting.

  Demo with real documents:

  The app is tested with two test PDFs – two pages of the DeepSeek V4 paper and a non-selectable PDF (screenshots with tables). In both cases, the Markdown is extracted correctly. Then a stress test with the complete 58-page DeepSeek V4 paper, where all pages are automatically converted.

  Hardware requirements & use cases:

  The model requires at least 10–12 GB VRAM (in the demo 9.9 GB out of 10 GB used). Alternative: Mac with Unified Memory or mini PCs with similar architecture. The main benefit is local, private processing of sensitive documents – ideal for lawyers, accountants, companies, and SMEs to build knowledge bases, RAG systems, or LM wikis without sending data to cloud services.

  Explicitly covered: GLM OCR, Ollama (local), Coding agents, Paddle OCR, DeepSeek, Mistral, DotS OCR – demo with practical tutorial.

• DeepSeek V4 è uscito: novità tecniche e test contro GPT-5.5 e Opus 4.7
  26.4.2026, 13:24:06

  DeepSeek V4: Technical innovations and comparison with GPT-5.5 and Claude Opus

  DeepSeek has released two new models: V4 Pro with 1.6 trillion parameters (49 billion active) in Mixture-of-Experts format, and V4 Flash with 284 billion parameters (13 billion active). The core feature of both models is support for 1 million token input context, which was a central design goal.

  Performance and positioning: According to the technical report, DeepSeek V4 Pro is very close to GPT-5.4 and Gemini 3.1 Pro on reasoning tasks – with an estimated development lag of 3–6 months compared to current frontier models. V4 Flash achieves performance comparable to GPT-5.2/Gemini 3.0 Pro, despite having only about one-third the parameters of these models.

  Technical innovations: The model uses three main mechanisms to boost efficiency:

  • Compressed Sparse Attention (CSA) and Heavy Compressed Attention (HCA): Instead of the quadratic complexity of classical transformer attention, memory usage is reduced by a factor of 4 (CSA) to 116 (HCA) through compression, causing the KV cache to grow almost linearly rather than exponentially.
  • Manifold Constraint Hyper Connection: Mathematically coupled residual connections between layers enable stable information flow without gradient explosion.
  • Muon Optimizer: Enhanced gradient descent variant that provides faster convergence and more stable training at enormous model scale.
  • Quantization-Aware Training (QAT): Hybrid quantized weights (FP4, BFloat16, full precision depending on layer) during training, not retroactively.
  • Router hashing for early tokens: In the first tokens of a query, deterministic layers are activated to save router overhead.

  Resource efficiency: At full 1-million-token context, V4 Pro requires only 10% of memory and 27% of compute operations compared to the previous version – that is, 90% less memory and 73% less compute through combined optimizations (KV cache reduction + sparse attention).

  Practical tests (Solar System, FPS game, ecosystem simulation, website):

  • Speed: Claude Opus 4.7 fastest
  • Token efficiency: GPT-5.5 most economical
  • Cost: DeepSeek dominates significantly – roughly 5× cheaper than GPT-5.5, 7× cheaper than Opus 4.7
  • Quality: Across the four tests, all three models deliver comparable results; DeepSeek and Opus added planet shadows, GPT-5.5 additionally included the Moon orbiting Earth. The Opus FPS game was more playable than the other two.

  Author’s conclusion: DeepSeek V4 Pro is an engineering masterpiece of efficiency optimization for production environments. It feels like a robust, paid frontier model – albeit a previous version. The Chinese open-source approach pursues not just performance, but explicitly economic accessibility and reduced operating costs.

  Mentioned models & tools: DeepSeek V4 Pro/Flash, Claude Opus 4.7, GPT-5.5, Gemini 3.1 Pro, GLM 5.1, Kimi K2.6, Llama Spark (Meta), Mimo V2.5 Pro (Xiaomi); testing via Open Router — demo & comparison.

Tech With Tim (5 new videos)

• I reviewed 20 AI engineering courses, here are my top 5
  1.5.2026, 14:00:34

  The video presents five AI engineering courses after the creator evaluated 20 courses. First, it defines what AI engineering means: building production-ready applications with already trained models (LLMs, APIs like OpenAI and Anthropic, AI agents, prompt engineering, MCP servers), without requiring a PhD or deep mathematical knowledge.

  The evaluation criteria are practicality, credibility of the creators, interactivity, depth, and target audience.

  The five recommended courses:

  1. Deep Learning AI Short Courses (free, paid for interactive components): Short, modular courses by Andrew Ng, highly credible, but somewhat overwhelming with the number of options, not very interactive.
  1. DataCamp – Associate AI Engineer for Developers Track (paid): Very practical and interactive (code directly in browser), covers OpenAI API, prompt engineering, Hugging Face and LM ops, ideal for developers with Python basics.
  1. Hugging Face LLM Course (free): Very in-depth, focusing on open-source models and fine-tuning, but less practical and interactive, better for those interested in theory.
  1. Full Stack LLM Bootcamp (free, UC Berkeley): High-quality video lectures on prompt engineering, LM ops and foundations, but videos only (not interactive), intended for advanced users, from 2023.
  1. DataCamp – Associate AI Engineer for Data Scientist Track (paid): Similar interactivity to the developer track, but with focus on deeper concepts (PyTorch, scikit-learn), ideal for data scientists.

  In conclusion, recommendations are given: beginners on a budget should start with Deep Learning AI + Full Stack bootcamp, practice-oriented learners with DataCamp, open-source focus with Hugging Face, and advanced users with the Full Stack bootcamp.

  DeepLearning AI, OpenAI, Anthropic and Hugging Face explicitly addressed; roundup with evaluation criteria.

• The State of Software Engineering in 2026
  30.4.2026, 14:08:21

  The repositioning of software engineering in 2026

  The head of Claude Code at Anthropic stated that he hasn’t written a single line of code manually in two months. Anthropic generates 70–90% of code with AI support overall. At the same time, employment of developers aged 22–25 has dropped by nearly 20% since ChatGPT’s launch, and job postings for entry-level positions have declined by 46–67%. AI isn’t on the horizon — it has already permeated software engineering.

  The core shift in role: Developers are moving from producers to supervisors. Rather than writing code, the core competency lies in distinguishing good code from bad and understanding what is maintainable and future-proof. This creates a paradox: to develop this judgment, you need experience through hands-on coding — but those who code manually become too slow and unproductive compared to colleagues using AI.

  Agent Experience (AX): A new design focus is emerging as AI agents increasingly consume software (dashboards, drive tools, etc.). Companies must design their software so that agents can use it. This creates new job categories like “Head of Agent Experience”. Tools like MCPs are being rapidly updated to enable this.

  Talent erosion: Fewer junior developers are hired and trained, while experienced developers retire. Companies primarily hire seniors because AI can write the simple code, but then there’s no one to replace the seniors. At the same time, rapid AI-generated “slop” code production fosters less innovation: LLMs can only predict based on training, they can’t truly invent something new — and often they reproduce poor existing code.

  Shifted bottlenecks: The bottleneck has moved from writing code to code review, security, deployment and maintenance. In-demand skills are now system design, operational excellence, observability, incident response and production debugging — not the volume of code written. This explains why senior roles are booming and junior positions are declining.

  Author’s conclusion: The future is uncertain and somewhat frightening. Developers who refuse to adapt will be marginalized. Adaptability, continuous learning and focus on higher-value skills (not lines of code) are vital — but at the same time, the new reality also opens opportunities to build more than ever before.

  Claude and open-source concepts discussed throughout (MCP, Agent Experience, AI generation), Anthropic and general LLM limitations discussed — opinion/reflection with analysis based on industry conversations.

• I gave Claude its own database, here’s what happened
  28.4.2026, 13:01:40

  The video introduces Ghost.build, a free database solution specifically designed for collaboration with AI agents like Claude. Ghost is installed as an MCP server (Machine Control Protocol) and enables database management natively within Claude – without manual setup or configuration.

  Core features:

  • Free with 100 compute hours/month, 1 TB storage and unlimited databases and forks
  • Installation with a single command, authentication via GitHub
  • Native SQL management, database operations (create, delete, fork, query) directly in the AI tool

  Demonstrated use cases:

  1. Simple database: Creating a reading log database with book entries and SQL queries (e.g., average rating) without manual interaction.
  1. Dashboard creation: Claude automatically creates a Next.js dashboard with Shadcn components for a movie night database with filters and stat cards.
  1. Query optimization: A large e-commerce database (100,000 customers, 500,000 orders) is forked three times and optimized in parallel with different strategies (indexed, materialized view, denormalized table). The best strategy is then applied to the main database – with no risk to the original.
  1. Data cleanup: A messily structured user database is forked 10 times to test 10 different cleanup strategies (dropping, backfill, regex, normalization, quarantine tables, etc.) and the best one is applied to the base DB.

  The central advantage is that databases can be created and discarded for free and quickly, enabling experimental work with AI agents – without fear of errors or hidden costs.

  Claude, MCP server, demo – specifically for using Ghost.build with AI agents for parallel database management and optimization experiments.

• How to Make an App With AI – 9 Steps
  27.4.2026, 14:01:29

  Summary: 9-step roadmap for building AI apps

  The creator presents a structured nine-step process for developing applications with AI, to differentiate between “simple” and “complete nightmare”.

  The nine steps:

  1. Clarify definition: Answer three core questions – What problem does the app solve? Who uses it? When is it done?
  1. Planning & tech stack: Create wireframes, feature lists and spec documents; discuss technical decisions with AI models (frontend, backend, database, deployment). Example: Claude is used to iteratively develop an MVP spec.
  1. Set realistic timeline: Define milestones – day 1: planning, days 2-3: working prototype, week 1: core features, weeks 2-4: polish and testing.
  1. Decide build approach: Either no-code platforms (Lovable, Bolt, Replit) for quick prototypes without technical depth OR build yourself with AI code editors (Cursor, Claude Code, Codex) for maximum control.
  1. Set up environment (option 2 only): Git/version control, Node.js, choose AI editor (Cursor or cloud code), configure MCP servers (e.g., GitHub, Nano Banana Pro for videos/images).
  1. Choose budget & model: Depending on available budget, decide between expensive premium models (Opus 4.6) and cheaper alternatives (Mini Max M2.7); consider subscription and deployment costs.
  1. Build minimally (MVP): Complete one feature fully, test before further development, commit to Git regularly, give small tasks to AI, read code (don’t just generate it), avoid scope creep.
  1. Continuous integration & deployment: Automated testing for critical features (authentication, UI), use GitHub Actions for automated tests and deployments – differentiates hobby projects from professional applications.
  1. Deployment & monitoring: Implement logging, monitoring, analytics and versioning to understand user behavior and plan future improvements.

  The creator warns against “vibe coding” (code without a plan) and emphasizes that planning upfront saves hundreds of hours later – a principle followed by all established software companies.

  Mentioned AI tools/platforms: Claude, Cursor, cloud code, Codex (OpenAI), Opus 4.6 (Anthropic), Mini Max M2.7, Lovable, Bolt, Replit, V0, Mocha; Boot.dev as sponsor; Whisper Flow for dictation; Nano Banana Pro for video/image generation. Format: Tutorial/deep-dive with structured roadmap format.

• Do THIS instead of watching endless tutorials — how to learn Python for AI
  26.4.2026, 14:00:18

  Summary: Python for AI – break through tutorial hell and learn properly

  The video addresses the problem of “tutorial hell”: beginners watch endless tutorials, feel productive, but build nothing. This happens especially in AI because new frameworks and models constantly emerge. The author offers a clear learning path for Python specifically for developing AI applications.

  The core problem: Passive consumption of tutorials leads to only about 20% retention, while active coding achieves 75–90%. You must make your own mistakes to build real skills.

  Step 1 – Learn only necessary Python: Variables, data types, f-strings, lists, dictionaries, loops, conditionals, functions, error handling (try/except), JSON, file I/O, environment variables and pip. Nothing more – no OOP, no decorators, no async patterns, until you really need them.

  Step 2 – Active learning: Use resources that have you write code, not just watch. The author recommends DataCamp here – specifically the Python Fundamentals track and the Associate AI Engineer for Developers track, which work with real projects (chatbots, semantic search, recommendation systems) and cover production deployment.

  Step 3 – First AI project (first week): Get an API key from OpenAI or Anthropic, install the SDK via pip, write a 10-line script that sends a prompt and outputs the response. Then wrap it in a function, accept user input and build a simple CLI chatbot. Done – your first AI project.

  Step 4 – Three progressive projects after that:

  1. Chatbot with memory: Bot remembers conversation history and responds in context. Teaches dictionaries, lists, functions, API loops.
  2. AI file summarizer / doc Q&A: Upload PDFs/markdown, ask questions about them. Teaches file I/O, chunking, basics of RAG (retrieval augmented generation).
  3. AI agent with tools: Model can call multiple functions (web search, file reading, math, external APIs) to answer questions in multiple steps. Teaches JSON schemas, structured outputs, more complex control flows.

  Each project should take max one weekend.

  Step 5 – Get out of the tutorial trap: Afterwards, don’t go back to videos – instead: read documentation of your own libraries, rebuild existing projects with new tools, add persistent databases/frontends/deployment. Use videos only for specific problems, not ongoing.

  Core rule: For every hour of learning content (video/courses) you should spend at least an hour writing your own code – ideally even more. The “one more course” loop is the biggest trap: you feel productive, but you have no portfolio and no real skills.

  The conclusion recaps the entire plan and emphasizes: courses are scaffolding, but you have to get out there, challenge yourself, dig into docs and solve concrete problems – don’t just consume content.

  Context: The video references OpenAI and Anthropic as API providers and DataCamp, LangChain, Hugging Face and Pinecone as specific tools/libraries; the learning strategy is oriented towards ChatGPT-like language models — opinion/reflection with practical learning guide.

TheAIGRID (4 new videos)

• Google’s New AI Could Change Healthcare Forever (Google DeepMind AI co-clinician explained)
  2.5.2026, 20:30:01

  Google DeepMind introduces multi-modal medical AI

  Google DeepMind has unveiled a new language model with video capabilities for medical consultation, demonstrating performance at or better than general practitioners in 68 of 140 aspects of clinical consultations. The system can see patients, hear them, talk with them, and guide them through physical examinations in real time.

  The video demonstrates three clinical scenarios: a patient with abdominal pain (suspected pancreatitis/appendicitis), a patient with ptosis (myasthenia gravis), and a patient with shoulder pain (rotator cuff issues). In each case, the system performs real-time video analysis, asks coordinated follow-up questions, conducts adaptive physical examinations, and provides accurate differential diagnoses and triage recommendations. Physicians in the video note: the system asks relevant follow-up questions, adapts the examination based on patient responses, and displays reasoning traces in real time.

  On benchmarks: the system outperforms 67% versus existing clinical tools (26% for alternatives), also beats GPT-4o with Search (63:30), and achieved top scores on the RXQA medication benchmark (open questions on interactions and dosing). On the Harvard-Stanford test with 20 synthetic scenarios and 10 real doctors as patients, it showed zero critical errors in 97 of 98 cases. Doctor feedback notes: the system sometimes shows premature conclusions, did not conduct all relevant tests, and occasionally recognizes passive visual findings only when patients mention them.

  DeepMind positions the tool as a support system, not a replacement—yet the gap between AI and general practitioners is closing rapidly.

  Google DeepMind, benchmark deep-dive, demo-focused.

• How to Use ChatGPT Codex : Codex Tutorial for Beginners
  30.4.2026, 21:30:02

  Summary: Codex – beginner’s guide to work automation

  The video introduces Codex, emphasizing that it’s not simply a code generator but an “AI team member” for real work outcomes on your computer. The first important step for beginners is switching settings from “Coding” to “Everyday Work” to reduce technical complexity.

  Key settings: The model selector enables different reasoning levels; higher levels cost more credits. For standard tasks, choose Medium; for code projects, High or Extra High. Regularly check usage limits in settings to avoid unintentional credit overages.

  Three main applications:

  1. Standardized file formats: Codex creates Excel, PowerPoint, and Word documents particularly efficiently. Example: a financial overview sheet with revenue, costs, and profit forecasts was created in under 4 minutes and could be adjusted immediately.
  1. Project work in folders: With the Projects function, Codex reads multiple files simultaneously and performs complex tasks—such as summarizing transcripts and transferring them to a Word document. Image generation based on local files also works: Instagram carousels with four high-quality images were created in roughly 5 minutes from existing documentation.
  1. Plugin integration: The Gmail plugin enables analyzing and sorting emails (urgent, soon, noteworthy). Based on this data, responses can be prepared automatically.

  Automations: In the Automations tab, you can set up recurring tasks on a schedule (e.g., daily or weekly). Example: summarize videos weekly and send results via Gmail. Multiple automations can run in parallel.

  Further use cases: Codex can generate local web apps (e.g., interactive financial dashboards). The reasoning level can be set here too to save credits.

  Skills: The Skills function saves repeatable processes as templates. Example: a Skill for Twitter posts (max. 240 characters, layperson language, no jargon) can be recalled later—say to generate 10 tweets at once without prompting each individually.

  The video positions Codex not as a chat interface but as a central command center that checks emails, creates summaries, generates images, and sends reports via automation—all without technical expertise.

  Topics covered: OpenAI Codex, Gmail plugin, GPT-5.5; Format: beginner tutorial.

• Elon Musk Just Leaked The Grok 5 AGI Plan… Grok 5 Explained
  30.4.2026, 06:19:56

  Summary: Elon Musk’s Grok roadmap to AGI

  Elon Musk has disclosed an aggressive development roadmap for xAI, progressing from the current Grok 4.3 Beta through rapid escalation to significantly larger models. Grok 4.4 is planned to contain 1 billion parameters and be available early May; Grok 4.5 will have 1.5 trillion parameters and follow by end of May—the entire timeline spans just a few weeks. The existing Grok 4.2 has only 500 billion parameters and Musk characterizes it as incomplete in training data to justify the next leaps.

  The centerpiece is Grok 5 with planned models at 6 and 10 trillion parameters. Colossus—xAI’s massive training cluster—currently trains seven models in parallel in various sizes and use cases. The 10-trillion-parameter variant requires roughly two months for the pre-training phase alone; further steps like post-training, alignment, evaluations, and safety testing follow. Musk directly links Grok 5 with AGI potential—when asked whether AGI will be achieved with one of these models, he responds simply: “Grok 5.”

  The strategy is scaling through massive parallel compute resources, not incremental improvements. Musk possesses substantial compute advantages through Tesla GPU clusters, X infrastructure, and SpaceX engineering capacity. Musk doesn’t necessarily claim Grok 5 will guarantee AGI, but rather positions it as the critical test moment. Under Google’s definition of AGI (broad cognitively human-comparable performance across many capabilities, not merely size or individual benchmarks), it remains unclear whether Grok 5 meets that standard.

  News update on xAI / Grok / Elon Musk; focus on roadmap and AGI positioning.

• OpenAI’s Secret AI Smartphone Just LEAKED – The OpenAI Smartphone Explained
  28.4.2026, 06:15:01

  OpenAI and hardware strategy: from AI assistant to potential smartphone

  In April 2025, Reuters and other media reported that OpenAI is working with Qualcomm and MediaTek on processors for an “AI-first smartphone,” targeting mass production by 2028. This is notable because it contradicts previous reporting: Sam Altman and Johnny Ive had emphasized for months that they would not build a phone but rather “what comes after the phone.”

  The core strategy: OpenAI wants to control the interface between user and AI. Currently, every AI app sits within an ecosystem controlled by Apple or Google—with their app stores, notifications, sensors, and habit loops. OpenAI instead wants to create the “iPhone moment for AI”—primary access to the real world through its own device.

  In May 2025, OpenAI acquired IO, a hardware company founded by former Apple designer Johnny Ive, for approximately 6.4 to 6.5 billion dollars. This matters: Ive shaped the iMac, iPhone, iPad, and other devices—someone with experience collapsing multiple functions into a single object.

  The first prototypes were not described as smartphones. Instead, reports pointed to compact, screenless, possibly wearable devices—with a “quieter” aesthetic than current smartphones. Altman compared current smartphone use to “constantly walking through Times Square, bombarded by distractions,” while the AI device should feel like “sitting by a quiet mountain lake.” The idea: the device understands context and your state so well that it interrupts you less—it doesn’t constantly vibrate, flash, and demand attention.

  But this requires massive data collection: camera, microphone, knowledge of your location, activities, what you’ve read. This creates significant privacy issues, especially for people near you who haven’t consented to being part of your AI context.

  The hardware challenge is less about industrial design than behavioral design. The first device must balance between “too cold and unusable” and “too friendly and creepy”—neither talking too much nor too little, present enough to not be forgotten.

  Earlier AI gadgets have failed: Humane AI Pin ($699) was returned more than sold (only ~10,000 units versus hoped-for 100,000 in the first year); reviews were scathing. Rabbit R1 ($199) received 1.5 of 5 stars due to unreliable performance and missing features. The core problem: users don’t simply reward “AI-native hardware” but rather reliability, battery life, and genuine convenience—and don’t want to carry another device.

  Current reporting is confusing because the timeline is muddled: January 2026—disclosure of plans for “second half 2026” launch; court documents suggest hardware won’t ship before end of February 2027; now reports of smartphone processors for 2028. The most likely explanation: OpenAI has multiple hardware projects running in parallel—a screenless, “quiet” device (the Johnny Ive project) and possibly a true smartphone later.

  The deeper strategic question: Can OpenAI build a device useful enough to carry around, trustworthy enough technically and privately, and “quiet” enough to not just be another distraction-focused rectangle? The smartphone gave the internet a pocket; OpenAI is trying to give AI a body. If it works, the next major platform might not be a visible iPhone but something you wear or carry that constantly listens and understands.

  Explicitly addressed: OpenAI (ChatGPT, general strategy), Qualcomm, MediaTek, Johnny Ive, Humane AI Pin, Rabbit R1, Apple, Google. Format: opinion/reflection with news elements.

Theo – t3․gg (5 new videos)

• Seriously, Anthropic??
  1.5.2026, 21:26:53

  The creator heavily criticizes Anthropic for multiple unacceptable practices around Claude Code:

  The main issue: Anthropic detects third-party tools (like OpenClaw, Hermes Agent) via keywords in system prompts and git commits and charges these users overage fees—even though they haven’t exhausted their monthly quota. One user was charged $200 after merely mentioning “Hermes.md” in a commit message, not even because they actively used Hermes Agent.

  Why this happens: Anthropic justifies the blocking with caching efficiency. The creator refutes this with concrete numbers from his service T3 Chat: At ~$40k monthly Anthropic costs, 50% of fees come solely from prompt cache writes—despite providing virtually no benefit (he tested disabling caching and costs didn’t drop). Anthropic is bad at caching itself but can’t charge more for it because then Claude Code would become equally expensive.

  Systemic issues:

  • Claude Code measurably underperforms compared to competing tools
  • Dario (CEO) hates engineers and looks down on them—hence the product lacks priority
  • This contempt trickles down: The team hates its users and deliberately builds hostile mechanics
  • The detection and git history are architecturally misaligned—a bug type pointing to fundamental design flaws

  OpenAI comparison: Costs the creator less than half as much, better support, genuine collaboration with researchers—not contempt.

  Creator’s conclusion: Anthropic is beyond saving. The engineering is toxic, corporate culture is a cult, user treatment is hostile. He won’t be diplomatic anymore.

  Tools/providers discussed: Claude Code, OpenClaw, Hermes Agent, OpenAI, T3 Chat (creator’s own service) | Format: Opinion/reflection with live demonstrations of reproducible bugs | Difficulty: advanced (requires understanding of prompt caching, API billing, system architecture)

• Github is Falling Apart
  30.4.2026, 09:55:10

  The creator delivers an emotional reckoning with GitHub after 15 years of intensive use. He documents four escalating critical reliability issues: first, inconsistent functionality; second, frequent outages (measured real uptime of ~86.75% vs. officially claimed); third, the horror scenario of merges spontaneously reverting (2,804 PRs on April 23rd); and fourth, new security vulnerabilities like an RCE and NPM package abuse under known names.

  The creator attributes the structural fault to leadership vacuum (no CEO since the previous one left, direct subordination to a Microsoft VP for AI/Infrastructure rather than a dedicated leader) and dysfunctional division between product and engineering teams with no overlap—a structure that only works with strong leadership.

  Kyle (COO) is sharply criticized for downplaying the severity of the merge incident with euphemistic language (“regression in merge queue behavior,” “appear reverted”), deepening trust erosion and never apologizing. Mitchell, creator of Vagrant and Terraform, publicly announces after 18 years that he’s migrating his flagship project Ghosty off GitHub because he’s documented daily outages in a journal and can’t work anymore.

  Additionally catastrophic: GitHub/NPM ignored a name-squat at “TanStack,” after which malware was later uploaded under that name on NPM—open-source maintainers were directly exposed to security threats. The creator concludes: On all four reliability levels, GitHub has failed; there’s no foundation of trust left to build on.

  Context: Opinion/reflection; no specific AI tools mentioned, but criticism of infrastructure platform GitHub under Microsoft ownership.

• Claude Code’s favorite tech stack
  29.4.2026, 08:33:14

  Summary: What AI models recommend when selecting tech

  The video analyzes an extensive study of recommendations Claude Code makes when choosing technologies for various developer projects—starting with the sobering finding that Claude spread a dangerous hallucination, falsely claiming PlanetScale had shut down its service.

  The key insight: Claude Code functions as a new gatekeeper for tech decisions. When developers let tools choose, the agent doesn’t just install packages—it shapes the entire architecture through its selections. Across 20 categories (databases, styling, testing, deployment, etc.) spanning four project types, a heavily consolidated stack emerges: GitHub Actions dominates CI/CD at 94%, Stripe at payments with 91%, Shadcn UI for components at 90%. Vercel is 100% the deployment target for JavaScript. Claude favors DIY solutions over established tools in 12 of 20 categories—especially feature flags (70%), observability (only 22% DIY), and email (22% DIY, which the speaker strongly warns against).

  Interestingly: Postgres gets 58% database recommendations, yet SQLite receives zero primary picks despite the models knowing it. For state management, Claude now ranks Zustand as equally popular as Tailwind (~68%), while Redux has fallen to 21.5M weekly installs versus Zustand at 22M—a paradigm shift.

  A critical comparison with Codex (OpenAI model) reveals Claude Code recommends Bun for Next.js runtime (wrong—Next runs on Node), while Codex correctly explains that Node is the safe path and only tooling (PNPM/Bun for install) can speed things up. Claude often misinterprets questions as “vibes” rather than precise instructions.

  The speaker tests in parallel how often Claude Code recommends its own Upload Thing tool—Opus 4.6 hit 100%, showing newer models are more willing to mention newer/specialized tools. Older models fall back on established standards.

  Explicitly mentioned tools/models: Claude (Sonnet 4.5, Opus 4.5, Opus 4.6), OpenAI Codex, Upload Thing (speaker’s own project), plus numerous recommended tools like Vercel, Postgres, GitHub Actions, Tailwind, Shadcn, Zustand, Drizzle, React Hook Form, Stripe, Railway, Resend—opinion/reflection with deep-dive elements.

• Realistic advice about software dev right now
  28.4.2026, 07:55:10

  Summary: “How to Learn and Actually Get Hired as a New Dev”

  Theo discusses how learning and job hunting have fundamentally changed for new developers. He observes that back when he entered—there was a bottleneck for good developers and companies were willing to bet on potential. Today the dynamics are reversed: there are overqualified candidates from layoffs, more applicants than jobs, and AI makes it harder to distinguish genuine competence from superficiality.

  The central point is a shift in priorities: The three traditional hiring factors—urgency (time pressure), likability (appeal), and competence—no longer work the same. Urgency is gone, competence alone isn’t enough anymore. Likability is now decisive. This means: not through technical perfection, but through genuine interest and human connection.

  Core recommendations:

  • Find things that excite you—in code, frameworks, or concepts—and dive deep, not out of obligation but because it’s fun.
  • Surround yourself with better devs—really or virtually. It protects against Dunning-Kruger and gives you realistic benchmarks.
  • Thank people whose work you love—with genuine, brief DMs. It creates human connection and makes you visible.
  • Explore “who” not just “how”—look at GitHub profiles of makers, not just their code. Understand their motivations.
  • Use AI for thinking, not doing—ask for approaches, hints, and whys, not solutions.
  • Go horizontal and vertical—don’t specialize only vertically (depth) but explore neighboring areas (breadth).

  Theo emphasizes at the end that in a world full of AI-generated content, only the human component matters. Genuine gratitude, enthusiasm, and relationship-building are the only differentiators. The opportunities aren’t gone—but whoever can excite themselves and share that with others finds their way.

  Format & tools: Opinion/reflection video on job market and junior dev growth; no specific AI tools or platforms discussed (beyond generalized “AI”).

• Markdown is a terrible language
  27.4.2026, 08:30:48

  The creator discusses critically why Markdown continues to be used everywhere despite its flaws. He starts with his personal belief in Markdown—he’s even passed up job opportunities if he couldn’t submit his application in Markdown. However, he argues that Markdown has now been taken too far, particularly through use with LLMs and agents as a communication medium.

  The author’s main issues (based on a cited article):

  Markdown was designed as a simple language to convert markdown files to HTML but fails at that simplicity: there are multiple syntaxes for the same result (e.g., different ways to write bold or italics), leading to parsing vulnerabilities—even a ReDoS security hole (Regular Expression Denial of Service).

  Inline HTML in Markdown was a bad idea because it requires a full HTML parser and massively increases the attack surface for cross-site scripting. Markdown’s grammar is no longer context-free but context-sensitive, significantly complicating parsing—footnotes and references change how earlier parts of the document are interpreted.

  The core problem: Markdown was designed as a transliterator (1:1 mapping) but has grown into a full compiler with dependency graphs—custom callouts, math support, CSS scoping, and plugins have turned it into a Frankenstein monster that’s neither true markup nor programming language.

  Alternatives are discussed and rejected: plain text, reStructuredText, MDX—all have problems. The author instead advocates for a purposefully built tool with clean, unambiguous syntax and a build system offering formal hook support rather than patching markdown chaos with shortcuts.

  The creator also references an older essay by Jeff Atwood who called on John Gruber back in 2012 to evolve Markdown or bless it—which never happened.

  Tools/providers: Markdown, CommonMark, Obsidian (mentioned); Format: Opinion/reflection (essay reaction); Difficulty: formal language and compilation theory is touched on but explained accessibly.

Tim Carambat (2 new videos)

• Hey Anthropic, That Looks Illegal?
  29.4.2026, 21:41:25

  Summary:

  Timothy Carambat reports from San Francisco, where he participates in the AMD AI Dev Day and discusses the use of local models. He criticizes the narrative that AI can replace humans, emphasizing that AI is a tool that should be used by people.

  A central theme of the video is the “enshittification” of AI tools, particularly Claude. Anthropic attempted to remove Claude Code from certain subscriptions and later reversed course. Additionally, there was a billing issue where users with certain character strings in their Git history were incorrectly charged extra fees. This led to negative user backlash, as Anthropic initially refused refunds but later offered a solution.

  Carambat argues that such issues indicate companies like Anthropic are resorting to questionable methods due to cost concerns. He recommends using open-source tools like pi.dev or Hermes Agent in combination with local models to avoid these problems.

  Final comment:

  The video explicitly addresses Claude by Anthropic and open-source tools like pi.dev and Hermes Agent, targeting intermediate users.

• The Cloud AI Situation is Bad.
  28.4.2026, 17:00:17

  The video discusses the “enshittification” of AI tools—the degradation of services and products over time, often accompanied by price increases and removal of features. The author uses examples like Airbnb, Uber, and Netflix to illustrate this phenomenon but focuses primarily on AI-specific examples such as GitHub Copilot and Claude Code. With GitHub Copilot, plans were heavily restricted, models were removed, and terms of service worsened, resulting in significant service degradation. Similarly, Claude Code saw features removed and usage limits introduced, negatively impacting the user experience. The author argues that these developments indicate cloud-based AI services are not sustainable in the long term and that local AI solutions represent the better alternative. Local AI models offer stability since they don’t depend on external factors like price increases or feature removals. Additionally, local models are now powerful enough to handle many tasks previously done in the cloud. The author emphasizes that local AI is the future and that many tasks, particularly productivity and coding-related work, could shift to local machines in the near future.

  Final comment: The video explicitly addresses GitHub Copilot, Claude Code, and local AI solutions like Anything LLM. It targets intermediate and advanced users who engage with the technical and economic aspects of AI.

Unsupervised Learning

No new videos in this period.

WorldofAI (6 new videos)

• Gemini 3.5 Flash In Arena! POWERFUL, Cheap, & Fast NEW AI Model! (Fully Tested)
  3.5.2026, 06:44:45

  Summary

  Google is testing behind the scenes an upgraded Gemini 3 Flash model hidden under the same model slug in an arena, but delivering significantly better output quality — users report reasoning and response quality approximately two levels above the current standard and closer to Gemini 3.1 Pro. In parallel, Google has informed Vortex AI customers that Gemini 3.1 Flash Light will soon be generally available. The theory is that Google will release version 3.1 Flash before Google IO (May 19–20), then announce Gemini 3.5 Pro at the conference itself, followed by Gemini 3.5 Flash in June/July — this would close the performance gap between 3.0 Flash and the more powerful 3.5 Pro.

  The creator tests the new model with several tasks: In front-end development (macOS browser UI, 360 product viewer, React animations) it shows quality on par with 3.1 Pro. In 3D graphics (ThreeJS) it produces impressively detailed scenes — a PS5 controller achieves 9/10, a 1970s TV simulator with nine different channels and real-time rendering works very well, only terrain navigation falls short. SVG generations (butterfly, pelican on bicycle) are solidly animated but show minor accuracy issues. The model is accessible via the arena in battle mode and proves significantly more powerful for complex creative and technical tasks than typical Flash variants.

  Concluding: Google / Gemini 3 Flash, 3.1 Pro, Vortex AI discussed — demo & opinion/reflection.

• Claude Sonnet 4.8 Leaked, Claude Cardinal, New Gemini 3.5 Model In Arena, & More! AI NEWS
  2.5.2026, 07:22:11

  AI News: Claude Jupiter, Gemini 3 Flash Update, and more

  Claude Jupiter and Anthropic Developer Event

  Anthropic is apparently preparing a new model release: code strings internally reference a model called “Claude Jupiter”. Whether it’s Sonnet 4.8, Haiku 4.7, or even Claude 5 remains unclear, but timing points to an announcement at the Code with Claude Developer Conference on May 6. Historically Anthropic has used similar code names (Neptune before Claude 4), so many expect a release soon. The new model is currently undergoing safety evaluations, jailbreak tests, and constitutional classifier stress tests. Additionally, Anthropic is working on a new feature called “Cardinal” for Claude that will give users a visual overview of their activities — conversation clusters, work styles, and focus areas in a kind of AI analytics dashboard for memory.

  Gemini 3 Flash improves significantly

  The Gemini 3 Flash model was quietly updated in LM Arena. Despite the model name remaining the same, it shows significantly better output quality — approximately two levels above the previous version and closer to Gemini 3.1 Pro. Tests show improved reasoning and response quality; one user created a functional Minecraft clone with block placement and terrain generation using it. At the same time, Google announced that Gemini 3.1 Flash will soon be generally available. You can test the new Flash model in battle mode via LM Arena (now called “Arena”).

  OpenAI Codex: Pets and Migration

  Codex received two practical updates: The “Pets” feature allows animated companions on screen that aren’t just cosmetics but also display live Codex activity (active threads, whether the agent is running, waiting, or ready). Additionally, OpenAI is integrating a new migration system that lets users import settings, plugins, agents, and project configurations with a few clicks — to simplify the switch to Codex.

  ARC AGI 3 Benchmark and further updates

  The new ARC AGI 3 benchmark scores show how difficult true generalized intelligence still is: GPT-5.4 achieved 0.02%, GPT-5.5 improved to 0.4%. Anthropic’s Opus 4.6 Max came in at 0.5%, Opus 4.7 at 0.2%. Even the best models barely solve these tasks. GitHub is working on a Copilot Max plan for $99/month. XAI released Grock 4.3 via API with new “Imagine Agent Mode” that connects text, image, and video generation in one workspace.

  Format & Tools: Roundup, covering Anthropic (Claude Jupiter), Google (Gemini 3 Flash), OpenAI (GPT, Codex), Anthropic (Opus), XAI (Grock).

• Codex Browser Use IS INSANE! Controls Your Computer & Automates Everything!
  1.5.2026, 07:14:21

  Summary:

  The video presents Codex, OpenAI’s free app with GPT 5.5, combining coding, browser automation, and computer control. The central focus is the newly integrated browser-use function as a plugin, enabling Codex to test applications like a real user — by clicking, taking screenshots, and understanding visually while simultaneously debugging console and network logs. GPT 5.5 achieves 78.7% on the OS World Verified benchmark and is significantly more token-efficient. The speaker demonstrates several use cases: automated workflows like daily AI news scraping in PDF form, local testing of a notes app with simulated user interaction, automated chess playing for functionality testing, and file management on the desktop. Another feature is integration with Apple’s iPhone mirroring for app testing on the phone through visual interpretation. Computer use now runs 42% faster, which the speaker says enables GUI operations by models at human speed for the first time. Codex is freely available for Windows and macOS and aims to close the build-and-verify loop for local deployments, allowing autonomous coding agents to deliver high-quality, tested software changes with minimal human input.

  OpenAI (GPT 5.5), Codex with browser-use and computer-use plugins — demo/tutorial with strong hands-on component.

• Codex + GPT-5.5 = SUPER APP! Build and Do ANYTHING!
  30.4.2026, 07:57:02

  Summary: OpenAI’s GPT 5.5 and Codex as new coding workflow standard

  The creator argues that OpenAI has regained the lead in the AI race with GPT 5.5 — the model is faster, more token-efficient, and offers significantly better usage volumes than current alternatives. He criticizes Anthropic for using aggressive rate limits and allegedly reducing performance (lowering reasoning level from high to medium), undermining the appeal of the Pro plan: even with Opus 4.7 in Cloud Code, you burn through your daily quota extremely quickly, making the $20/month no longer justified. GPT 5.5 with OpenAI’s Codex is the much better choice — Codex functions as an autonomous coding agent similar to Claude Code, can write, debug, and execute code, offers browser automation, computer control, and even integrates DALL-E for asset generation.

  Codex features in detail: The tool has a user-friendly dashboard interface with plugin store (currently browser use, computer use, Sentry etc.), enables project organization, Git commits and PR creation directly from the app, offers live web preview for developed projects, and an integrated terminal. Users can set up automations (e.g., daily AI news briefings, automatic bug fixes) and granular permissions (sandbox-only, auto-review, or fully autonomous). Implementation planning features can be combined with different reasoning levels (medium to extra high) and speed modes. According to the creator, the tool manages to create complex projects (CS:GO clone, Terraria game) with minimal quota consumption and can also generate spreadsheets, PowerPoint presentations, and data analysis. Free with ChatGPT account for Windows and macOS.

  Explicitly mentioned tools/models: OpenAI, GPT 5.5, Codex, Claude Code, Anthropic/Claude, DALL-E. Format: Demo/tutorial with opinion component (comparison/ranking argumentation).

• Gemini 4.0 Soon, GPT 5.6 Spotted, NEW Open AI Labs, Codex Model, AI Robots & More! HUGE AI NEWS!
  29.4.2026, 05:51:05

  Summary: AI News Roundup – A week full of model drops and industry shifts

  OpenAI & GPT Updates: OpenAI launched GPT 5.5 five days ago and hints of GPT 5.6 are already appearing, expected next month. Additionally, a GPT 5.5 Codex model was discovered in backend logs, which could be optimized specifically for coding and agentic workflows in a few weeks.

  Google Gemini: Google is preparing Gemini 3.5 for its developer conference in 21 days. The Google Cloud CEO hinted in a podcast that internally there are very good benchmarks for a massive model in the 10-trillion-parameter range. Additionally, the Gemini app received new file generation capabilities and its own sandbox execution environment.

  Coding landscape: Root Code is ceasing operations and focusing on its new cloud agent product Rumote. This leaves Kilo Code as one of the last independent AI coding tools outside the large AI lab ecosystems. Kilo Code has relaunched its VS Code extension and now offers parallel agent execution, sub-agent delegation, and other features.

  New open-source models: Xiaomi released Mimo 2.5 Pro (1 trillion parameters with 42 billion active parameters, 1 million token context window) under MIT license and competes with models like Claude Opus 4.6 and GPT 5.4 in coding. Poolside AI, a new AI lab, launched Laguna XS2 (33 billion parameter MOE model with 3 billion active parameters) under Apache 2.0 — fully trained in-house on a single GPU.

  Claude Code Updates: New connectors for Blender and Autodesk Fusion enable direct integration into creative tools. The Slash-Res feature speeds up large sessions by up to 67 percent. Improvements include push notifications, better crash recovery, MCP server concurrent connectivity, memory optimization on Linux, and various UX fixes (scrolling, paste handling, terminal resizing).

  Nvidia Neatron 3: Nvidia released open-source Nvidia Neatron 3 Nano Omni (30 billion parameter hybrid Mamba-Transformer) for multimodal agentic workflows. The model processes text, images, videos, audio, documents, and charts with 256K context and offers 9.2x higher efficiency on video workloads compared to similar models.

  DeepSeek & Mistral: DeepSeek extended discounts on DeepSeek v4 Pro through May 31 with up to 75% API reduction and integrated 1-million-token window in Claude Code. Mistral AI is preparing a new model called Mistral Medium (approximately 128 billion parameters).

  Miscellaneous: China is automating retail with AI-powered robot cashiers. The trend of new AI labs shows a shift away from chatbot models toward optimized coding and autonomous agent systems.

  Video on OpenAI (GPT 5.5/5.6), Google (Gemini 3.5), Anthropic (Claude Code), Nvidia, DeepSeek, Mistral, Xiaomi (Mimo), Poolside AI (Laguna) and open hardware/OSS movement — news update aimed at developers.

• Xiaomi MiMo V2.5 Pro IS INSANE! New Opensource Frontier AI Model Beats Deepseek v4! (Fully Tested)
  28.4.2026, 06:39:15

  Xiaomi Memo 2.5 Pro: New open-source frontier model tested

  Xiaomi has released Memo 2.5 Pro, a new open-source model designed as a 1.2-trillion-parameter mixture-of-experts model with 42 billion active parameters, 1-million-token context window, and hybrid attention architecture. The model is available under MIT license and intended for commercial deployment. Two variants exist: Memo 2.5 Pro for advanced agentic workflows and software engineering, as well as Memo 2.5 as a native omni model with multimodal capabilities.

  The focus is on long-horizon agent workflows — the model is designed to handle thousands of tool calls with stable coherence and manage real tasks like creating complete apps. It uses 40–60% fewer tokens than GPT-4o, Claude Opus 4.6, and Gemini 3.1 Pro at comparable performance. Pricing is $1 per million input tokens and $3 per million output tokens.

  Access is available via Xiaomi’s Memo Studio, via API, or locally. The author tests the model with Kilo Code (including $25 free credits) and demonstrates several projects: a macOS clone with Minecraft clone including animated Finder app and functioning terminal; various frontend projects (SaaS landing pages, Slack workspace, Amazon product page); 3JS/WebGL scenes with physics simulation (lava lamp, SUV off-road test, multi-channel TV environment with nine different scenes); and SVG generation (pelican on bicycle with leg movement, animated butterfly).

  The model shows strengths particularly in frontend and 3D visualization tasks and often exceeds Deep Seek and Kimi, although it still has weaknesses in some tasks (e.g., 360° product viewer with 3D modeling). The author emphasizes that practical value doesn’t lie in benchmarks but in the ability to sustain long complex agent workflows without breakdown — the model is a serious candidate for productive AI systems beyond demos.

  Explicitly discussed models/tools: Xiaomi Memo 2.5 Pro, Kilo Code, Open Router, Arena, Deep Seek, Kimi K 2.6 / K 2.7, Gemini, Claude Opus, Minimax M2.7 — demo/hands-on review.

Zubair Trabzada | AI Workshop (1 new video)

• I Built An Entire Crypto Trading Team With Claude Code in 22 min
  2.5.2026, 16:03:31

  The creator built a free tool using Claude Code that analyzes cryptocurrencies through five parallel AI agents. The tool performs on-chain analysis (wallet movements, exchange flows), analyzes tokenomics and unlock schedules, evaluates sentiment across Twitter, Reddit and crypto communities, and creates technical and fundamental analyses — all in an automated research report.

  The tool generates a Crypto Score (0–100), ratings across five dimensions (On-Chain Health, Fundamental Strength, Technical Setup, Sentiment, Tokenomics), and concrete action recommendations with entry zones, price targets and stop-loss levels. Examples: Solana received 65/100 (Hold & Accumulate), Ethereum 69/100.

  Installation works in two ways: Paid community members download via private repository with a terminal command, free community users download a ZIP file with skills folders and copy them locally. After installation, users can generate full reports via /crypto analyze [Token] in Visual Studio Code or Claude Code. The creator demonstrates live analyses for Ethereum and Polygon with Markdown and PDF output.

  The system is based on a skills.md file that instructs Claude Code as an expert in crypto research — three phases: web discovery, parallel agent launch, report synthesis. Additional skills like crypto quick (60-second snapshot), crypto on-chain (whale tracking, active addresses), crypto sentiment (fear index, news tone, community health) are also available.

  The free community is open; paid members receive additional projects and a five-week program for launching your own AI agency.

  Claude Code (Anthropic) and five parallel custom agents as a skills system; demo with live analysis and step-by-step installation.

---

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