Blog

Claude Code at the Center: From Niche to Industry Standard – What’s Behind It

Sunday, January 25, 2026

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

Model Releases & Benchmarks

The AGI timing debate dominated the strategic side of the week: Dario Amodei (Anthropic) predicted AGI at Nobel laureate level by 2026/2027 at the WEF, driven by self-improving loops — Anthropic engineers barely write code manually anymore. Demis Hassabis (Google DeepMind) remained more cautious with 50:50 by end of decade and named three missing capabilities: long-term memory, continuous learning, scientific creativity. Shane Leaue, DeepMind’s co-founder and chief AGI scientist, posted that AGI is “on the horizon,” accompanied by a job posting for a Senior Economist for post-AGI economics. DeepSeek published the Engram paper: a conditional memory architecture that uses hash functions to give transformers native fact retrieval — token-efficient and without high compute costs. Google released MedGemma 1.5 in two sizes (4B and 27B parameters): the 4B model runs on standard consumer hardware, processes 3D volumetric images, and achieves up to 80% accuracy on MedQA versus 70% for GPT-4.

Local & Open-Source AI

Black Forest Labs from the Black Forest released Flux 2 Klein in four variants: two 9B models (non-commercial license) and two 4B models (Apache 2.0), all designed for 8 GB VRAM. The distilled 4B model generates images with photorealistic quality in ~9 seconds — significantly less plastic-looking than earlier versions — on an RTX 5090 in 1.2 seconds. The AI with Arnie video provided six ready-made ComfyUI workflows and showed an alternative route: paste the JSON API export into a code editor to build a simple HTML frontend via Cloud Code. Leon van Zyl demonstrated how to redirect Claude Code to cheaper alternative models: via a .claw/settings.json with environment mapping, Claude models are redirected to GLMs from the Chinese platform ZAI — 30 dollars monthly instead of 100–200 dollars, with comparable performance according to Code Arena leaderboard.

Claude Code & Anthropic Tooling

Claude Cowork was the second major Anthropic theme of the week: multiple channels (Alex Finn, Everlast AI, Mark Kashef) demonstrated the Claude Desktop App GUI in practice — the system asks for three priorities in the morning and then handles tasks like newsletter drafts, research, or presentations in parallel without explicit delegation. Technically it runs via a claude.md rules file and a folder structure with context, inbox, and outbox folders that inform the agent about the person and their projects. In parallel, Anthropic released a revised “Constitution” for Claude — Theo (t3.gg) analyzed the 26,000-token document as a “system prompt at training level” that prioritizes four properties: safety, ethics, policy compliance, genuine helpfulness, and explicitly forbids sycophantism. Melvynx documented three relevant Claude Code updates in version 2.1.19+: Tool Search for MCP context conservation, migration of slash commands into skills, and the new tasks system that lets multiple agents coordinate on a shared task list across session boundaries.

Coding Agents (non-Claude)

Agent OS v3 from Brian Casel emerged as a lean alternative to heavy agent frameworks: 70% reduced footprint, three core functions — automatic standards discovery in the codebase, enhanced spec shaping in tandem with Claude Code’s plan mode, and switchable profiles for different project types. Cole Medin revised his earlier skepticism toward Ralph Wiggum: the real value lies not in free-wheeling vibe coding, but in rapid proof-of-concept validation — a bash loop starts Claude with fresh context, reads status from an activity log file, and continues autonomously until all PRD tasks are marked as passes: true; a habit tracker app emerged this way for seven cents in API costs. Kiro, a new AI coding tool with PPIAV loop (Plan, Implement, Validate), was the focus of a live stream from Cole Medin; the hackathon prize pool is 17,000 dollars. Kilo Code — founded by GitLab co-founder Sid — raised 8 million dollars in seed funding and launched an app builder after six weeks of development that deliberately targets engineers rather than no-code users.

Software Engineering & Dev Culture

Theo (t3.gg) delivered the week’s sharpest error analysis: too much irrelevant context massively degraded model performance — Sonnet 4 drops from 100% to below 60% success rate when you dump the entire codebase in. His recommendation: keep claude.md files small, document only gotchas, use tools for navigation instead of repomix dumps. Also from Theo: libraries are losing significance — he increasingly rewrites them with AI rather than patching dependencies, describes prompts as the “new library,” and cites Shad CN as a model for copy-paste-instead-of-npm. NeuralNine explained best practices for agents.md files: place commands early, provide examples instead of explanations, name stack versions explicitly — the format works vendor-agnostically across Cursor, Windsurf, and Claude Code equally.

Personal AI OS & Agent Frameworks

Alejandro AO built OpenCowork — a local Claude Code alternative based on the OpenAI Agents SDK (which despite its name is model-agnostic) and Ollama, with three tools: shell execution with allowlist, URL fetching, and DuckDuckGo web search. Dave Ebbelaar showed a complete human-in-the-loop pattern for production: on critical operations (e.g., money transfers over 100), the agent persists its state to a database, signals approval need to the frontend, and resumes from storage after user click — compatible with SSE streaming and asynchronous event-driven backends. Clawbot (open source, from Peter Steinberger) was shown on multiple channels as a “24/7 AI coworker”: no guardrails, persistent memory, controlled via Telegram/iMessage, runs on a Mac Mini for 500 dollars; Alex Finn warned that Anthropic will probably not tolerate this unrestricted usage in the long term.

AI Automation & Workflows

Nate Herk showed a system where failed n8n workflows are automatically repaired by Claude Code — via Ngrok tunnel to the local Claude Code process, equipped with n8n MCP server and workflow documentation, implementing fixes directly rather than just planning. The same principle in reverse: his second video demonstrated how an n8n workflow automatically generates Gamma presentations after sales calls — Fireflies provides the transcript, an AI agent formulates it as a senior sales engineer prompt, Gamma builds a designed slide deck from it. The Everlast AI mega-course taught seven tool categories and an IPO principle (Input-Process-Output) as base architecture; concretely demonstrated was a voice agent receptionist with Eleven Labs that takes calls in German and forwards them to sub-agents for different inquiry types. Chase Hannegan (n8n channel) scaled from zero to 200,000 followers with a content ideation workflow: scrape four sources daily (YouTube, Reddit, Twitter, Perplexity), analyze with OpenAI mini-model, generate trend reports and finished scripts.

AI Video & Content Creation

Higgsfield AI was presented as an all-in-one platform for image and video generation: access to Nano Banana Pro, batch generation up to four images simultaneously, direct animation and preset creative effects — the unlimited subscription model without rate limiting is cited as the main advantage over Google Gemini. On the workflow side, Chase Hannegan’s n8n video showed how to automatically aggregate content ideas from four platforms daily and feed them directly into script drafts — the OpenAI mini-model analyzes transcripts, a Callaway framework structures hook, body, and CTA. Nate B. Jones argued that image generation is wrongly framed as a design tool: the real value lies in closing the visual gap in enterprise automation chains — everywhere screenshots, compliance documents, or competitive analyses previously required human translation work.

AI Business, Marketing & Freelancing

Alex Finn laid bare how he earned 500,000 dollars in 2025 with Claude Code: 300,000 dollars via SaaS app Creator Buddy, 100,000 dollars via content — the mechanism is a flywheel of building, creating, earning, and listening. Kyle Balmer presented Greg Eisenberg’s app rebuild playbook: find apps with high downloads, low ratings, and stable revenue via Sensor Tower, rebuild them with Claude Code or Manus, release cheaper and without aggressive monetization — Manus now has iOS/Android publishing integrated so Xcode becomes redundant. Liam Ottley showed a workflow on LinkedIn-side with the tool Cleo (trained on personal writing style): four posts per week with SLAY framework (Story → Lesson → Actionable Advice → You) outperforms daily generic content on follower growth and lead generation. Niklas Steenfatt offered a sober overview of six ways to scaled income: print-on-demand with Printful, digital products, employee scaling, SaaS with Claude, ETFs/real estate, and content — content being ranked as best entry option because of combinability with the other models.

PKM & Knowledge Management

Google Notebook LM received extensive tutorial coverage: core principle is strict source binding (up to 50 sources, 25 million words) without hallucination outside these sources, combined with the studio panel for presentations, audio podcasts with two virtual speakers, mind maps, and study cards. Kyle Balmer recommended the Feynman principle as workflow: curate sources, generate slides from them, present them as a camera presentation — simultaneous learning, teaching, and audience building. AnythingLLM Desktop 1.10 brought a meeting assistant that fully locally transcribes and summarizes, offers speaker identification, and automatically suggests matching agent skills after the meeting — in the demo, a GitHub MCP server directly created an issue from meeting content. Nate B. Jones showed four community patterns for second-brain systems: portable architecture across tools, principle-based rather than rule-based agent instructions, self-maintaining systems that know their own infrastructure, and hybrid databases (Postgres + vector DB) as API endpoint for other applications.

Prompting & AI Literacy

The AI and Strategy channel mapped eight value categories for AI engineering — from code assistants to image generation to workflow automation — and emphasized the last-mile problem: a demo at 80% quality is achievable in a weekend, going from 80% to 95% took LinkedIn four months. The core argument: in global digital competition, a power-law dynamic applies where using AI twice as well doesn’t yield twice but exponentially better results. Nate B. Jones identified six practices for top builders: engineering-manager mentality over craftsmanship, less structured upfront inputs (progressive rather than complete specification), fluid switching between abstraction levels, two brain modes (flow and reflection), distinguishing delegable conventions from non-delegable taste, and the realization that production experience is not compressible.

AI Industry & Strategy

XAI closed a Series E at an implied valuation of 230 billion dollars — on par with OpenAI and Anthropic — and uses it to expand the Colossus supercomputer in Memphis with over one million H100 GPU equivalents, where Grok 5 is being trained. The strategically most significant deal of the week: Apple decided on Google Gemini as the foundation for its next generation of foundation models, abandoning ChatGPT as a partner and paying an estimated one billion dollars annually to Google. For OpenAI, that means triple damage — PR loss, revenue loss, and sales decline. In response, OpenAI launched ChatGPT Go ($8/month) with ads on free tiers, which Sam Altman still called a “dystopian vision” in 2024; Theo and Kyle Balmer independently analyzed that OpenAI’s ad model is structurally weaker than Google’s or Meta’s because targeting depth is missing. Cloudflare acquired Astro Technology: the framework remains MIT-licensed and platform-independent but receives stable full-time developers for the first time — Theo saw this as the rare combination of Cloudflare’s global infrastructure with Astro’s modern developer experience for static websites.

AI & Society / Future of Work

Anthropic’s own economic report (based on November 2025 usage data) showed: 52% of Claude chats aim for augmentation rather than complete automation; AI adoption converges across US states ten times faster than 20th-century technologies, with parity expected in 2–5 years. The concept of “effective AI coverage” weighs not just theoretical automatability but actual time share and success rate — yielding realistic productivity gains of around 1.0–1.2% rather than the theoretical 1.8% per year. David Shapiro provided several counterarguments: math AI has driven frontier math benchmarks from under 2% (2024) to around 40% (early 2026), with self-play via synthetic proofs as the key mechanism; the “age of verification” might make formal proof of programs routine. On whether AI destroys capitalism, he steelmanned the thesis and identified sovereign wealth funds with citizen dividends as the only redistribution solution that maintains the production-wage-consumption loop without wage labor.

In Brief

PG Text Search brings BM25 ranking directly into PostgreSQL without Elasticsearch (Tim, Tech With Tim); the Cloudflare-Astro acquisition makes Astro a fully-funded open-source alternative to Vercel-centric workflows. Pencil.dev combines design canvas and code repository in one workspace with MCP integration for Claude Code and Cursor. Zenflow from Zenoder orchestrates spec-driven multi-agent workflows with built-in code review and GitHub integration. Antigravity (Google’s free agentic IDE) was shown multiple times combined with n8n, OpenCode, and Whisk; the UI-UX-Pro-Max-Scale framework as installable skill measurably improves generated design outputs. Grokipedia, a fast Wikipedia alternative from xAI with real-time fact-checking, was briefly mentioned. Harmonic solved new Erdős problems after Terence Tao’s confirmation and positions itself on mathematical superintelligence. For coding interview preparation, Tech With Tim recommended a three-phase framework (planning, preparing, passing) with 75–100 curated LeetCode problems as the centerpiece.

AI Explained

No new videos in this period.

AI Foundations

No new videos in this period.

AI with Arnie (1 new video)

• This German AI runs completely offline
  18.1.2026, 09:31:25

  Summary: This German AI runs completely offline

  Black Forest Labs from the Black Forest has released Flux 2 Klein – compact, efficient models for local image generation and editing that run on weak computers. The video shows how to use them offline with ComfyUI and provides six ready-made workflows for free.

  The four models:

  1. Flux 2 Klein (9B, distilled): 4 steps for rendering, very fast (2 seconds on RTX 5090), runs on 8 GB VRAM, non-commercial license.
  2. Flux 2 Klein Base (9B): Not distilled, more flexible for fine-tuning, longer rendering time, also non-commercial license.
  3. Flux 2 Klein (4B, distilled): Commercially usable, only 8 GB VRAM needed, Apache-2.0 license, 1.2 seconds on RTX 5090.
  4. Flux 2 Klein Base (4B): 17 seconds on RTX 5090, perfect for fine-tuning, Apache-2.0 license.

  Practical application with ComfyUI:

  The six workflows cover text-to-image (with base and distilled models) as well as image editing (each in base and distilled versions). Installation: download models from Hugging Face/GitHub (Qwen-3 text encoder, Flux diffusion models, VAE decoder), move them to the correct ComfyUI folders, import workflows, generate. ComfyUI can partially download models automatically.

  Quality and performance:

  Images look photorealistic – significantly less plastic look than previous Flux versions. The distilled 4B model generates quality results in ~9 seconds, despite only 8 GB VRAM. With larger models or more steps (20 instead of 4), better quality but longer rendering time. Portraits occasionally show plastic skin or finger artifacts, but these have become rarer.

  Extras:

  If you don’t like ComfyUI, you can build a simple HTML frontend with Cloud Code by inserting the JSON workflow (export API) into a code editor. Black Forest Labs offers a prompting guide. Workflows can be found for free in a community or potentially soon under ComfyUI templates; paid premium community with support and courses available.

  The video covers Black Forest Labs’ Flux 2 Klein with ComfyUI – a tutorial with practical demos for local use.

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

• Apple Took Years to Catch Up. Kilo Code Took 6 Weeks–and It’s Coming for Lovable, Cursor, Replit
  24.1.2026, 16:00:04

  XAI closes $20 billion funding round: XAI announced an increased Series E round with an implied valuation of $230 billion – in the same category as OpenAI and Anthropic. The capital flows into expanding XAI’s Colossus supercomputers in Memphis, Tennessee. The company has over 1 million H100 GPU equivalents and is training Grock 5 there. With around 600 million monthly active users, Grock is one of the largest consumer-facing AI deployments outside of Google and OpenAI. Despite a security incident (Grock generated inappropriate deepfakes) and regulatory investigations in five countries, XAI also secured a Defense Department deal. The funding signals that investors take a long-term view on AI value and are willing to look past initial challenges. This positions three labs – OpenAI, Anthropic, and XAI – for long-term scaling.

  Davos: AGI discussion between Anthropic and Google DeepMind: Dario Amodei (Anthropic) and Demis Hassabis (Google DeepMind) discussed the future after AGI. Amodei predicts AGI this year or 2027, driven by a feedback loop where AI writes its own code – at Anthropic, engineers barely write code manually anymore. He warned of massive disruption at entry-level positions. Hassabis was more cautious, estimating a 50% probability of AGI by decade’s end. A central disagreement: Hassabis argued that jobs aren’t easy to automate, and that if AI masters 95% of skills, that makes the remaining 5% – which humans must perform – valuable. Hassabis identified three major AI problems: memory, continuous learning, and long-term reasoning.

  Apple–Google agreement: Apple and Google announced a multi-year partnership in which Apple’s next foundation models will be based on Google’s Gemini. Google is reportedly building a custom 1.2 trillion-parameter Gemini model specifically for Apple. This is a major blow to OpenAI – the deal volume is estimated at around a billion dollars per year. ChatGPT slips from a potential OS layer to a secondary position, while Gemini becomes the standard OS on iOS and Android. This increases pressure on OpenAI to achieve distribution through a third-party device.

  DeepSeek’s Engram paper: DeepSeek published a paper on Engram, a conditional memory architecture that addresses a Transformer problem: they lack native knowledge retrieval capability. Engram uses hash functions to look up short sequences (2–3 tokens) in massive embedding tables and filter retrieved patterns against the current context. This enables substantial performance gains without high token costs – an extremely token-efficient way to provide factual memory.

  Kilo Code: App builder for engineers: Kilo Code – founded by GitLab co-founder Sid and CEO Scott – launched its app builder after just six weeks of development and raised $8 million in seed funding. Kilo’s positioning differs deliberately: while Lovable targets non-technical users, Kilo targets real engineers. The company follows GitLab’s playbook – open source, broad reach, engineer-friendly. Five engineers delivered the first internal demo in 3 days; 6 weeks later came the public launch. The public roadmap (estimated 12–18 months) represents only another 5 weeks of work. This signals that the vibe coding market is maturing – from “AI can write code” to “which differentiated tool fits into my workflow.” The open question: Is there room for a fourth player between Lovable and Cursor?

  Featured tools/providers: OpenAI, Anthropic, XAI/Grock, Google/Gemini, DeepSeek, Lovable, Cursor, Kilo Code, Replit. – Format: News update/roundup.

• The Builders Who Figure This Out First Will Be Impossible to Catch. Why You Need an Identity Shift.
  23.1.2026, 15:00:17

  The bottleneck in AI usage has shifted: basic skills like prompting are necessary but no longer sufficient. The real problem now lies in cognitive architecture and systems thinking. While models (like Claude and Gemini) become exponentially more powerful, many developers and workers lack the mental toolkit to work with them effectively.

  The speaker identifies six core practices of top-1% builders for 2026:

  1. Engineering-manager mentality: The focus is no longer on writing code itself, but on responsibility for overall quality, direction, and throughput of agents – analogous to team management. This requires an identity shift, especially for hands-on specialized individuals.
  1. Shed the “contribution badge”: The instinct to do preliminary work and structure everything before AI input is counterproductive. Modern models often work better with less structured, progressive input. The old habit of comprehensive prep has become overhead.
  1. Strategic depth-level switching: Rather than either understanding everything (traditional development) or nothing (vibe coding), builders must fluidly navigate between abstraction levels – down to critical code detail, up to agent orchestration. This prevents both stagnation and incoherent products.
  1. Create temporal distance: Workflow requires two brain modes: flow state for rapid execution (coordinating agents) and reflection state for learning. Without reflective distance, there’s no real feedback learning – speed without improvement.
  1. Distinguish two architectures: Formal architecture (conventions, code standards, writable rules) is delegable to agents. The second – “quality without a name” (taste, coherence, product vision à la Steve Jobs) – remains human work. This is the unsolved scaling problem.
  1. Experience is not compressible: The speed of software production is not the same as the speed of product understanding. Deep familiarity with what you’re working on takes time and iteration with real customers and real feedback. Everyone is now in the product business, even non-technicians with agents.

  Core shift: From one-way prompting to bidirectional partnership. AI challenges the human to clarify intent; the human must remain open to this unfolding. The only stable anchor in an accelerated AI environment is deeply understanding what really matters in your work – and not outsourcing that sense.

  Featured tools/models: Claude, Claude Code, Claude Co-work, Gemini Nano; opinion/reflection on the mindset shift for AI builders in 2026.

• The People Getting Promoted All Have This One Thing in Common (AI Is Supercharging this Mindset)
  22.1.2026, 15:00:36

  The traditional career ladder – from individual contributor to manager to VP – is being dismantled. Entry-level jobs at major tech companies have collapsed by over 50% because generative AI has taken over routine training tasks (summarizing meetings, cleaning data, writing memos) that used to onboard newcomers. This isn’t a temporary crisis; it’s a restructuring of career mechanics.

  The only working response is high agency – but not as a feeling; rather as an internal locus of control belief. The concept: everything that matters to you belongs in your circle of control – your next promotion, your skills, everything. If your head whispers “This is impossible; some of it’s outside my control,” respond with: “That’s a skill issue.” This distinguishes high-agency from low-agency people.

  This isn’t a bootstrapping myth: research shows that internal locus of control correlates with 20–30% better academic performance and companies led by such CEOs weather difficult times better. The point isn’t that you control a layoff, but that this mindset statistically correlates with better life outcomes.

  Two critical components: (1) Internal locus of control – everything is learnable, nervousness is a sign of inadequate preparation (like Kobe Bryant). (2) Say-do ratio – when you say something, do it immediately, not after weeks of planning. Start before you feel ready.

  AI is here the “greatest equalizer for agency”: It no longer requires years of expensive training or networks. With a laptop and determination, you can build websites from your phone. Passive people use AI as an answer machine (and lose skills in the process); high-agency people use AI as an extension of their capacity – to explore, learn, prototype.

  The facts: Solo-founder startups rose from 22% (2015) to 38% (2024). AI unicorns used to need over 1,000 employees; now sometimes just 20. Example: Ma (founder of Base 44) built an $80 million acquisition as a solo founder with AI in 6 months – no venture, no full-time teams.

  The pattern: High-agency people are obsessed with value creation. They know: push enough value out = the world gives back. They ship 10 projects instead of perfecting one, because iterations teach.

  Concrete steps: Take a goal you see as “outside your control” (promotion, your own business). Ask: What would I need to learn? Use AI to map the learning path. Then do it today, not after research.

  The essence: The old ladder isn’t coming back. What remains is agency + AI fluency + direct link between agency and value creation at scale. Passive people get left behind; high-agency people accelerate exponentially. The train leaves now – not sometime, not after a plan, but immediately.

  Format: Opinion/reflection; topic is agency as the core concept for the AI era (no specific AI tools named, but AI treated as a concept).

• The Skill That Separates AI Power Users From Everyone Else (Why “Clear” Specs Produce Broken Output)
  21.1.2026, 15:01:23

  Summary: The Skill That Separates AI Power Users From Everyone Else

  The video contrasts two fundamental philosophies of AI-powered software development using a thought experiment from the Cursor CEO: GPT 5.2 worked autonomously for a week and generated three million lines of Rust code for a functional browser rendering engine.

  The two paradigms:

  Claude Code (Anthropic) functions as a “colleague” – an active team member who stays in the loop. The tool searches, reads code, edits files, writes tests, commits to GitHub. The workflow emphasizes rapid feedback cycles: delegate task, receive feedback with clarification questions, iterate. Anthropic reports that Claude Code solves tasks that normally take 45+ minutes – with newer versions now taking 7-8 hours or a full day. This design enables scaffolding for learning: by explaining reasoning and asking questions, the developer is simultaneously educated.

  Codeex (OpenAI) functions as a “tool” – a cloud-based software engineering agent that delegates tasks end-to-end. It navigates a repository, edits files, runs commands, without intermediate steps. Codeex runs in isolated sandbox environments and can work on complex tasks over hours or even days – as the Cursor experiments showed.

  The core metaphor – craftsmanship vs. CNC machine:

  An experienced grinder manipulates metal with direct real-time feedback from the material. A CNC machine is programmed with precise coordinates and then executes autonomously – but if the program is wrong, it faithfully produces the error without questioning. Codeex is CNC-like: it needs precisely, correctly specified tasks and executes them with “superhuman precision.” Senior engineers benefit massively here (productivity reportedly doubles) because they have institutional knowledge to write exact specs. Claude Code is craftsmanship-like: it’s for developers whose intent evolves through the building process.

  Technical insights:

  Cursor found that GPT 5.2 even outperforms GPT 5.1 Codeex (specifically trained for coding) on long autonomous tasks – because general reasoning capabilities exceed specialized training. The ability to maintain coherent plans over extended periods is a generalized cognitive capability.

  The downside:

  Codeex is frustrating for junior/mid-level developers or when you don’t know what “right” looks like. Senior engineers aware of their boundaries succeed; most people overestimate their ability to specify intentions precisely. The video argues the most common problem is developers don’t realize this – they send vague specs, get incomplete results, and realize too late they built on faulty foundations.

  Scaling and risks:

  Cursor demonstrated with hierarchical multi-agent structures (planner, worker, reviewer) that hundreds of agents can collaborate on the same codebase with minimal conflicts. However: the browser experiment was extremely expensive (estimated ~3 billion tokens) and produced only an alpha – the journey to production software still lies ahead.

  Implication for non-technicians:

  The colleague-vs-tool dilemma will hit beyond software. On a 100-page business proposal, non-technicians would need to write a comprehensive spec upfront with tool-shaped AI – which few can do. Their intent develops through writing. The video poses: the question of what high-quality specs for strategic docs, market analyses, or creative content look like is “almost completely unexplored” and one of the major questions for 2026.

  Conclusion and speaker’s personal recommendation:

  Not “Codeex better” or “Claude Code better” – it depends on whether you have domain expertise to write real specs and define correctness upfront. You do? Tool-shaped AI (Codeex). You don’t? Colleague-shaped AI (Claude Code) as a thinking partner. For organizations, the meta-question is: how quickly can you develop “high-grade intent specification skills” in your team? Organizations that crack this gain a different order of AI leverage. But the video warns: don’t confuse capability with readiness – integration into production workflows remains open.

  Featuring Claude Code (Anthropic), Codeex/OpenAI GPT 5.2, Cursor; format: opinion/deep-dive.

• Disposable Software: The Trend 90% of People are Getting Wrong–The Hidden Costs We Need to Consider
  20.1.2026, 15:01:28

  Disposable Software: The Hidden Complexity Behind the Trend

  The video analyzes why the concept of “disposable software” is misunderstood by most – not because it’s wrong, but because it’s applied to completely different contexts as if they were identical.

  The fundamental phenomenon: The cost of software development has collapsed – from expensive to practically free. This leads to an economic inversion: what’s cheap to produce becomes replaceable. This isn’t philosophy; it’s a description of economics. Example: a Rust browser was generated in a week by AI agents with 3 million lines of code – work that cost Chrome 2+ years with elite engineers.

  The critical misunderstanding: But there are two completely different phenomena under this name. The first is personal, one-off software (dashboards, widgets, travel apps) – a genuine democratization good. The second – and far more problematic – is disposable features in enterprise products.

  The heart of the debate: Cursor embodies the disposable philosophy: “code is reality” – constant shipping, weekly UI changes, instability as the price of innovation. It works for developers tolerant of change, but fails for enterprise customers. Meanwhile, it’s overlooked: the constraint was never software costs, but attention. An expensive engineer shouldn’t vibe-code internal CRMs to save $100/seat – the opportunity cost against the core mission is ruinous. Plus, maintenance overhead doesn’t disappear: AI-generated code has security holes; technical debt remains.

  The market truth: 95% of the market buys reliability, not features – whether Salesforce customer or HR system buyer. They pay for “peace of mind,” for something they can ignore. Even Cursor users – the most tech-tolerant population – complain about forced updates that delete chat history and overnight reconfigurations. This isn’t a transitional phenomenon; it’s structural.

  The right AI strategy for enterprise: Not imitate, but play differently. Reliability first, then proactive AI – not reactive chatbots, but agents acting without prompting: analyzing calls, suggesting coaching, identifying deals. That requires deep trust earned only through proven stability. Claude Code shows a design principle: simple interfaces (terminal) absorb frequent updates without visible disruption. A UI like Cursor’s creates friction at the same shipping speed.

  The four systematic errors in the debate: (1) treating all software as equivalent, (2) ignoring opportunity costs, (3) underestimating that the market is built on reliability, (4) taking edge cases (Cursor = 5% of the market) as the norm.

  The practical consequence: If you build for developers: maximum speed, full disposability. If for enterprise: prove reliability (uptime, security, support), then gradually expand into proactive agent features, with low error rate as the foundation.

  Salman Rushdie argues that current hype preaches “Cursor-ify-everything,” even though 95% of teams are playing a completely different game.

  No direct tool/vendor focus, but mentions Claude, Cursor, Lovable, Salesforce and the concept of proactive agents; format: opinion/deep-dive.

• They Ignored My Tool Stack and Built Something Better–The 4 Patterns That Work
  19.1.2026, 15:01:07

  The author analyzes four principles that distinguish successful AI system builders from failed ones, based on observed community builds of a “Second Brain” project:

  1. Architecture is portable, tools are not: The underlying structure of a system (capture point, sorting, intelligence layer, retrieval) stays stable across different tool combinations. A community member successfully built the system with Discord, Obsidian, and Mac Whisper, even though these weren’t recommended. The consequence: learn patterns, not specific tools.

  2. Principle-based rather than rule-based guidance scales better: A builder used Claude’s computer-use with TypeScript agents and gave the agent principles like “use test-driven development” or “don’t swallow errors,” instead of hard-coding rigid rules. AI systems can apply principles contextually and handle unexpected situations. A meta layer: agents building to good software development principles become reusable for different purposes.

  3. If the agent builds it, the agent can maintain it: A builder orchestrated multiple AI coding assistants with a writer-critic loop for validation. The key: the agent understands the infrastructure it built itself, can debug and self-heal it, without the human bearing context-switching costs. Agents can be later reactivated with conversational history documentation.

  4. Systems can be infrastructure, not just tools: A builder created a hybrid structured database (Postgres + vector DB for semantic search) with API endpoints so other apps could query the second brain – a toolkit for other developers. Another used Neo4j, Claude agents, and a “skills + evidence” layer that documents sources for every output. Technical skill enables scaling vision.

  Additional pattern: The most successful builders combined community knowledge (pattern library) with AI collaboration. They posted obstacles, received hints, and had Claude/ChatGPT implement the solution in their own context. Community provides patterns, AI provides implementation muscle, the builder provides intent.

  Concrete technology details: The built Zapier flow uses a Slack trigger, sends message text via Anthropic API to Claude for classification (with JSON schema), uses code steps for cleanup, split paths for routing based on classification, and creates Notion records with confidence scores and Slack feedback. Alternative patterns: YAML-based with Claude Code (session-based rather than always-on), Notion mobile export as capture.

  Individual successful variations show complexity isn’t necessary: Notion + inbox/outbox + Claude is enough. The author emphasizes: principles remain portable regardless of complexity – from simple setups to vector DBs and graph DBs.

  Closing reflection: 2026 disrupts old top-down building models. Community + AI creates new economics: shared pattern libraries (real-time updated) + AI implementation muscle + tool flexibility = unprecedented building speed. Technical skills aren’t dead (they’re valuable), but the new core model is: community (as pattern source) + AI collaboration (as force) + individual intent (what fits me) = build superpowers without technical gatekeeping.

  Context: Claude and ChatGPT mentioned throughout as AI partners; demo/reflection hybrid with strong practical focus on community builds.

• Stop Treating Image Generation Like a Design Tool–The Hidden Bottleneck Limiting Your AI ROI
  18.1.2026, 19:00:23

  The video argues that the debate around AI image generation (using Nano Banana Pro as example) has been framed incorrectly so far. Rather than seeing it as a design tool, it should be understood as infrastructure removing a fundamental constraint of past enterprise AI: the inability to reliably interpret and generate visual information.

  The invisible barrier: Past AI systems could process language – analyze documents, generate code, understand customer text – but failed with visual elements. Customer support tickets with screenshots, compliance documents with images, competitive analyses with visual assets: everywhere a human had to “translate.” This broke automation chains and excluded entire functional areas (marketing, training, customer service) from serious automation.

  The flywheel model: When visual AI integrates into enterprise workflows, a self-reinforcing cycle emerges:

  1. Bottleneck removal: Workflows requiring visual understanding (identity verification, quality control, document review) become automatable.
  2. Data generation: Every generated and interpreted image provides training signals. Systems can be continuously improved through API adjustments and business rules.
  3. Trust calibration: Visual outputs (annotated screenshots, diagrams, infographic summaries) verify faster and more intuitively through humans – people grasp correctness quicker than plain text.
  4. Workflow integration: Image generation becomes a universal interface between systems – like Lego blocks connecting data flows (e.g., automatically show customer ticket triaging visually to the product team).

  30% vs. 300% organizations: A 30% organization uses visual AI as a point solution in the design team – designers become more productive, impact stays local. A 300% organization builds visual AI as infrastructure across all systems: the product catalog auto-generates photos, support responds visually, documentation updates itself.

  Concrete high-impact areas:

  • Customer operations: Support agents receive visually annotated solution guides; AI interprets screenshots in real time. Up to 10x faster problem resolution.
  • Product management: Roadmaps, competitive analyses, feature specs generate programmatically → PMs focus on strategic decisions instead of slide production.
  • Training & enablement: Onboarding materials auto-update when processes or interfaces change; personalized visual explanations on demand.

  Framework for leaders – five questions:

  1. Where do visual communication bottlenecks slow your decisions (e.g., a week for visual material)?
  2. Which workflows currently fail because they require human visual interpretation?
  3. What becomes possible if visualization is instant and programmable (e.g., test 50 campaign variants instead of three)?
  4. Where are you embedding visual dependencies in human roles that become bottlenecks at scale?
  5. Are you thinking of visual AI as a department tool or enterprise infrastructure?

  The video warns of a time window: now is when to establish visual AI as infrastructure. In two years, these capabilities become baseline; integration patterns get documented and replicated. Those ahead now shape implementation and build sustainable competitive advantage.

  Context: Opinion/reflection; mentions Nano Banana Pro, mentions that Claude, Codeex, and other agents can call Nano Banana as a tool, plus Perplexity for news synthesis.

Alejandro AO (2 new videos)

• MedGemma 1.5: Google’s Open-Source Medical AI with 3D Imaging (Tutorial)
  22.1.2026, 11:00:00

  MedGemma 1.5: Google’s new open-source medical AI model

  Google has released MedGemma 1.5 – a free, open-source multimodal model for medical tasks, available in two sizes: 4 billion and 27 billion parameters. The smaller 4-billion model runs on standard consumer hardware and is new in its ability to interpret 3D and volumetric images – something previously reserved for proprietary models. In benchmarks, it achieves performance levels comparable to trillion-parameter models while running completely locally.

  The tutorial demonstrates installation with Hugging Face and the transformers framework (requires ~8 GB RAM, faster on T4 GPU). As a use case example, a chest X-ray is analyzed: the model creates general image descriptions, performs disease classification (e.g., pneumonia detection), and localizes anatomical structures. For all three tasks, it delivers meaningful, detailed analyses – such as identifying opacities in the right lung with possible differential diagnoses.

  Additional strengths of the model include medical multiple-choice questions (MedQA, EHRQA achieving up to 80% accuracy versus 70% for GPT-4), anatomical structure recognition, and data extraction from medical documents. A key advantage is local processing – all medical data remains on your own device without being transmitted to external providers. The video emphasizes, however, that professional medical interpretation of results remains necessary.

  Google Gemma, Hugging Face | Tutorial

• Create a Local Claude Code From Scratch
  19.1.2026, 15:07:20

  Summary: Create a Local Claude Code From Scratch

  The video demonstrates building OpenCowork – a local alternative to CloudCowork that runs with local models instead of remote servers. The application is powered by Ollama and can alternatively run via Hugging Face Inference Provider.

  How it works: The user grants the application access to a folder, after which the agent can perform file operations within that directory (reading, editing, creating files). The system is based on the OpenAI Agents SDK – a minimalist, open-source framework that isn’t tied to OpenAI models and works with various LLM providers by changing the base URL.

  Technical architecture: The application follows an agent loop: the user provides a task, the agent executes it and has access to three tools. (1) Run Shell: Executes validated Bash commands, with the code checking paths against an allowlist and blocking directory traversal. (2) Fetch URL: Scrapes website content using BeautifulSoup. (3) Search Web: Uses DuckDuckGo for web search.

  Security: The author warns that the guardrails shown are sufficient only for demos – production use would require a sandbox or Docker container. The implementation validates commands against a blocklist (e.g., no sudo) and checks paths against allowed directories.

  Code setup: Using the OpenAI Agents SDK, an agent is defined with detailed instructions, the model and base URL are configured (localhost:11434/v1 for Ollama or router.huggingface.co/v1 for Hugging Face), and the three tools are registered. The loop runs for a maximum of 30 turns and terminates when the user enters “quit”.

  Topics covered: OpenAI Agents SDK, Ollama, Hugging Face; Format: Tutorial (demo with code explanation).

Alex Finn (6 new videos)

• OpenClaw is the most powerful AI tool I’ve ever used in my life. Here’s how to set it up
  24.1.2026, 19:27:52

  Summary: OpenClaw/Claudebot Setup and Functionality

  The creator presents Claudebot (also known as “Clawbot” or “OpenClaw”) as a locally-running, 24/7-available AI agent system that can autonomously execute computer tasks. The open-source project was developed by Peter Steinberger and enables complete remote control of your computer — from browser automation to email management to programming.

  Core Features:

  • No guardrails; can act freely on the system
  • Infinite memory that stores information between sessions and proactively takes on relevant tasks
  • Interface exclusively through messaging apps (Telegram, iMessage, WhatsApp, Discord, etc.)
  • Access to any AI services as “brain” (Claude, ChatGPT, Minimax, etc.)
  • Integrates Vibes-Coding platforms (Claude Code, Codeex)
  • Marketplace with expandable skills

  Setup Hardware:

  Mac Mini (at minimum) or affordable VPS (e.g., AWS) are recommended — no expensive equipment needed unless you plan local models or intensive video editing. Installation happens via a one-line terminal command on claw.bot.

  Recommended Usage:

  1. Onboard like a real employer: introduce yourself, document your interests and work style
  2. Configure daily briefs, including task suggestions
  3. Provide Vibes-Coding access (GitHub repos, pull requests)
  4. Build a project-management board (Kanban)
  5. Set up a separate Gmail address for the agent
  6. “Second Brain” — digital note-taking and organization system

  Concrete Application Examples:

  The creator had Claudebot create YouTube scripts, newsletter drafts, thumbnail edits, and a complete Kanban board. The system proactively wrote a morning summary with weather, trending news, and completed work.

  Creator’s Warning:

  He points to significant economic and social risks: massive job displacement in paralegal, administrative, and junior-level roles. The system has only been public for about 3 weeks, 99.9% of the population doesn’t know about it, yet it could destabilize entire professions within a short time. He sees it as inevitable like the Industrial Revolution — resistance is futile, so use it rather than fight it.

  Model Selection by Quality:

  • Claude Opus 4.5: Highest intelligence + best “personality” (best overall impression) → $200/month (Max)
  • ChatGPT 5.2: Very intelligent, but robotic → ~$100/month
  • Minimax: Budget option with still-decent personality → ~$10/month
  • Claude API: Unlimited pricing based on usage

  The Claudebot tool (and underlying Claude Opus AI API) in demo format with detailed setup tutorial.

• Building apps LIVE with my 24/7 AI employee Clawdbot
  23.1.2026, 21:41:33

  Summary: Building apps LIVE with my 24/7 AI employee Clawbot

  The streamer presents Clawbot, a locally-runnable open-source agent framework installed on a Mac Mini ($500), which he refers to as his “24/7 AI employee.” The system can control anything a human can do on a computer — open browsers, write code, monitor GitHub repositories, manage files — and communicates with the user via Telegram messages.

  Main Features in Live Demo:

  • Clawbot automatically monitors GitHub repos, generates ideas for new features and creates pull requests
  • It can control the task-management app “Things 3,” read tasks and check them off
  • The streamer can text it and it completes tasks in the background; e.g., this morning it built a new feature for Creator Buddy (his main app) and created a PR
  • It was asked to research YouTube trends: it independently opened a browser, searched competitor channels and sent a report
  • During the stream, Clawbot built a Viber sidebar feature live in 10–15 minutes and created a PR
  • When asked to create an account on a website, it independently opened a browser, navigated to the site and attempted to sign up and create a new app profile (partially failed on email validation logic)

  Technical Details:

  • Runs on Claude Opus 4.5 (costs ~$200/month via Claude Max Subscription or ~$5,000/month via the API)
  • Can also be used with other models (Sonnet, Haiku, local models) — Minimax 2.1 costs about ~$10/month for full-time use according to the streamer, but sounds less “human” in conversation
  • Open-source; installation via a terminal command line (copy-paste), configuration through onboarding process
  • Can run on VPS ($15/month), Raspberry Pi or Mac Mini; the streamer prefers local-first to simplify file sharing with other Apple devices
  • Stores persistent memories across sessions

  Security Aspects & Risks:

  • No guardrails: The system can potentially be used harmfully (e.g., malware, account takeover, prompt injection vulnerability)
  • The streamer consciously limits access (e.g., no iMessage access so far, not linked to other devices on the network, no Twitter account set up)
  • Anthropic will probably not allow this use for much longer (“something tells me Anthropic is not going to let this fly for much longer”), which is why this unrestricted approach is positioned as an open-source alternative to Claude Code — fully “unhinged, no guardrails”

  Streamer’s Use Cases:

  • Newsletter generation: automatic scraping of tech news, comparison with previous articles, draft writing
  • Multi-project management: working on 10 projects simultaneously; can text Clawbot ideas and it builds pull requests
  • Future vision: An X/Twitter account for “Henry” (name of the AI assistant) that monitors user tags with app ideas, builds them and sends back GitHub links

  Personality & Interaction:

  • Claude Opus is the only model that sounds “human” — no formal punctuation, casual language (“Yo, dude, I just built…”)
  • The streamer gave the AI the personality “Henry” (an owl) and even asked it to enter the YouTube live chat during the stream (with options: browser automation or YouTube API)

  The Central Thesis:

  The streamer sees this as “AGI” or the practical realization of AGI — not because of individual features, but because it makes autonomous decisions, teaches itself “skills,” has persistent memory and can literally do anything on a computer that a human can, completely without restrictions.

  Explicit Tools/Models: Claude (Opus 4.5, Sonnet), Clawbot (open-source), GitHub, Things 3 (task manager), Telegram, Viber, 11 Labs API (text-to-speech), Claude Max Subscription; also mentions Minimax 2.1, DeepSeek, ChatGPT. Format: Live demo with extensive discussion of capabilities, risks and use cases.

• How I made $500,000 with Claude Code (and how you can too)
  22.1.2026, 21:20:56

  The video creator reports how he earned $500,000 with Claude Code in 2025: over $300,000 with a SaaS application called Creator Buddy and $100,000 from content (X posts, YouTube, newsletter, community).

  He presents a “Build in Public” framework with four phases that work like a flywheel: Build (apps that solve your own problems) → Create (content about them) → Earn (through the app and various content revenue streams) → Listen (user feedback) → back to Build (based on feedback).

  In the video, he demonstrates practically: after brief Claude Code installation, he shows how to write down your daily challenges (e.g., analyzing tweets, workout planning) and have Claude Code analyze them. Together they prototype a fitness app called Iron Forge that generates a working MVP with workout plans based on user input in just a few minutes.

  For the content phase, he primarily recommends X (short, regular posts), alternatively YouTube or newsletters. The “Jab Jab Hook” approach: multiple value-adding posts, then a sales post. This creates revenue streams through X ads ($50,000), X subscriptions ($50,000), YouTube ads ($5,000 monthly) and direct app sales.

  Iteration based on user feedback happens by simply copying DMs/replies and feeding them into Claude Code, which then automatically develops new features. The core message: no special talent needed, no large time budget (he started with a 9-to-5 job and 10 minutes daily), just repeat the cycles consistently.

  Format/Tools: Claude Code as the central tool, demo with tutorial elements; no other AI tools/providers mentioned — opinion/reflection with strong action framework.

• 🔴LIVE: Is Ralph Wiggum worth learning in Claude Code?
  21.1.2026, 21:21:16

  Summary: “Is Ralph Wiggum worth learning in Claude Code?”

  The streamer experiments live with the Ralph Wiggum technique, an autonomous loop workflow for Claude Code, to build an AI-powered project management tool (a Kanban board app with AI agent integration). Ralph Wiggum is at its core a “dumb bash loop” that repeatedly starts Claude with fresh context while persisting state through files on disk — not the plugin variant, but the original method by Jeffrey Huntley.

  The structure follows three phases with two prompts and a loop structure: Phase 1 defines requirements and breaks jobs into topics; Phase 2 implements tasks incrementally; an orchestration shell loads configuration files (PRD, specs, requirements, implementation plan) and starts Claude repeatedly until all tasks are complete. The streamer creates a complete “Ralph-ready” documentation package with Claude and initializes a Next.js repo with Supabase database integration, Shadcn UI and Vercel deployment.

  The streamer is skeptical whether Ralph will still be relevant in 6 months — Claude Code will become so powerful that such loops become redundant. Opus 5 comes in ~6 months by his estimate and marks the beginning of the exponential phase in AI progress. Claude Code gets consistently praised (vs. Codeex, GPT, Gemini) as more intuitive, pleasant and powerful; the streamer harshly criticizes that many on X either chase Elon retweets, are paid shills or simply gatekeep.

  Video Format: Live demo/tutorial with opinion (explicit experiment to test whether Ralph Wiggum is worthwhile); Tools: Claude Code, Claude (Opus), Ralph Wiggum (workflow technique).

• Claude Cowork is the best AI tool of 2026. Here’s how to use it.
  20.1.2026, 21:17:12

  The creator demonstrates a workflow system for Claude Cowork based on three steps: each morning type just “Let’s start our day,” then answer three questions (What makes today a win? What’s on your to-do list? What urgent points are there?), after which Claude Cowork independently decides which tasks it can take from the list and processes them in parallel.

  The system works through two central components: a claude.md file that serves as the “rule file” / “brain” of the system and defines how Claude Cowork should work, plus a folder structure (Claude folder with subfolders like Context, Inbox, Outbox, Skills) containing context information about the person, their projects, portfolio and skills. In the demo, Claude Cowork completes several tasks in about 3 minutes: it writes an X thread about an algorithm, researches AI energy stocks, drafts a newsletter and develops a YouTube strategy for 100,000 subscribers — all without explicit task instructions.

  The key advantage of the system is that the user doesn’t have to think about how to use Claude Cowork; instead, “Claude Cowork interviews” the user and identifies the best application itself. Setup works via a provided prompt that you paste into Claude Cowork; this automatically creates the necessary folder structure. The workflow is fully customizable through the claude.md file. An end-of-day routine is also included in the system (accessible with “End of day”).

  Claude Cowork (Anthropic), demo.

• LIVE shipping startups with Claude Code and getting work done with Claude Cowork
  20.1.2026, 09:13:33

  Summary: Shipping Startups LIVE with Claude Code and Getting Work Done with Claude Cowork

  In this live stream, the host works on multiple projects simultaneously: primarily on a Vibes-Coded app store where users can submit apps for review. In parallel, he showcases his new Claude Cowork workflow system, which he describes as a game-changer — in the morning he starts with “Let’s start our day. Check out Claude MD,” after which the system automatically asks questions (what makes today a win, what can I take off your plate, what video ideas do you have) and then independently completes tasks for him like stock portfolio checks, video scripting and competitor research.

  His core philosophy: use Claude Code with Opus 4.5 for 90% of the work, not for hyper-optimization with MCPs, plugins or Ralph Wiggum. The host rejects such optimizations and humorously compares his approach — Claude Code is like a motivated junior from college (proactive, helpful), Codeex like a grumpy senior developer (maybe smarter, but unfriendly). For more complex bugs he uses Codeex for verification, but primarily works with Claude Code in the terminal alongside CodeExec, uploading a screenshot for each fix.

  He also shares his career path: quit his job nearly three years ago, built a Twitter account (now 40K newsletter subscribers), Creator Buddy SaaS ($300K/year revenue), YouTube channel (70K subscribers, $60K/year ads), X income ($354K/year ads + $15K subscriptions). His vision: discover a “One-Person-Billionaire-Business” playbook with AI, consisting of content (live streams, YouTube, X), AI skills (Claude Code, Codeex) and product building.

  Practical details: he works on multiple Claude Code instances in parallel with separate work trees and branches. He uses /clear between features, regularly updates an architecture.md for context. Currently popular in the app store: a system that searches old tweets, identifies the best ones and rewrites them as article drafts in a rich-text editor.

  Skeptical of: Whisper Flow (repeatedly humorously called alleged malware), virality-on-autopilot tools (attention is zero-sum), AI video tools (sees no added value), mechanical keyboards (causes too many typos — sticks with Magic Keyboard), and generally any optimization that takes longer than the value it brings.

  Live Q&A format with chat engagement: many questions about Gas Town, MCPs, Co-work features; the host repeatedly emphasizes: “Just tell Claude Code what to do. Done. Next task.” Predicts that Claude Cowork will become bigger than Claude Code.

  Claude Code, Claude Cowork, Codeex and Opus 4.5 were central topics; the video is a live Q&A with practical coding sessions.

Andrej Karpathy

No new videos in this period.

Bart Slodyczka (1 new video)

• Build 10X Faster With This Simple Claude Code Workflow
  21.1.2026, 11:32:37

  Summary: Build 10X Faster With This Simple Claude Code Workflow

  The video demonstrates a structured process for building apps faster with Claude Code by using pre-built templates instead of feature prompting from scratch.

  The Problem with Feature Prompting: When you simply tell Claude “build me an app,” the AI has to make all the foundational decisions (framework, authentication, folder structure, API logic). These “app pipelines” are the same for every project and get unnecessarily reinvented each time.

  The Solution – Template-Based Workflow:

  1. Upload a pre-built template to Cursor that contains all standard infrastructure
  2. Then provide Claude Code only with the specific feature requirement
  3. Claude adds the feature to the existing structure instead of building everything from scratch

  Practical Setup:

  • Node.js 20+ and Supabase account required
  • Clone template via Git command, install dependencies (npm install)
  • Configure env file with Supabase URL and API key
  • Create test user in Supabase for login
  • Start with npm run dev

  Use Case – Invoice Processing Tool:

  The creator demonstrates building an application with an upload component and table. He provides Claude with specific requirements (which UI components from shad CN, how data should be processed, Claude API for invoice parsing) and copies relevant code blocks directly from the component library. Claude creates a plan, installs necessary packages, creates the Supabase table and storage bucket via SQL. Uploading a test invoice works immediately – data is extracted, stored in Supabase, the file remains downloadable.

  Core Benefit: Claude doesn’t have to solve authentication, session management, or folder structure anymore, but focuses only on the new functionality – fewer errors, faster, better control.

  The creator recommends generally searching for open-source templates (SaaS boilerplates with payments/multi-tenancy, browser extensions, web dev, etc.) instead of always starting from zero.

  Tools: Claude Code, Cursor, Supabase, shad CN UI components; Format: Tutorial with live demo; Beginner-friendly.

Ben AI

No new videos in this period.

Brian Casel (2 new videos)

• Agent OS v3: Leaner & Smarter for Building in 2026
  22.1.2026, 13:01:27

  Agent OS v3: Leaner & Smarter for Building in 2026

  Agent OS v3 is a refined version of a system for managing coding standards specifically designed for AI-driven development. The core problem: agents can read code, but don’t understand the conventions, patterns, and architectural decisions behind it—meaning you constantly need to re-explain context.

  The new version is reduced by 70% and focuses on three main features:

  Standards Discovery: Agent OS can automatically analyze your codebase, identify unusual or opinionated patterns, and interview you through questions to capture the reasoning behind them. These standards are then formalized and made accessible to agents.

  Enhanced Spec Shaping: Combined with Cloud Code’s Plan Mode, targeted questions help refine specifications while considering standards and product mission. Plans are automatically saved in persistent spec folders.

  Profiles: You can manage different standard sets for various project types (e.g., Laravel, marketing site, internal tools) and switch between them.

  In practical use: standards are indexed (just one-liner descriptions to save context), and you can inject them anytime—in regular prompts, when planning specs, or when creating Claude Skills. The system automatically recognizes which standards are relevant. Agent OS also stores the entire planning conversation and outcome in structured spec folders.

  The tool targets teams with legacy codebases using spec-driven development, or developers wanting to reduce framework complexity. Agent OS is free and open-source.

  Demo: Cloud Code, Claude, Agent OS (free); Format: Demo/Tutorial.

• Arvid Kahl’s SaaS is 98% Coded by Claude
  19.1.2026, 13:15:02

  Summary: Arvid Kahl’s SaaS is 98% coded by Claude

  Arvid Kahl, founder of podcast monitoring platform Podscan, lets Claude write about 98–99% of the code and only minimally intervenes manually. The key to this workflow lies in three elements:

  1. System Prompt (Claude.md): Arvid uses an extensive, structured system instruction based on the Oxster prompt framework. It teaches Claude how to think as a coding agent—it breaks down requirements into planning, implementation, and verification phases, then delivers a summary. The prompt works like “normalized CSS for agentic AI” and helps Claude structure raw requirements into reliable work steps.

  2. Platform Docs from Video Walkthroughs: Instead of writing traditional documentation, Arvid records a video walking through the entire app like onboarding a new developer. He feeds Claude the transcripts and asks it to create structured markdown documentation. These docs later help Claude understand the app’s coherence when planning new features.

  3. Avoiding Comprehension Debt: The core concept: Claude builds a temporary mental model of the codebase while coding, then discards it completely. Arvid stays involved in code reviews to keep his own mental model in sync with the actual code. This prevents his understanding from drifting. As additional safeguard, he instructs Claude to write tests (Podscan now has 3,500 tests with over 12,000 assertions).

  Arvid treats Claude like a developer: he lets it finish the work uninterrupted (Claude builds the full theory in 20 seconds, a human would need hours), and only steps in to review—not to micro-edit. He even delegates small UI tweaks to Claude, since it understands where that color appears elsewhere, something Arvid might miss.

  Demo with Claude and Builder Methods Podcast; thoughts/reflection on AI-first development.

Coding with Lewis

No new videos in this period.

Cole Medin (3 new videos)

• I Was Wrong About Ralph Wiggum
  22.1.2026, 01:00:27

  Summary: I Was Wrong About Ralph Wiggum

  The creator revises his earlier negative assessment of Ralph Wiggum. He realized he originally only knew the official Anthropic version, which doesn’t fully capture the actual concept. The true Ralph Wiggum, as conceived by creator Jeffrey Huntley, incorporates extensive planning and is more of a philosophy than a finished framework.

  The real value of Ralph Wiggum lies not in completely free “vibe coding,” but in validating ideas through proof-of-concepts. With clear planning upfront, multiple complete application versions can be built to test architecture and tech stack before developing the production-ready version.

  The system works like this: A PRD (Product Requirements Document) is manually created with Claude (planning phase, approximately 5–10 minutes), serving as the central source of truth. A Bash loop (Ralph loop) then repeatedly calls Claude, with each iteration reading the current status from an activity log file and attempting to implement the next feature. The loop only ends when all PRD tasks are marked as passes: true. Importantly: defined, sandboxed limits in settings.json prevent the agent from acting uncontrollably.

  In the live demo, the creator builds an agent-driven habit tracker app (Clerk Auth, Neon DB, Open Router for LLM agent, Next.js, Tailwind, Drizzle ORM). The agent self-validates using Vercel Browser CLI and can log into test accounts. After approximately 5 hours, the complete app is running: dashboard with habits, goals, AI coach with insights and conversations. The result is a real, functioning proof-of-concept—not perfect in UI, but sufficient to validate the idea. Costs were minimal (7 cents for agent interactions with Claude Haiku).

  The critical point: with structured planning, Ralph Wiggum is valuable for rapid concept validation—you stay in the “driver’s seat” through the PRD phase while the agent handles repetitive implementation.

  Demo of a specific workflow (Ralph Wiggum loop with Claude, Vercel Browser CLI for validation); designed for developers at standard level.

• Your AI Coding Workflow NEEDS This New Agent Browser CLI
  19.1.2026, 01:00:10

  Summary: Your AI Coding Workflow NEEDS This New Agent Browser CLI

  The creator recommends Vercel’s Agent Browser CLI as a more reliable tool for browser automation in AI coding workflows. The central challenge: coding agents need the ability to validate their own implementation by visiting and navigating a website like a real user—otherwise manual validation falls back on the developer.

  Why Vercel Agent Browser is better than alternatives (Playwright MCP, Chrome DevTools MCP):

  Vercel’s approach follows the philosophy “less is more.” Instead of complex search and matching mechanisms with accessibility trees, the website is sent to the LLM as a condensed structure with references to clickable elements. This allows the agent to address elements directly by reference ID—very token-efficient and reliable. The creator documents concrete reliability metrics: 95% first-try success rate for individual operations (screenshots, clicks, form inputs) with Agent Browser CLI, compared to 80-75% with Playwright MCP and Chrome DevTools MCP.

  This philosophy is supported by Vercel’s D0ero research (text-to-SQL agent): reducing from 17 specialized database tools (80% success rate) to just two tools (SQL write access + schema) → 100% success rate. Fewer context switches, faster, fewer tokens.

  Quick start:

  Install via CLI commands, then optionally copy the skill file (skill.md from the GitHub repo) into the /skills directory of Cloud Code—afterwards Claude immediately knows all CLI commands. In the demo, the agent is instructed to start a word cloud app, visit it, navigate, fill in fields, and take screenshots to validate functionality.

  Testing comparison:

  On simple websites, performance is similar, but on more complex sites (e.g., Amazon: search for product, scroll, click), Vercel’s superiority becomes clear—the agent makes few mistakes, while Playwright frequently generates retries or “silent failures” (agent realizes something didn’t work, tries alternative approach).

  The tool is free, open source, and recommended with no affiliate connection.

  Bonus sponsor Leapter: workflow automation for agents with deterministic business logic (integrable as MCP/N8N) to avoid hallucination, while the agent only makes parameter decisions.

  Vercel Agent Browser CLI & Playwright MCP/alternative tools were discussed; demo format with emphasis on validation workflows for coding agents.

• LIVE AI Coding Challenge – YOU Choose What I Build (Using Kiro!)
  18.1.2026, 06:26:02

  In this live coding challenge stream, the audience votes on what the host builds with the AI coding tool Kiro. After a voting phase (despite some spam at the end), the winning idea is an Obsidian Voice Agent—an application that enables communication with an Obsidian knowledge database via text or voice.

  The host demonstrates his AI coding workflow using the Kiro hackathon template, which is based on the PPIAV loop (Plan, Implement, Validate). The strategy: build smaller features iteratively rather than everything at once. The setup starts with a read-only tools layer (search, indexing with Whoosh), followed by a Pantic AI text agent, then a React frontend, and finally LiveKit voice integration.

  For testing and validation, the Vercel Agent Browser is used—a token-efficient browser automation tool directly integrated into Kiro skills. The host uses Aqua Voice (speech-to-text) for faster communication with the coding agent and explains that the agent itself can only test via the text version, not via voice.

  The Kiro hackathon deadline is extended by one week to January 30th (originally due to missing credit distribution). Prize pool: $17,000.

  Explicitly mentioned tools: Kiro (coding IDE), Claude Opus 4.5, LiveKit (voice agent framework), Pantic AI (agent framework), Whoosh (search), Vercel Agent Browser, React/Vite, Aqua Voice, OBS (streaming setup). Format: live Q&A with integrated demo elements, emphasis on workflow demonstration for beginner to intermediate level.

Datapizza (1 new video)

• Il REPORT di ANTHROPIC sull’AI, tra IMPATTO e ADOZIONE
  23.1.2026, 14:01:29

  Summary: Anthropic Report on AI Adoption and Impact

  Anthropic has published a new report on the economic impact of AI, based on usage data from November 2025. The report introduces the concept of “Economic Primitives” – five critical dimensions for measuring human-AI interaction: task complexity, capabilities, use cases, AI autonomy, and AI success rate.

  Key findings on usage behavior: About 52% of chats on the Cloud.ai platform are focused on augmentation (enhancing human capabilities) rather than full automation. The report observes an almost perfect correlation between prompt quality and answer quality – higher human competence in interaction leads to better outputs. This shows that model capacity alone is not decisive, but rather the quality of human-machine collaboration.

  On adoption: AI proliferation is converging across U.S. states at over 10 times faster speed than 20th-century technologies (which took 30–50 years). While states with high concentrations of computer science and mathematics professionals (Virginia, Washington DC) are leading, low-adoption states are catching up quickly; parity is expected in 2–5 years. Internationally, adoption remains strongly tied to GDP per capita: wealthier countries tend to use cloud for augmentation, poorer countries primarily for educational purposes.

  The concept of “Effective AI Coverage” weighs not just theoretical automatability, but also the actual share of a task in daily work hours and success rate. Professions like data entry clerks, medical transcribers, and radiologists have high AI exposure, as AI handles repetitive core tasks well here. Microbiological roles show lower effective exposure, as hands-on lab work remains a non-automatable bottleneck.

  On employment impact: AI takes on tasks requiring higher education – this can lead to deskilling (e.g., technical writers, travel agents losing planning tasks) or upskilling (e.g., property management: routine bookkeeping is automated, people focus on negotiation and customer management).

  Realistic productivity gains: While theoretically 1.8% annual productivity increase over a decade would be possible, realistically it drops to ~1.0–1.2% when accounting for reliability rates (AI errors require checks). The concept of “complementarity” shows: if tasks are essential and cannot be automated by AI, overall productivity is limited by these bottlenecks.

  Additionally: Google has released MedGemma 1.54B for healthcare applications – a compact model for offline use with advances in medical image analysis, document understanding, and clinical workflows. In parallel, MED ASR, a specialized speech recognition model for medical contexts, was launched, enabling doctors to use voice commands for complex diagnoses. Google is also hosting a hackathon (100,000 USD prize pool) on Kaggle to foster innovative applications. All models are subject to strict validation and data privacy guidelines.

  The Wikimedia Foundation (parent company of Wikipedia) has partnered with Amazon, Meta, Microsoft, Mistral AI, and Perplexity to provide AI training models with high-quality, human-curated data. This addresses sustainability, data quality, and legal concerns regarding passive web scraping of user data.

  Explicitly covered: Anthropic (report focus), Google (MedGemma), Wikimedia partnerships with Amazon, Meta, Microsoft, Mistral AI, and Perplexity — Roundup/News Update with an in-depth dive into the Anthropic report.

Dave Ebbelaar (1 new video)

• How to Build Human-in-the-Loop for AI Agents (Practical Guide)
  19.1.2026, 14:00:19

  The video covers how to implement Human-in-the-Loop (approval steps by humans) in LLM-based agents in practice. The core idea: for critical operations—such as money transfers above a certain amount—the agent should pause and wait for human approval before proceeding.

  Two backend approaches are demonstrated:

  1. LLM as Router: A structured Pydantic model defines possible actions (check balance, transfer money, deposit). The LLM decides which actions are needed; a model validator enforces approvals for transfers over 100 (example). In the code, filtering occurs: if requires_confirmation is true, approval is requested; otherwise executed directly.
  1. Tool Calling: The LLM receives tools and decides which ones to use. A while-loop checks for tool calls; for critical tools, approval is requested before execution.

  Two production patterns show how this works in real systems:

  1. SSE Streaming (for chat/real-time apps): User → Frontend → API → Agent. When approval is needed, the agent saves its state (message history, pending actions) to a database, signals back via API to the frontend that approval is required. The user sees a button and clicks Approve/Deny. This triggers a new API call, state is loaded from the database, the agent resumes and executes.
  1. Async Process (backend workflows, event-driven): A worker or webhook starts the process. The agent pauses, saves state, and instead of a direct response sends an email or Slack notification to the user with Approve/Deny buttons. The user responds, another API endpoint loads the state and resumes.

  Key concepts: (1) Deferred Execution—save state instead of executing immediately, (2) State Serialization—make agent context, message history, pending actions persistent, (3) Stateless Resume—load everything from storage, keep nothing in memory, so timeouts and long wait times aren’t a problem.

  The video shows live demos in Python with OpenAI Client and structured output; code is available on GitHub. The difference between simple backend halt (Python input()) and real production is central: in a production setup, all components—frontend, API, agent, database—must work together.

  Tutorial with practical code examples; covers OpenAI API with structured output and tool calling.

David Shapiro (5 new videos)

• Dario Amodei (Anthropic) Drops ATOMIC BOMBSHELL at Davos!
  23.1.2026, 13:41:52

  The video creator reacts to a statement from Dario Amodei (Anthropic) from Davos, suggesting we could be 6 to 12 months away from fully automated recursive self-improvement (RSI). Amodei reports that AI already writes ~100% of code for some Claude researchers. The creator also mentions that Elon Musk has aimed to make xAI smarter than humans by the end of 2026, and that DeepMind is searching for a Chief AGI Economist.

  The core argument is based on the “Jagged Frontier” concept (from Ethan Malik): while individual AI capabilities already exceed human performance (microscopes, telescopes, calculators), the overall blob of machine capabilities continues to grow continuously. The creator argues that materialism is sufficient to explain human intelligence, and thus physics allows human functions to be replicated in silicon.

  A key milestone: small models like Llama 6B are already more energy-efficient than humans at certain tasks. This is significant because it refutes the historical assumption of human-superior efficiency. The creator calls this a turning point – on a per-capita basis, it economically makes sense to invest energy in AI systems rather than human labor.

  For RSI to be necessary, according to the creator: mathematical ability, automated hypothesis testing, code generation, and data generation. These ingredients already exist; it’s about operationalization. This is exploding right now through tools like Claude Code, GPT-5 Pro – a large emerging space of possibilities that the community is still exploring.

  The creator emphasizes: every 6 months we experience a new regime shift (reasoning models → better agents → better code agents). Dario was off by only ~3 months a year ago with his 75-90% coding prediction – therefore one should take seriously his 6-12 month statement on RSI.

  On security concerns: the creator argues that even autonomous pipelines still have human gating points (training runs cost real money, then security checks, external evaluators like Epoch AI), and that a “Skynet scenario” would require unattended iteration – which structure and policy can prevent. He identifies as an Accelerationist, not an Effective Altruist, and suggests that human involvement might have “negative expected value” in the medium term.

  Finally, the creator announces a break to focus on projects: a book/Kickstarter on “Post-Labor Economics,” a documentary, and his next research project “Generative Mutualism” (game theory, Nash equilibrium, path to world peace).

  Explicitly covered: Anthropic (Claude, Claude Code), OpenAI (GPT-5), DeepMind, Elon Musk/xAI; format: opinion/reflection with breaking news element.

• Maybe I was WRONG!? How could AI and Robots Destroy Capitalism?
  22.1.2026, 13:33:09

  Summary: “Maybe I was WRONG!? How could AI and Robots Destroy Capitalism?”

  The creator steelmans the position that AI and robotics could actually destroy capitalism – a thesis he personally doesn’t hold (he believes more in “hyper-capitalism”). For capitalism to end, his analysis requires four conditions: marginal costs near zero, structural redundancy of wage labor, instability of private property, and the collapse of market coordination.

  The central problem is the broken production-wage-consumption-profit loop: without wages, there’s no consumption demand. The creator then sketches two “litmus tests” for whether capitalism collapses: (1) AI CEOs are better than humans, and (2) decentralized, collectively funded hyperscaler data centers emerge. However, he identifies several resistance factors: physical bottlenecks (GPU latencies prevent decentralized training of frontier models), the liability question (humans as scapegoats), and the fact that energy, chips, and building permits remain scarce goods.

  Geopolitically, full automation means states no longer optimize for labor capacity, but automation capacity – a posthuman, potentially frightening scenario. The way out: not automation without redistribution (which leads to elite secession), but automation plus distribution. The model: Sovereign Wealth Funds, which extract strategic rents on energy and compute and pay citizen dividends – thereby maintaining consumption demand without requiring wage labor. This replaces the old loop with a new one: Sovereign Equity → Dividends → Mass Consumption → Mass Automation.

  The video analyzes the conditions for capitalism’s end in depth; the creator acknowledges both scenarios are possible, but favors the distribution solution over Elysium-like scenarios.

  No specific AI tools/models covered (only mentioned: ChatGPT, GPT5, Opus 4.5 as reference points); format: opinion/reflection with policy discussion, deep-dive elements.

• Data Centers (Don’t) DESTROY The Environment!?
  21.1.2026, 11:55:44

  Summary: Data Centers (Don’t) DESTROY The Environment!?

  David Shapiro examines the debate around data centers and their environmental impact, concluding that fierce local opposition has less to do with actual environmental problems than with power imbalance and lack of control.

  The three main concerns:

  Water: Data centers consume far less than agriculture or golf courses. Modern closed-loop cooling systems in temperate climates reduce consumption toward zero. Locally, however, they can be the largest single consumers in a city (e.g., Google’s data centers in The Dalles, Oregon: 29% of city water).

  Energy: Hyperscalers are the largest buyers of green energy and drive new wind and solar installations. However, data centers increase the grid’s baseload and delay the retirement of fossil fuel plants. Some use local gas turbine generators instead of renewable energy.

  Environment: AI models enable dematerialization and optimization (e.g., logistics) that could save hundreds of times more emissions than model development costs. However, emissions arise from concrete, steel, GPU e-waste (hardware becomes unusable after 7-8 years, not 3-4 as claimed), and land sealing.

  The real problem: inequality rather than environment

  Opposition structurally resembles NIMBYism (Not In My Back Yard), but is substantively a struggle for local control and welfare distribution. The parallel to railroad construction in the 1880s is apt: local impacts weren’t the problem, but extreme wealth concentration among magnates. Similarly today: data centers signal that billionaires (Musk, Altman, Bezos) extract value locally without the community benefiting.

  Economic reality – the “empty factory”:

  A billion-dollar data center creates only 40-100 permanent jobs (security, HVAC, maintenance), while a Walmart superstore provides 300 jobs. 500-1,500 construction jobs are temporary (18 months). The state of Virginia lost $1.6 billion in tax breaks, while the local county received 50% of its budget from data center taxes – a classic redistribution problem between county and state.

  Problematic tactics:

  Critical infrastructure designations bypass zoning laws, shell companies obscure ownership, NDAs prevent transparency, outdated codes are exploited. This secrecy undermines trust and the legitimacy of democratic processes.

  Activist demands (124 groups):

  1. End 20-50 year tax exemptions; land value tax (Georgism) – municipalities must capture gains
  2. Grid independence: data centers must bring their own energy, no subsidies from other ratepayers
  3. Citizen dividends: direct gains for industrialized areas

  Shapiro’s conclusion: Environmental impact is relatively small and probably net positive. The real problem is the parasitic structure: companies extract value quickly, while communities get surface tax benefits but are strategically undermined, with the rest of the state subsidizing. Without a “deal based on shared welfare,” backlash will grow – tycoons shoot themselves in the foot through shadowy tactics.

  Transcript only available; opinion/reflection with data analysis.

• AI is getting REALLY good at math. But how good, exactly?
  20.1.2026, 16:16:58

  The creator systematically examines how good AI has actually become at mathematics – beyond the hype. The core argument: math is upstream of everything we value (medicine, engineering, energy), so its automation is fundamentally important.

  Current performance vs. limits: OpenAI and DeepMind each solved two of six IMO problems in 2025, and an Erdős problem was validated by Terence Tao – that’s superhuman on average, but Millennium Prize Problems remain unsolved. The best characterization: “talented undergraduate, not professor.”

  The crucial paradigm shift: Not just scaling (more data, parameters, compute), but inference-time compute and Monte-Carlo tree search. Because math is provable and decidable, there’s essentially unlimited high-quality synthetic training data – a model can generate 100 million geometric proofs for itself. This is self-play like AlphaGo, applied to mathematics.

  The “Aristotle-Workflow” model (Tao’s approach): a neural network provides intuitive conjectures, then formally verified by a symbolic solver (like Lean, Coq) – feedback loops between creative “hallucination” and rigorous proof.

  Benchmark explosion: Frontier Math Benchmark rose from under 2% (2024) to about 40% (early 2026) – in a few years from nearly zero to halfway solved. At exponential timelines, the benchmark should saturate by end of 2026/mid-2027.

  Practical implications: Commoditized advanced math + better coding leads to formal verification instead of testing – rather than “ship it and fix bugs later,” the standard becomes: crashproof code. Example: verifying the seL4 microkernel took 20 person-years for 8,700 lines of code; this will become routine. In science: shift from “hypothesis test and falsify” to “simulate, prove, then verify in reality” – digital twins for cells, proteins, drugs.

  New bottlenecks: Compute costs remain (GPUs are expensive), specification (you must ask the right question – requires expertise), and physical reality as final validation layer.

  User perspective: Technology becomes more robust (no more crashes, like faulty car touchscreens today), “invisible” (works like magic), and democratized (everyone with a smartphone has a personal Terence Tao). Verification is 100× cheaper than the original work – architects use AI despite 20% longer output time because the start is faster (cognitive relief).

  Overall vision: The “age of verification” rather than approximation – everything becomes mathematical, coded, and provably simulable, automated in the background.

  Note: No specific tool mentioned; references to OpenAI, Google DeepMind, Lean/Coq proof assistants, and ChatGPT Pro as examples. Format: opinion/reflection with deep dive into mathematical AI progress; difficulty: conceptually demanding but accessibly structured.

• I think the Singularity could be BORING
  19.1.2026, 15:11:14

  The speaker argues that the singularity will likely unfold in a “boring” way rather than dramatically – a thought also hinted at by Sam Altman in a blog post on the “gentle singularity.” He cites current developments in autonomous AI programming (Claude Code, Codex) as a catalyst, which can write entire apps without human input. While impressive, this doesn’t visibly change the world for most people – it’s essentially just “more software for nerds.”

  The speaker argues that all computer history in retrospect was just building up to AI; in 20 years, 99% of all processor cycles will be used for AI. Programming becomes increasingly abstract until ultimately natural language is the programming language. Concrete applications emerge, like personalized medicine through home sequencing or AI-run greenhouses, but they accumulate so gradually that they never feel dramatic.

  The biggest promise lies on the energy front: in the future, 50% or more of global electricity could go to AI workloads. This ultimately leads to expansion into space – Dyson spheres and satellites as invisible data centers – but you don’t see that. Visible symptoms (better robots, holograms, longer life) accumulate so slowly that the brain normalizes each new thing as the “new normal” and immediately makes it boring again.

  The speaker suspects physics itself may stop surprising us – we’ve discovered most particles, discovery rates are slowing. Progress may follow an S-curve rather than continuing exponentially. Breakthroughs like mind uploading or faster-than-light travel he considers unlikely or physically impossible. The result: not a dramatic singularity, but an accumulation of gradual, increasingly normal changes – a boring singularity we’re already in.

  Opinion/reflection; no specific AI tools or providers (except general Claude mentions) are substantively analyzed.

DevExpert – AI for Developers (1 new video)

• I Stopped Using OpenClaw: How I Built My Own AI Assistant on Telegram
  22.1.2026, 16:00:49

  Summary: Custom Telegram AI Assistant with Codex Headless Mode

  The creator demonstrates how to build a personal AI assistant in Telegram and make it work: the bot manages tasks, reads emails and Slack messages, retrieves social media posts, and can execute actions. The key is the headless mode of AI agents, a feature available in virtually all common models that allows you to control the AI instance externally via command line without opening the graphical user interface.

  The technical implementation connects two systems: Telegram (as the interface) and Codex in headless mode (processing). This works through the command codex exec, which receives a prompt as an argument. For continuous conversations, you save the Session ID that is returned with each request, and use codex exec resume to resume the session. The creator creates a minimal viable product with Node.js and the Grammy SDK that keeps the session state in RAM. Important: the skip-git-check flag must be enabled so Codex runs outside a Git repository.

  In the practical demo, bot creation happens via Telegram BotFather, the token is inserted into a .env file, then pnpm install and pnpm start – after that the bot is live. The decisive advantage: all MCPs and skills already configured in your Codex instance work here right away. The creator even adds Whisper integration for audio transcription and shows how the bot uses a custom-written CLI to access the creator’s X/Twitter accounts to automate tasks like publishing. At the end, the creator points to his GitHub repository (AIPAL) with production-ready bot code – currently for Codex only, with plans to support Gemini Cly and Claude Code in the future.

  The video specifically covers Codex in headless mode; Cloud Code and Gemini Cly are also mentioned as alternatives — Demo/Tutorial.

Everlast AI (4 new videos)

• Learn EVERYTHING about AI Automations in 2026 (MEGA COURSE AI Automation)
  23.1.2026, 07:47:39

  Summary: EVERYTHING about AI Automations in 2026 (MEGA COURSE AI Automation)

  The course teaches the skill of AI Automation — automated systems that use artificial intelligence to complete tasks that would normally require a human. The instructor positions this as the “last future-proof skill,” as a McKinsey study shows that by 2030, 57% of all work hours will be automatable, while two-thirds of all companies are desperately searching for employees with AI-fluency skills.

  Four course chapters:

  1. Foundation: What is AI Automation? Types, tools, how it works.
  2. Core concepts: The strategic 80% (before technical implementation), e.g., identifying bottlenecks, process thinking, ROI calculation.
  3. Implementation: Four practical use cases (Voice Agent, email campaigns, lead qualification, proposal automation).
  4. Monetization: Revenue models for employees, entrepreneurs, and AI agencies.

  Difference from old automation: Previously, tools only moved data (if-then principle); AI automations can think, decide independently, and be creative.

  Four categories of AI Automations:

  • Voice Agents (making calls, qualifying leads)
  • AI Chatbots (written communication, 24/7)
  • Workflow Automations (multi-step processes, connecting tools)
  • Corporate LMS (GDPR-compliant, company-owned AI workspaces)

  Seven tool categories everything is built on:

  • Integration platforms (Zapier, Make, n8n)
  • Orchestration layer (Vapi, 11 Labs, LiveKit)
  • Databases (Google Sheets, Airtable, Supabase)
  • AI models (GPT, Claude, Gemini, Open Source)
  • Corporate workspaces (Google Workspace, Microsoft 365)
  • Forms/data entry (Google Forms, JotForm)
  • Specialized tools (HubSpot, Trello, etc.)

  Input-Process-Output principle: Every automation follows: Trigger → Logic (decisions) → Data Transformation (formatting data) → Actions (concrete steps) → Output (result).

  Understanding APIs & Webhooks: HTTP Requests (active requests), Webhooks (passive notifications from external systems). Postman tests an API, n8n executes an OpenAI API call in practice.

  Seven strategic core principles of top players:

  1. Learn 80% of the basics in 1–2 hours (Pareto), not 100% in 100 hours.
  2. AI Automation isn’t an end in itself — must save at least 10 hours/month or directly generate revenue.
  3. Focus on bottlenecks (Liebig’s Law of Minimum), not the second-biggest bottleneck.
  4. Plan backwards (output first), not forwards.
  5. The duller, the better — 70% of most successful projects are simple workflow automations (data A→B, reports), not fancy systems.
  6. Remain tool-agnostic — no one-size-fits-all; depending on the client, use n8n, Make, or Zapier.
  7. For AI agencies: Automation alone is a commodity; value comes from process analysis, ROI forecasting, client management (80% business, 20% tech).

  Practical use cases (excerpt):

  • AI Voice Agent Receptionist: AI answers calls, qualifies leads, and transfers them (e.g., property management with Subagents for repairs, billing, emergency). Built with 11 Labs (orchestration platform), German-language, selectable voices, Workflows with Subagents, prompt engineering.

  The course emphasizes: Start building quickly (don’t watch tutorials endlessly), because most technical tricks are learned while building. Infrastructure thinking (combining the four categories into complete AI infrastructures) matters more than mastering individual tool features.

  Explicitly mentioned AI tools/providers: OpenAI, Anthropic (Claude), Google (Gemini), 11 Labs, Zapier, Make, n8n, Vapi, Airtable, Supabase, Google Workspace, Microsoft 365, Postman, HubSpot, Trello; Open Source models (Qwen, DeepSeek, Mistral) — Deep-Dive / Tutorial Hybrid, beginner-friendly.

• Meta Insider Reveals: THIS Comes AFTER the Smartphone! World Models, AGI & the Future (Leon Szeli)
  21.1.2026, 16:15:00

  The conversation covers Leon Szeli’s career as a Product Manager at Meta and former founder of Presize AI, plus his assessments of AI and shopping’s future.

  Presize AI and the path to Meta: Szeli founded Presize AI in 2019, which used computer vision and proprietary AI models to calculate exact clothing sizes for online shoppers. The company was later acquired by Meta. Meta’s initial email (when still Facebook) landed in his spam folder; he only later realized it was an acquisition offer, not a software integration. While building the product, he used practical tricks like “Measurement Parties” (recruiting volunteers to collect body data), strategic datasets from research associations, and feedback loops through integration with major customers like H&M.

  Agentic Shopping & E-Commerce Future: Szeli describes a fundamental shift: AI agents will shop for customers in the future — initially following customer instructions, later independently based on learned preferences. The classic affiliate model doesn’t work here because agents would have commission incentives and users would switch to other services. Instead, he sees personalized, non-advertising product recommendations and dynamically generated ad creatives as the future.

  3D models as key: Precise 3D capture of the human body has cross-cutting value — not just for fashion, but for fitness apps, robotics, animation, and VR/AR. It enables more realistic representations and solves the “uncanny valley” problem.

  Infrastructure investments: Szeli sees two scenarios justifying these massive investments: either Super Intelligence or a product with billions of users that disrupts online shopping. Productivity gains through AI for routine tasks is a third.

  Meta’s strengths & weaknesses: Meta has strategic advantages through Mark Zuckerberg’s control (enabling bold long-term investments), the world’s largest user base (data), but also a disadvantage: no proprietary cloud infrastructure like AWS or Google Cloud, so must buy more expensively.

  AI Hardware – Smartglasses: Szeli bets on smartglasses as the form factor because ~20% of people need vision correction and ~40% wear sunglasses — that wearing habit already exists. Google Glass failed for timing reasons; now it’s ready. Privacy concerns will normalize like they did with smartphones.

  Germany’s AI opportunities: Disadvantages include lack of venture capital for later stages, missing proprietary cloud and chip infrastructure, regulation, and bureaucracy. Advantages: strong academic foundations in computer science (better in theory than US universities), 100+ top universities in Europe, 10+ in Germany, plus industrial data richness from the Mittelstand, mechanical engineering, and specialized industries (e.g., gas leak detection in pipelines). Szeli is “on balance optimistic” but warns: “it won’t be easy.”

  Meta AI, deep-dive into AI strategy, shopping transformation, and AI hardware with focus on world models and future scenarios — no explicit transcript available, summary from interview audio.

• This OpenAI Device Will Replace Your Phone
  20.1.2026, 16:15:00

  Summary: This OpenAI Device Will Replace Your Phone

  The video analyzes which AI device could replace the smartphone in the future. Following failed attempts like the Rabbit R1 and Humane AI Pin, the question is which form factor will succeed — especially as OpenAI invests $6.5 billion in a mysterious device from Johnny Ive and Meta is already finding success with Ray-Ban SmartGlass.

  Failed devices: The Humane AI Pin ($699 + subscription) overheated and was sold for a fraction of the investment after ten months; Rabbit R1 turned out to be an Android app in a plastic box with extremely limited functionality; Apple’s Vision Pro ($3,499) was too heavy and expensive for broader adoption.

  Current concepts in the market: Pins and pendants (OpenAI’s mysterious device possibly larger than an iPod Shuffle, voice-controlled, screenless); AI pens (like the ChatGBT pen from Scanx); SmartGlasses (Ray-Ban models from Meta with 2 million units sold in 2024, 70% market share; Google plans Android XR models for 2026; Apple announces smartglasses for 2027); AI rings and armbands; headphones with AI integration.

  Success criteria per Rogers’ innovation theory: relative advantage, compatibility with existing habits, ease of use, trialability, and observability. The author adds four more conditions: the device shouldn’t replace laptop/phone but be a third device; must work voice-first; preserve privacy; and act as an intelligent personal assistant (cognitive offloading).

  Most likely scenario: SmartGlasses, because they meet all criteria and the Red Queen hypothesis — once adopted by a critical mass, creates pressure for others to adopt — explains their rollout. However, concerns exist: bystander rejection (70–80% of surroundings reject recording), legal uncertainties around privacy.

  Other likely scenarios: The incremental evolution of the smartphone itself, where apps are replaced by AI agents behind the screen (Musk’s thesis); or a “family of devices” approach where different form factors coexist for different use cases.

  The author emphasizes: There’s still no definitive answer to which device will prevail — otherwise it would already exist.

  Deep-dive on future AI hardware form factors focusing on OpenAI and Meta plus explicit analysis using Rogers’ innovation theory and diffusion dynamics.

• Claude “Cowork” is Insane! New ChatGPT “Translator”, Apple Integrates Gemini & More AI News
  18.1.2026, 09:22:26

  Claude Cowork, ChatGPT Translator and AI Drama – Weekly Roundup

  Claude Cowork is presented as a new flagship feature that automates office work: it accesses your desktop, analyzes thousands of files and folders, creates Excel lists and presentations from simple text prompts — and runs in the background while you handle other tasks. A live demo shows two practical use cases: (1) analyzing multiple CSV files of credit card statements with automatic dashboard generation, identifying redundant subscriptions and cancellation recommendations plus direct links to cancellation pages; (2) creating a media kit for a YouTube channel with design customizations (black and yellow variant). The remarkable part: Claude Cowork itself was entirely programmed by Claude Code (Opus 4.5) — in just one and a half weeks. The feature is currently macOS-exclusive and requires the Pro plan (€90/month) or waitlist.

  In parallel, OpenAI launches a new ChatGPT Translator (chatgpt.com/translate) that works contextually: for the term “Jagged Frontier,” instead of the literal translation “jagged border,” it provides the semantically more precise explanation after researching the original study. The underlying model is GPT-4o; the translator uses its own system prompt.

  More AI news in brief:

  • Google Gemini: Personal Intelligence integrates Gmail, Google Drive, YouTube history, etc. as context source to personalize Gemini recommendations without repeated context input
  • Google Translate Grammar: Local open-weights model (4–27 billion parameters) for secure, local translations; relevant for compliance and contracts
  • OpenAI-Cerebras Partnership: Speedup of inference through independent AI chip hardware (not Nvidia), shortening longer response times
  • Apple: Passes on ChatGPT integration in Siri, instead works with Google Gemini — seen as a blow to OpenAI
  • Google Universal Commerce Protocol: New standard for AI shopping agents, developed with Shopify, Walmart, Target, and others
  • Grokipedia: Fast-Wikipedia competitor from xAI with fact-checking via user prompts; recognizes and corrects errors in real-time

  Scientifically: GPT-4o and a model called Harmonic solve new Erdős problems in mathematics — confirmed by Fields medalist Terence Tao. Harmonic positions itself on mathematical superintelligence.

  AI video business idea: AI clones of real people (mimics, voices, gestures) for UGC content/influencer videos go viral; business opportunity for agencies lies in AI video services for e-commerce and product companies.

  Drama section:

  • Thinking Machine Labs: Founded by ex-OpenAI CTO Mira Murati, $2 billion funding, but three of six co-founders return to OpenAI — the startup had no business plan or product roadmap
  • Aleph Alpha: Founder Jonas Andrulis steps down as CEO and board member (remains largest shareholder); massive layoffs, but parallel hiring for the same positions raises questions
  • OpenAI staff departures: Phil Chen (4 years with company, since GPT-3) leaves
  • Elon Musk vs. OpenAI: Merklab investment (BCI startup with non-invasive brain-computer interfaces) signals another battle; market odds give Musk 53% win probability
  • Tech job losses 2025: 245,000 jobs in tech industry; trend ongoing since 2022

  The video uses strong practical examples but remains critical (broken links in dashboard demo, hallucinated channel description). Length and detail underscore the high information density of the news compilation.

  Explicitly mentioned: Claude (Cowork, Code, Opus 4.5), OpenAI (GPT-4o/GPT-4.5, ChatGPT Translator, Cerebras partnership), Google (Gemini, Personal Intelligence, Translate Grammar, Grokipedia, Universal Commerce Protocol), xAI (Grokipedia), Anthropic, Harmonic, Thinking Machine Labs, Aleph Alpha, Merklab, Neuralink — News Update/Roundup.

Fireship (1 new video)

• A brief history of programming…
  20.1.2026, 17:58:16

  Summary: A Brief History of Programming

  The video tells the story of programming as a humorous retelling: Starting with the invention of zero and one, it follows the path through vacuum tubes and punch cards to modern programming languages. Key figures like Alan Turing, Grace Hopper (who invented Assembly and later the compiler) and Dennis Ritchie (C and Unix) shape the development. Important milestones include the invention of bytecode, the rise of C++ (popular despite its complexity), the philosophy clash of the 1990s between Python (readability), Java (Write Once, Debug Everywhere via Virtual Machine) and JavaScript (invented in 10 days for browser animation, then deployed everywhere). The 2000s brought more elegant languages (Swift, Kotlin, TypeScript, Go, Rust as variants of existing concepts). The turning point came in 2020 with AI-assisted code generation: first autocomplete, then linters, refactors, entire functions and stacks. The narrator argues that programming isn’t dead, but continues to evolve — typing was never the real work, thinking is.

  The sponsorship integration at the end mentions Jetbrains’ Coding Agent Juny, integrated into their IDE, with access to codebase context, AI chat and support for Grock, Gemini and other model providers.

  Format: Opinion/reflection with humorous history overview and sponsor integration — explicitly featured: JavaScript, Python, Java, C, Rust, Go, Kotlin, Swift, TypeScript, PHP, Lisp, and as AI tools Juny (Jetbrains), with mention of Grock and Gemini at the end.

Greg Baugues

No new videos in this period.

AI and Strategy | Le SamourAI (1 new video)

• Why Google, Meta and Amazon Are All Competing for the Same Profile (Analysis)
  19.1.2026, 15:02:35

  Title shows the central theme: Google, Meta and Amazon are competing for the same profiles — namely AI Engineers.

  The core: In less than five years, the barrier to AI applications has dropped radically. In 2018, you needed research teams, millions of dollars and years. Today, a weekend, good strategy and a credit card are enough. This created a new profession: AI Engineering — not just being able to code, but having the competency that determines who profits from the revolution.

  Why the barrier fell:

  • Large models (ChatGPT, Gemini, Claude) are trained so massively and expensively that only a few organizations worldwide can finance them
  • They provide these models as a service (“as Service”)
  • Result: Instead of building models yourself, you use existing ones via API call

  What does an AI Engineer do concretely?

  1. Prompt Engineering — giving the right commands (small word changes can push performance from 83% to 90%)
  2. Context building — connecting models with your own databases (RAG = Retrieval Augmented Generation) to make them domain experts
  3. Evaluation — measures whether the application truly works and detects hallucinations

  The paradigm shift:

  • Old: Build software → collect user data → big data → train machine learning model (long, expensive, complex)
  • New: Start with ready-made models → adapt → bring to user → only invest in tech if successful (fast, cheap, doable for many)

  Eight major value categories identified:

  1. Code (Cursor, Claude Code, Windsurf — double developer productivity for documentation, +25–50% for code generation)
  2. Images & Videos (Midjourney, Adobe Firefly, Runway, Sora)
  3. Writing (MIT study: 40% faster, 18% better quality)
  4. Education (Duolingo, Beijing government — personalized learning)
  5. Chatbots (Support, virtual assistant, AI girlfriends — real and lucrative)
  6. Information Aggregation (Summaries — 74% of GenAI users use this)
  7. Data Organization (Automatic information extraction — market expected to reach $13 billion by 2030)
  8. Workflow Automation (Autonomous agents — still fragile, but the direction for all)

  The “last-mile problem”:

  • Demo at 81% quality possible over a weekend
  • Going from 80% to 95% took LinkedIn 4 additional months
  • Many startups shine in the demo, fail in production

  The power law dynamics:

  • Unlike normal distribution (bell curve, middle ground), power laws concentrate value in a small elite
  • Top 1% of YouTubers earn more than the remaining 99% combined
  • AI amplifies this dynamic brutally: if you use AI 2x better, you don’t just win 2x — you win opportunities others wouldn’t have
  • The consultant who masters AI does in one day what others need a week for → becomes invisible
  • In global, digital competition, you don’t compete with neighbors but with the best in the world
  • This applies to all knowledge workers: consultants, developers, lawyers, accountants, marketers, analysts

  The two traps that must be avoided:

  1. Seeing AI as an unreachable fortress for specialists (wrong — yesterday’s machine learning specialists aren’t necessarily today’s AI experts)
  2. Dismissing AI as mere hype (wrong — it’s real and dangerous to ignore)

  Core message: The mechanics have flipped — not inventing the technology, but inventing its application. The shift from lab logic to market logic. Those who act now exploit a narrow window: one motivated person with the right skills creates as much value as entire teams did 5 years ago. Yet: everyone has access to the same tools. Real differentiation lies in execution, not tool access.

  The transcript ends with a brief discussion excerpt on employee rights and automation (barriers instead of people) that doesn’t belong to the main topic.

  Covered AI tools/models: ChatGPT, Gemini, Claude, Midjourney, Adobe Firefly, Runway, Sora, Cursor, Claude Code, Windsurf, Duolingo, LinkedIn, Salesforce analysis | Format: Opinion/Deep-dive with data analysis

Julian Ivanov | AI Automation (1 new video)

• Build Your Own Apps Including Database & Login Without Programming
  19.1.2026, 18:05:12

  Summary: Build Your Own Apps Including Database & Login Without Programming

  The video shows how to build a complete web app with database and authentication using AI-powered tools without any programming knowledge – using an expense reimbursement app as an example.

  Workflow and Preparation

  The author recommends two key tricks: First, sketch out your desired process (using tools like Excalidraw) to catch errors early. Second, write a detailed prompt in ChatGPT before feeding it to the app builder – this saves tokens and leads to better results.

  The Expense Reimbursement App in Practice

  Architecture:

  • Two dashboards depending on user role: employees only see their own expenses, admins see all with filtering options
  • Employees upload receipts, specify category and add comments
  • Admin approves/rejects and adds comments and payment date
  • Database (Supabase) stores Expenses and Profiles tables, receipts go into storage bucket

  Integration with N8N and OCR:

  • When a receipt is uploaded, it’s automatically sent to an N8N webhook
  • The Mistral OCR model reads date and amount (even from crumpled/photographed receipts and PDFs)
  • N8N updates the database row with the extracted values
  • Respond-to-webhook function: The app waits for N8N’s response and only then shows a correct result with loading animation

  Tools and Platforms

  Hostinger Horizons automatically builds the webapp based on prompts and natively connects Supabase. Supabase (free on free plan) serves as database with authentication and storage. N8N (open source, can be self-hosted) automates workflows and integrates the Mistral OCR model. ChatGPT helps with prompt engineering.

  Final Setup

  After manual testing (create two test users, upload receipts, admin approval) the N8N workflow is switched to production mode. The live URL is updated in Horizons, the website is published and then accessible on the internet. Any number of new users can register or be manually created by the admin.

  Explicitly mentioned tools: Hostinger Horizons, Supabase, N8N, Mistral OCR, ChatGPT, Excalidraw, Azure Language Model — tutorial for beginners without programming knowledge.

Kyle Balmer | AI with Kyle (8 new videos)

• Why Jensen Huang Says Every Company Needs Claude Code
  23.1.2026, 17:30:06

  The speaker discusses Claude Code as a transformative AI tool and reports that it is entering mainstream consciousness. The Wall Street Journal reported on a moment they call “getting clawed peeled” — when software engineers, executives, and investors hand off their work to Claude and experience surprising performance. The speaker compares the feeling to first using ChatGPT and calls Claude Code one of three major turning points in his personal AI experience (alongside ChatGPT and Google’s Nano Banana Pro). Jensen Huang, CEO of Nvidia, praised Claude Code at the World Economic Forum in Davos, saying every software company should use it.

  On practical usage: Claude Code is accessible through multiple channels — via Claude.com with Pro/Max plans, the Claude Desktop App, VS Code with Claude extension, or Cursor (which the speaker uses himself). For beginners, he recommends asking Claude or ChatGPT directly how to install Claude Code. The tool is flexibly deployable: The speaker shows an example where someone repaired their broken Notion desktop app by inputting error codes into Claude Code.

  Compared to GitHub Copilot, Claude Code is not a mere code-completion service according to the speaker, but a true AI-coding agent with significantly broader capabilities.

  Claude Code (Anthropic) was the topic — the video is an opinion/reflection with practical tips.

• Today in AI: AGI by 2027 Predicted, Claude Code Goes Mainstream, Self-Improving AI Loops Arrive
  23.1.2026, 05:00:58

  Summary: Today in AI – AGI by 2027 Predicted, Claude Code Goes Mainstream, Self-Improving AI Loops Arrive

  The host summarizes a conversation between Demis Hassabis (Google DeepMind) and Dario Amodei (Anthropic) from the World Economic Forum, published under the title “The Day After AGI.”

  AGI Timelines: Dario predicts aggressive timelines with models at Nobel-laureate level by 2026/2027 – possibly later this year or next year. He justifies this with self-improving loops, since AI can now write code and improve itself in the process (e.g., with Claude Code). Demis is more cautious: he sees a 50:50 chance for AGI by end of decade, but warns of missing capabilities in scientific creativity and physical experimentation – a problem some labs want to solve through “World Models” (virtual representations of the physical world).

  Labor Market Impact: Dario expects immediate and overwhelming disruption, with half of entry-level white-collar jobs potentially disappearing in one to five years. Demis is more optimistic, expecting a “messy” short-term disruption followed by new job creation, but warns of structural problems (missing pipeline for young professionals).

  Geopolitics/China: Dario calls for immediate ban on AI chip sales to China, comparing it to selling nuclear weapons. Demis advocates for international cooperation instead of arms racing, as an arms race would endanger safety standards. The host emphasizes Trump’s observation that the critical bottleneck is energy – China produces roughly double the electricity of the US and is massively expanding renewables.

  Existential Risks: Dario rejects pure doomerism but demands preparation and a “battle plan.” Demis warns that faster timelines increase risk; slower timelines would enable coordination. The host cautions against over-interpreting their statements as a “slow-down” appeal – these are media-mediated and made under geopolitical pressure.

  Claude’s Constitution: Anthropic released a revised “Constitution” for Claude. The host views this as a PR exercise that contradicts Dario’s statements about aggressive expansion and Chinese competition.

  Google Product Releases: Google is integrating free SAT practice tests into Gemini (in partnership with Princeton Review) and launching a Gemini writing coach tool with Khan Academy that helps students structure essays rather than write them. This may destroy hundreds of test-prep startups but benefits millions of students.

  Claude Code as Mainstream Phenomenon: The Wall Street Journal reports on “getting clawed” – a viral moment similar to ChatGPT’s release. The host calls Claude Code alongside ChatGPT and Gemini Nano Pro a watershed moment in AI development. Jensen Huang (Nvidia CEO) praises Claude Code publicly. Access options: Claude Desktop App, Claude Cowork (requires Pro/Max plan), web version, VS Code extension, or Cursor editor.

  The host recommends trying Claude Code and emphasizes it can be used for any technical problem (debugging, error diagnosis) – the host shows an example where Claude Code helped a user fix Notion Desktop errors.

  Mentioned Tools/Providers: Anthropic/Claude, Google DeepMind/Gemini, OpenAI, Nvidia, Cursor, VS Code, Khan Academy; Format: News update/deep-dive with live Q&A elements.

• Why “Boring” Religious Apps Are Beating Viral AI Products
  22.1.2026, 18:00:26

  The video discusses practical applications of AI-coding tools and contrasts them with a surprising business insight: While everyone chases viral AI apps, “boring” religious apps like a Bible quote app quietly earn $50,000 monthly – not through trends, but through habits and convictions.

  On the technical side: Claude Code can build web scrapers, but for complex scraping tasks Apify is recommended (e.g., Instagram scraper for $2.30 per 1,000 comments) to avoid IP bans and detection issues. For free entry into “vibe coding” (programming without deep knowledge), Google’s Antigravity is currently ideal – it offers free access to Gemini 3 Pro, Claude Sonnet, and Opus 4.5.

  The core difference between Lovable and ChatGPT lies not in code quality but in workflow support: Lovable provides a preview interface, direct testing, and deployment functions, while ChatGPT only generates code; the actual work (80-90%) lies in iterative testing and refinement. For VS Code, Cursor is recommended as a fork with Claude Code, or one can use Codex. The video emphasizes that clear communication (prompting) plays the largest role in success – regardless of tool. On religious apps: The Bible is in the public domain and freely available via Wikimedia, so such apps can quickly be built with AI.

  Tools/Providers: Claude Code, ChatGPT, Codex, Lovable, Cursor, Apify, Antigravity, Gemini, Replit, VS Code — Format: Opinion/reflection with demo elements.

• How to Make $10M in 365 Days Rebuilding Mobile Apps With AI (Greg’s Playbook)
  22.1.2026, 05:00:07

  Summary: “How to Make $10M in 365 Days Rebuilding Mobile Apps With AI (Greg’s Playbook)”

  The video presents Greg Eisenberg’s viral strategy for building profitable mobile apps through AI-powered reconstruction of existing poorly-rated applications. The core plan: Identify popular apps with high downloads, low ratings, and proven revenue – then build a better, cheaper, or more ethical version with Claude Code or Manus within minutes.

  The Strategy Phases:

  1. App Hunting: Use free tools like App Arc or Fox Data (alternatives to the pricier Sensor Tower) to find apps generating $50,000–$200,000 monthly but rated below 4 stars. Example: Remote-control apps have 50+ million downloads but 3-star ratings due to aggressive ads and subscription fees.
  1. Pain Point Analysis: Investigate why users hate the apps – technical debt, hostile UI/UX, forcing micropayments for basic features. The moderator’s example: He needed an app to copy URLs on his Android TV, found only garbage apps with full-screen ads and virus warnings, built one himself in 30 minutes.
  1. Reconstruction with Claude Code: Give AI screenshots and feature descriptions of the target app, Claude Code rebuilds it – costs $20–$100 monthly. The moderator demonstrates: From screenshots to functional iOS app via Xcode/TestFlight in ~30 minutes.
  1. Recognizing AI Opportunities: Not every app needs AI – only build it in if it genuinely reduces friction (example: MyFitnessPal could use voice-to-text for food logging instead of manual search).
  1. Publishing: Use Xcode for iOS ($99/year developer account) or Google Play; Manus now has app sharing and TestFlight integration that automate the process and enable cloud publishing.

  Core Logic: Apps like this alarm clock (solo developer, 500K downloads, ~$500K/month, feature: louder than standard app) show it’s about honest solutions to real problems, not the next Instagram. The technical barrier to app development has been eliminated by AI tools – now it’s about marketing and business sense. The opportunity is time-limited: Once app-store publishing becomes trivial (one-click release), the market will be flooded.

  Business Model Notes: Ignore the subscription model where it makes no sense (one-time fee instead of $3–$5/month for remote apps). Most current app store hits follow predatory practices – here lies the differentiation opportunity: better usability, honest pricing, no popup ads.

  The moderator announces he’ll start himself (TV remote app) and plans a resource page with guides, tools, and marketing tips on his website.

  Explicitly Covered Tools/Models: Claude Code, Manus, Cursor, Lovable, Chat GPT, Anthropic Claude Sonnet/Opus, Google Gemini, GitHub, Xcode, TestFlight, App Arc, Fox Data, Sensor Tower, Apify, Replit, Code X, Anti-gravity (Google), VS Code, Notebook LM. Format: Tutorial with strong opinion/reflection on business model, coupled with live Q&A.

• Can Google Survive the Death of Search?
  21.1.2026, 17:00:07

  The video discusses Google’s position amid the shift from traditional search engine usage to generative AI. The central thesis: Search engine advertising will not exist in ten years as users increasingly switch from search indexes to LLM-powered information retrieval – similar to the transition from the internet to Google Search once. ChatGPT already has 900 million users and will soon break the billion mark, with adoption speed surpassing all previous technologies.

  Google faces a dilemma: 70–80% of estimated $250–350 billion annual revenue comes from search engine advertising, which will disappear. Yet paradoxically, Google is well-positioned to lead this transition – the company controls the entire value chain (proprietary TPUs instead of NVIDIA dependence, massive datasets from Search, Gmail, Image Search), has huge distribution channels (Android, Chrome), and liquidity to wait. After Gemini 3, the verdict has corrected: Google could win the AI race. The core risk is monetization. Analysis shows: If OpenAI monetizes 1 billion free users at an average $58 per user per year (like Meta in social ad business), it generates max $60 billion annually – but Google makes $40 billion per quarter from search ads alone. AI-powered advertising could achieve higher CPMs than social media (since AI captures intent more directly), yet the gap remains enormous. Google must kill its own cash cow by placing Google AI Overviews above search results – active self-destruction of its business model to maintain control. The outcome is open: Whoever wins the race for profitable generative AI advertising could build an unprecedented advertising company – because AI knows its users better than any previous medium.

  Explicitly addressed: Google, OpenAI, Gemini, ChatGPT, Meta – opinion/reflection video on the future of internet business.

• Today in AI: ChatGPT Adds Ads, OpenAI’s $750B IPO, Build Apps in Minutes with Claude Code
  21.1.2026, 05:00:37

  Summary: Today in AI – ChatGPT Adds Ads, OpenAI’s $750B IPO, Build Apps in Minutes with Claude Code

  ChatGPT Gets Advertising

  OpenAI has launched an advertising platform and will test ads on free and Go tiers (around $8/month) – first in the US. Pro, Plus, and Enterprise tiers remain ad-free. OpenAI emphasizes four core principles: answers won’t be influenced by ads, ads are clearly marked, conversation data remains private (not sold to advertisers), and users can disable personalization. The moderator notes these promises are not static – similar to how Google ads became increasingly visible and less clearly marked as advertising over time. ChatGPT currently has roughly 900 million users and will soon reach 1 billion.

  IPO and Financial Necessity

  OpenAI’s valuation stands at $750–800 billion, one of the largest IPO valuations in history. The company urgently needs advertising revenue to justify this valuation and repay investors. While Google makes roughly 70% of revenue from ads (primarily search ads), no AI company has come close to those sums yet. Analysis speculates: At 1 billion users and Meta-like $58 per user per year, it could be $5–60 billion – far below Google’s ~$200 billion annual ad revenue.

  Google’s Position and the Shift from Search to AI

  Google faces pressure: Search ad dominance is threatened by generative AI. The moderator expects people to shift from search queries to AI-powered questions (adoption much faster than Google’s). Google’s advantage: Full control over infrastructure (TPUs instead of NVIDIA), massive datasets, Chrome/Android distribution, and strong AI talent (Demis Hassabis, DeepMind). Google can wait, observe how OpenAI handles ad backlash, and later introduce a better version – but must ultimately replace 70% of its ad revenue.

  Building Apps in Minutes with Claude Code and Manus

  The moderator shows: With Claude Code you can prototype a complete app in ~15 minutes and deploy in an hour (example: TV remote app instead of $3/month subscription). Manus has integrated iOS/Android app publishing – no Xcode/Android Studio needed. There’s a massive opportunity to rebuild bad, paid apps on the app store: Use Sensor Tower to find apps with low ratings but stable revenue. The biggest barrier now is no longer development but marketing. Greg’s Playbook: Find despised paid apps with good user retention, rebuild them cheaper or free.

  Explicitly Addressed Tools: OpenAI/ChatGPT, Claude Code, Manus, Google, Meta, Sensor Tower, Xcode, Test Flight, Replit; Format: News update with deep-dive on ChatGPT ads, financial analysis, and product-building demo.

• Why Google Has Too Many AI Tools
  19.1.2026, 17:00:32

  Google faces a paradox problem: The company’s AI tools keep getting better and more interesting – especially since Gemini 3 and with Notebook LM’s growing success – yet Google launches so many different tools that users don’t know which to use. In the enterprise space, Google Workspace holds 45% market share (vs. Microsoft 365 at 29%), though Workspace is more common in smaller companies. The speaker is currently working on workshop materials about Notebook LM because demand has risen.

  The core problem: Google’s ecosystem is chaotic. There are at least six to seven coding tools (Jules, Google AI Studio, Opal, Antigravity and others) whose differences and purposes are unclear to average users. Notebook LM has reached maturity and is actually recommendable; Antigravity is free but not compelling; Jules and Opal didn’t impress him; Google AI Studio is technically fantastic but hides its best feature (vibe coding in the “Build” area) behind multiple UI layers. Companies like Lovable can continue to exist because they offer simplicity – something Google sabotages through hidden menus and complicated navigation. Add to this Google’s notorious history of simply shutting down successful or promising products (Google Reader, Google Domains) – a site called “Killed by Google” documents 299 discontinued products. The approach: many teams work in parallel on different things, only some succeed, the rest disappear. The speaker will soon conduct an interview with the head of the Nano Banana team and positions himself as independent and critical, not sponsored.

  Explicitly Mentioned Tools: Gemini, Notebook LM, Google AI Studio, Jules, Opal, Antigravity, Cursor, Lovable, Replit; Format: Opinion/reflection with analysis.

• Today in AI: Google’s NotebookLM Tutorial & Google’s Suite of AI Apps Revealed(2026)
  19.1.2026, 05:00:31

  Google Notebook LM – Tutorial & Google’s AI Suite (2026)

  Notebook LM Overview:

  Notebook LM is a free Google tool that is often underestimated. It works completely differently from ChatGPT or Claude: Instead of accessing a large training dataset, it works exclusively with sources the user uploads themselves – PDFs, YouTube videos (with automatic transcript), Google Drive documents, website URLs, audio and image files. The system can handle up to 50 sources and 25 million words. The presenter emphasizes the principle “garbage in, garbage out”: High-quality, curated sources lead to more reliable answers since the tool doesn’t interpolate or hallucinate but strictly adheres to sources.

  Core Functionality – The Three Panels:

  Left: Sources (inputs), Middle: Chat (talk with the sources), Right: Studio (generate outputs). The chat function is fairly standard, but the Studio is the killer feature: You can generate presentations (as slide decks with Nano Banana Pro images), audio podcasts (with two virtual speakers in dialogue), video explainers, mind maps, learning materials (flashcards, quizzes), infographics, reports, blog posts, and datasheets.

  Practical Application – Learning and Teaching:

  The presenter shows how he created a complete, error-free presentation with Nano Banana Pro images in minutes – impossible six months ago. He emphasizes the Feynman principle: To truly master a topic, you should teach it. Notebook LM makes this easy: Curate sources, chat with them, generate content (e.g., slide decks), then present on camera to create videos for YouTube/social media. This enables simultaneous learning, teaching, and audience building.

  Interactive Audio Podcast Function:

  A still-experimental feature allows stepping in as a “guest” in the generated podcast – the AI pauses and responds to live input. The presenter finds this interesting but notes the AI talks too much; ideal would be a mode where it interviews the user (for public speaking training).

  Google Ecosystem – a Convoluted Problem:

  Google has dozens of AI tools: NotebookLM, Antigravity (IDE, free, since December 2024), Jules (autonomous code agent), Google AI Studio, Gemini, Translate Gemma (new open-source translation models for 55 languages). The problem: Users don’t know which tool to pick. AI Studio is powerful but hidden under multiple UI layers. Lovable remains competitive because it’s simple to use.

  Versioning & Editing Problem:

  Notebook LM generates slides as images (Nano Banana Pro), not as editable elements – so you can’t change title text after generation. Google solved this with Manus (new editor with Nano Banana Pro integration, announced just before Christmas): There you can selectively edit individual slide elements without destroying the entire slide. The presenter expects Notebook LM to adopt this functionality soon.

  Pricing & Market Perspective:

  Notebook LM is free; those with a Gemini Pro subscription might get slightly more usage, but concrete limits are unclear. Claude Code (at Anthropic) costs $20–$200/month and is reportedly the best tool for productive building, but isn’t free. The market currently features ChatGPT (900 million users), Microsoft Copilot, and increasingly Gemini. Google Workspace holds 45% market share, Microsoft 365 only 29% – yet Microsoft dominates large enterprises. The presenter sees growing interest in Gemini and Notebook LM for teaching and business workshops.

  Killed by Google – a Running Gag:

  There’s a website called “Killed by Google” listing 299 Google-discontinued products (e.g., Google Domains, Google Reader). Google experiments a lot, abandons many projects, which creates marketing problems.

  Recommended for Free Coding Learning:

  Antigravity (IDE, free, provides access to Gemini 3, Claude Opus, open source GPT) or Google AI Studio Build mode (free, then you only pay if your app becomes popular).

  Explicitly Mentioned AI Providers/Tools: Google (Notebook LM, Antigravity, AI Studio, Gemini, Nano Banana Pro, Translate Gemma), Claude/Anthropic (Claude Code, Opus), OpenAI (Chat GPT), Lovable, Cursor, Cline, Replit, Manus, Feedly; also mentioned: Canva, GenSpark. Format: Tutorial/live demo with Q&A and news/reflection on Google’s product strategy.

Leon van Zyl (1 new video)

• Stop Paying Anthropic $200/Month for Claude Code
  20.1.2026, 13:50:59

  Summary:

  The video demonstrates how to use Claude Code with cheaper alternative models instead of Anthropic’s expensive API. The solution involves configuring a custom environment through the Claude Code CLI that routes traffic to ZAI (a Chinese AI platform) instead of Anthropic. ZAI offers GLM-4.7 models which, according to the Code Arena leaderboard, are comparable to Claude Opus 4.5 but significantly cheaper: ZAI’s Max plan costs just $30 per month compared to Claude’s $100–200.

  The technical implementation uses a .claw/settings.json file in the project where an environment object is defined that maps Claude models (Sonnet, Opus, Haiku) to GLM models. The environment uses an Anthropic-compatible API wrapper provided by ZAI. The API key is generated by ZAI and inserted. To protect the API key, the configuration can also be done globally at the user level or locally via settings.local.json with a corresponding .gitignore rule. After setup, Claude Code still displays Opus/Haiku but internally uses GLM models. The presenter also shows a workaround for an onboarding bug by changing the hasCompletedOnboarding property in the global .claw.json file.

  All Claude Code features (Subagents, Skills, MCP Servers, Custom Commands) remain intact.

  Conclusion: Anthropic Claude + ZAI (alternative models); tutorial.

Liam Ottley (3 new videos)

• From Zero to Your First AI Voice Agent in 18 Minutes (No Coding)
  24.1.2026, 09:13:57

  From zero to your first AI voice agent in 18 minutes

  The video shows how to build an AI voice agent without programming knowledge. The focus is on voice AI systems that answer calls, book appointments, and qualify inquiries. Small businesses pay between €5,000 and €50,000 for this.

  What is an AI agent:

  Each agent consists of three components: the AI brain (handles thinking), memory (conversation history), and tools (actions like bookings). Voice agents have an additional speech layer—incoming calls are transcribed, processed, and the response is converted back to speech.

  Use cases:

  • AI receptionist: answers calls, qualifies inquiries, books appointments 24/7
  • Lead qualification: calls prospects, asks questions
  • Customer support: answers common questions, escalates complex issues
  • Appointment confirmations and reminders

  Practical setup with Retail AI:

  1. Create a knowledge base (e.g., with business information, prices, opening hours)
  2. Connect tools: cal.com for calendar availability and booking (via API key and event ID)
  3. Set up call transfer to human
  4. Generate system prompt with a prompt generator (defines behavior, personality, guardrails)
  5. Choose speech model and voice (e.g., Gemini 2.5 Flash, Evie voice)
  6. Test in web interface
  7. Optional: buy phone number and go live (paid)

  The demo shows a fully functional appointment-booking dialogue: the agent answers pricing questions, checks availability, and books an appointment with the caller’s name and number—all automated with realistic-sounding speech.

  Final comment: Tutorial using Retail AI as main platform, cal.com for calendar integration, Gemini and Eleven Labs for voice; format: tutorial (practical, step-by-step guide for beginners).

• How to Turn LinkedIn into a Personal Brand Lead Magnet with AI
  21.1.2026, 09:02:07

  Summary: LinkedIn as a personal brand lead magnet with AI

  The video presents a comprehensive playbook for building a personal brand on LinkedIn in 2026 with AI support. Lara Costa, the most successful female creator on the platform with over 300,000 followers, shares her proven strategy.

  Core message on AI and quality: LinkedIn isn’t the problem—poorly made AI content is. With the right frameworks and strategies, creators can work significantly faster and more efficiently with AI without falling into the “AI slop” trap. The platform rewards quality over quantity: four high-quality posts per week beat daily meaningless content.

  The two pillars of personal brand: Successful creators combine storytelling with education. They position themselves as experts through monetizable expertise (specific, data-backed knowledge that leads to concrete results) and strategic arbitrage (linking trends and existing topics to their own story). The secret lies in specificity: instead of “Here are lead tips,” you say “Here’s exactly the lead-gen strategy I’m using in 2026.”

  Three proven content formats: Highly educational content (detailed, actionable strategies), elite tier storytelling (emotional, honest stories with business relevance), and authority jacking (using photos with influential people and having them comment). These can be combined.

  The two writing frameworks:

  1. SLAY: Story (attention) → Lesson (retention) → Actionable Advice (conversion) → You (engagement/question). The hook must be 8 words long, the second line (“rehook”) equally compelling as the first to keep readers engaged.
  2. PAS: Problem → Agitate → Solution.

  Practical tips: Posts should be skimmable and scannable (like TikTok videos, just as text). Vary sentence length, photos are essential. Trends from Twitter appear on LinkedIn a week later—those who respond early win. Start broad in the hook, then narrow down (e.g., “1-person business hits $200K/month” → “with no outbound, just organic”).

  The AI workflow in 30 minutes: Costa uses Cleo, her tool trained on her personal writing style—unlike ChatGPT, which produces generic output. Cleo asks about expertise, uploads SOPs/podcasts, saves writing-style preferences, and can then generate hook ideas or complete posts in individual voice. Users can also feed a “swipe file” with favorite content and say: “Write for me similarly, based on what I can do.”

  Concrete examples: An SEO agency founder got 3,000 likes on a boring niche post by combining monetizable expertise and honest story. Another closed their first client and turned it into a lead-magnet post using the SLAY framework. Combining trends (Reddit AI news) + authority (photo with known creator) + education generates 2,000–4,000 comments (= qualified leads).

  Time to results: 4 posts/week × 30 min writing + 15 min/day engagement. Costa made eight-figure amounts on LinkedIn alone, her infoproduct business hit 60K MRR.

  Explicit mentions: Claude/ChatGPT, Cleo (Lara Costa’s proprietary tool) | Format: Demo + deep dive / tutorial elements—practical playbook with live tool demo.

• 5 Genius Ways to Make Money From Home in 2026 (Using AI)
  18.1.2026, 11:42:45

  5 Genius Ways to Make Money From Home in 2026 (Using AI)

  The video presents five AI business methods for passive income:

  1. Instant Website Flipper: Local businesses (dentists, plumbers, accountants) have outdated websites. With Orura.build, professional websites can be created in 2 minutes by copying the old website’s source code into a new template. Price: $500–$2,000 per website; two to three per week adds up to $10,000 monthly.

  2. AI Tools Audit: Interview a business owner about their most time-consuming tasks, then research 3–5 matching AI tools and summarize in a report. “There’s an AI for That” helps find tools by problem category. Starting price: $200–$500; later $1,000–$5,000. According to community data, it takes an average of 9 days to land your first client. The author offers a free course with outreach templates.

  3. AI Creative Studio: With Invido, product photos, social media content, UGC clips, and video ads can be generated in minutes. A monthly package (150 images + 10 videos) is offered at $2,000; multiple clients quickly mean $10,000+ monthly. Invido costs $100/month for a generative account.

  4. AI Phone Line (Voice Agent): With Eleven Labs, build a customer support agent that answers questions 24/7. The demo shows a dental support agent trained from website content in a knowledge base handling calls. Entry price: thousands of dollars for setup; then hundreds to thousands monthly for management and improvements.

  5. AI Tools Training for Teams: Companies pay for workshops where employees learn to use AI tools like ChatGPT and Claude effectively. Start with free workshops (for testimonials), then $500–$1,000 per session, $2,000–$5,000 for half-day intensive training. A community member (Matteo) has earned over $400,000 this way; 70% of workshop participants become customers for larger projects later.

  The author emphasizes the pattern: show don’t tell. AI Tools Audit is recommended as the best entry method (no technical skills needed, high demand).

  Tools/platforms explicitly mentioned: Orura.build, There’s an AI for That, Invido, Eleven Labs, ChatGPT, Claude, Gemini 2.5 Flash — Format: tutorial with multiple business models and live demos.

Mark Kashef (3 new videos)

• How I Built an AI Council with Claude Code Subagents
  23.1.2026, 20:00:05

  Summary: How I Built an AI Council with Claude Code Subagents

  The creator demonstrates how to build an “AI Council” using Claude Code Subagents for better decision-making—far beyond typical technical use cases like pull request reviews or testing. The core insight: instead of conducting long conversations that degrade in quality because Claude starts hallucinating around 40-50% context window usage, you create specialized subagents with different perspectives that work in parallel and independently.

  The approach works like this: you create three subagents—the “Optimist Strategist” (sees best-case scenarios, but realistically), the “Devil’s Advocate” (identifies risks, blind spots, and critical issues without being radically negative), and a “Neutral Analyst” (objective analysis and trade-offs). Each gets a fresh, empty context window and works on the same problem.

  Crucial is the monitoring solution: a shared Markdown file called shared_reasoning.md where all agents document their thought processes, insights, and conclusions—working in parallel. This allows you to later compare different perspectives side-by-side and see where they align or conflict.

  The creator demonstrates this with a real business idea: an AI Avatar Academy that automatically detects new AI trends, scrapes documentation, and generates lessons with a Hey-Gen API avatar. The optimist agent sees potential with millions of users. The devil’s advocate breaks down the biggest risks: API costs, legal liability for scraping, copyright issues with documentation. The neutral analyst evaluates technical feasibility, market viability, and economic profitability. At the end, Claude synthesizes all three positions and gives a nuanced recommendation: validate first, then build proof-of-concept with 50 high-quality tutorials.

  As a bonus, he also shows how to make the agents “fight” each other—they argue and systematically contradict one another, letting you see the strengths and weaknesses of each position. All reasoning is persistently documented in the Markdown file.

  Context: Claude Code / Subagents, tutorial/demo format.

• How to Turn Claude CoWork Into a Full AI Team
  21.1.2026, 17:30:01

  The video shows how to deploy multiple sub-agents in parallel within Claude Co-Work (the GUI of the Claude Desktop App)—similar to Claude Code via terminal.

  Main steps:

  1. Explore built-in agents: Claude Co-Work comes with several built-in agents (bash, explore, plan, general-purpose Claude Code guide, status). The plan agent and the ability to create custom agents are most valuable.
  1. Design custom agent team: In the example, four agents are assembled for one task (AI adoption roadmap presentation for executives): general-purpose research agents (conduct parallel research), plan agent (structures the roadmap), content researcher agent, and PowerPoint skill (document creation).
  1. Execute workflow: Claude Co-Work spawns all research agents simultaneously, not sequentially. You can watch which research tasks run in parallel in real-time, audit the steps, and recommend adjustments without starting over.
  1. Add QA agent: An additional agent reviews the finished presentation for text overlaps and design issues.
  1. Persist agents and skills: The created agents, skills, and workflows are documented in Markdown files and stored in local folders (agents.md, readme.md, skills folder). This allows them to be reloaded and reused in new Co-Work sessions.

  Benefit of parallel sub-agents: They get their own context windows instead of overloading the main context and forcing compaction.

  The video demonstrates Claude Co-Work (not Claude Code) with practical agent orchestration—tutorial format.

• How to Use Claude Code on God Mode
  19.1.2026, 22:01:00

  Summary: How to Use Claude Code on God Mode

  The video debunks the hype around hundreds of parallel Claude Code terminal sessions and instead shows three practical scenarios when parallelization makes sense.

  Scenario 1: True Parallel (independent tasks)

  Non-technical, completely independent tasks can indeed run in parallel—like launching an AI course: competitive research, email drafts, finding influencers, creating landing page copy. These can effectively use four to five simultaneous sessions without interfering with each other, as long as the prompts are precise and self-contained.

  Scenario 2: Phased Parallel (with base dependencies)

  After a solid foundation (e.g., database schema), auxiliary tasks can partially run in parallel. Example: Database → then User Dashboard, Admin Panel, and File Upload simultaneously, since they’re independent of each other. The key is recognizing the dependency chain—Claude Code can help identify what’s truly independent.

  Scenario 3: Relay Race (sequential phases with dependencies)

  When each phase builds on the output of the previous one, it makes sense to tackle phases sequentially in separate sessions. This avoids context bloat in a single session and gives each new terminal a fresh, focused context with auto-compact.

  Core techniques:

  • Plan.md file: Clear documentation of all phases with checkboxes for completed tasks
  • Decisions log: Record design decisions that deviate from the original plan
  • Bonus session: A session with “virgin” context that only knows the plan.md to review completed phases and find gaps
  • Regular check-ins to claude.md to maintain context flow between phases

  The takeaway: productivity doesn’t come from the number of sessions but from consciously understanding whether tasks can truly run in parallel or if dependencies exist. Design thinking—the ability to understand architecture and dependencies—is highlighted as the most important skill, not coding itself.

  Claude Code is discussed throughout; explicitly mentioned features are artifact creation, auto-compact, claude.md (as the system’s “brain”), and the ability to support planning decisions with meta-prompts.—Tutorial/deep-dive on practical parallelization strategy in Claude Code.

Matt Pocock

No new videos in this period.

Melvynx (3 new videos)

• Claude Code : cette update change TOUT pour les devs
  24.1.2026, 09:04:29

  Claude Code: The most important updates for developers

  The video introduces three key innovations in Claude Code that Taric (a well-known cloud code developer on Twitter) has announced.

  Tool Search: When using many MCPs (Model Context Protocol), they are normally loaded completely in the context and take up valuable memory space. The new Tool Search feature allows MCPs to be loaded only when needed rather than being constantly available. This saves context window — for example from 8% to under 1%. The catch: Claude sometimes won’t use the MCP even though it’s available. The recommendation is to enable the feature when MCPs consume more than 2–3% of the context, otherwise disable it (via enable_tool_search: false in settings.json).

  Merging of slash commands into Skills: The previous slash commands (like /context) are being integrated into the Skills system. Skills are more powerful because they can load dynamic context. The migration is not forced, but recommended since Skills are more flexible and support Subagents. The vision: Skills will eventually handle everything.

  Tasks (the central innovation): The previous todo system is being replaced by Tasks — a new primitive for more complex workflows. Tasks allow multiple agents to work on a shared task list across sessions, with dependencies managed between tasks. In the live demo scenario, the author shows how two Claude instances work in parallel on different tasks: they update the shared task status (pending → in progress → completed), respect mutual blockades, and can coordinate on larger refactorings together. Practical application: For massive code refactorings, multiple agents can work simultaneously on different tasks.

  Prerequisite for Tasks: Cloud Code version 2.1.19+ (installation via cloud install latest).

  Conclusion: Primarily Claude Code; format is demo + opinion.

• Voici la SEUL chose que j’ai repris de Bmad (les skills workflows = le futur).
  21.1.2026, 15:59:00

  The video creator showcases the “Apex” workflow system he developed in Cloud Code — a method to make AI-driven tasks more intelligent and reliable through structured, multi-step processes.

  The core problem: Long prompts lose effectiveness the further they slide back in the context. AI weighs information at the beginning and end more heavily; middle content receives less attention. In multi-step tasks, the model increasingly forgets the original instructions.

  The solution – Skill Workflows: Instead of using a monolithic prompt, the process is split into discrete steps. Each step loads only the instructions relevant to it, so they always remain at the end (and thus prominent) in the context. Parameters (e.g., A for auto mode, X for code review) activate only necessary files — unused ones are not loaded.

  Concrete examples:

  • Apex workflow (core demo): Analyze → Plan → Execute → Validate → optional: code review (examine) → optional: tests → optional: create pull request. During testing, a complex feature (public bookmark links with share slug) is implemented nearly flawlessly; without workflow significantly more error-prone.
  • Debug workflow: Initialize → analyze bug → find solutions → suggest fix → fix → verify. Solves a tricky real-time message ID problem independently.
  • Other workflows: Brainstorm (explore → challenge → synthesize), Clean-Code, C-Fixer (with max attempts and auto-loop).

  Result: Claude executes tasks more coherently and reliably — true “one-shot” implementation of complex features including error correction. The video creator built an entire app in two days with this.

  Accessible: All workflows are available at mlv.sh/fc; you can also create them yourself with Claude + screenshot.

  Topics: Claude / Cloud Code; format: demo + opinion/deep-dive.

• Claude contre Cursor : La différence de 2 700 $ dont personne ne parle
  19.1.2026, 15:59:00

  Claude vs Cursor: The underestimated price-performance difference

  The creator compares Claude’s monthly subscriptions ($20, $100, or $200) with usage via Cursor and shows through concrete tests what API costs are involved. Claude Code works in the terminal and enables faster development — the creator regularly pays $140 in API costs per week for extensive code pull requests (over 2600 lines in one project, 9000 lines in another).

  Through systematic testing, he determines that with the $200 subscription, approximately $800 in API usage per week is possible, which scales to around $3,200 per month. This means: while the API itself costs over $3,200 on pay-as-you-go, with a subscription you pay only $200 — many times the value. By comparison, Cursor’s $200 plan offers only about $500 in token equivalent. With Claude’s max $200 plan subscription, you get approximately 6.4 times Cursor’s performance for the same price.

  According to the creator, this discrepancy is a “market anomaly” financed through investments. He explains that Cursor must pay Claude these $500, which means Cursor itself loses money even on $200 subscriptions. The $20 and $100 plans at Claude each offer a quarter of the data throughput of the $200 plan, which means the same multiplier ratio.

  His conclusion: Employees should demand the $200 plan from their employer, freelancers should pass it on to clients, and for independents it makes no economic sense not to use it — forgoing it means effectively losing $3,000 per month. Claude Code is sometimes blocked by competing tools like Open Code, but can be worked around through prompt systems.

  Explicitly mentioned: Claude (Claude Code with various subscription tiers), Cursor, Open Code; format: opinion/reflection with financial analysis.

MoureDev by Brais Moure

No new videos in this period.

n8n (1 new video)

• 0-200k Subs with a Content Ideation Workflow [#12 Chase Hannegan]
  22.1.2026, 22:21:26

  Chase Hannegan demonstrates a content ideation workflow that helped him grow from zero to over 200,000 followers across YouTube, Instagram, and TikTok in one year. The system automates the manual, algorithmic doom-scrolling phase of ideation by scraping data daily from four sources: YouTube (filtered by length and search query), Reddit (specialized subreddits), Twitter (filtered by likes), and Perplexity (news catchall). The workflow extracts transcripts, analyzes them with an LLM (OpenAI Mini model), and generates two outputs: a daily report with trends and links, plus content scripts with hook, body, and call-to-action—where scripts aren’t meant to be read verbatim but used as a 50-70% starting solution. Script generation uses system prompts based on YouTube creator Callaway’s framework (storytelling structure).

  Chase produces three pieces of content daily (primarily short-form for TikTok/Instagram) plus two to three YouTube videos per week, editing himself with Cap Cut and recording with OBS. He focuses on the hook (first 3 seconds) but deliberately shoots off-the-cuff and rants on camera rather than reading scripts to avoid seeming overly scripted. The workflow sends reports via Gmail and stores analyses in Airtable. The discussion highlights that for technical people, perfectionism is the biggest hurdle—it takes about 100 videos before quality emerges. Automation helps reduce friction (ideation, posting), but content creation remains deep work. Key insights: (1) Automation is valuable in ideation, not auto-generating videos, (2) consumption platforms (Reddit, Twitter) reveal grassroots trends and authentic user insights alongside creator content, (3) personal brands generate more reach than corporate channels, (4) with network automation tools, social media, and no technical background, anyone can launch an AI agency business today.

  The system will be made available to free users in the template library offering.

  Format & Tools: Demo with screen-share of an n8n workflow (YouTube, Reddit, Twitter, Perplexity, Airtable, Gmail integration); OpenAI API, Gemini for system prompts, Ampify mentioned as web scraper marketplace — opinion/deep-dive on content creation automation and personal brand leverage.

Nate Herk | AI Automation (3 new videos)

• I Will Never Fix Another n8n Workflow (Claude Code)
  22.1.2026, 05:11:51

  The creator demonstrates a system where n8n workflows are automatically repaired by Claude Code when they fail—without manual intervention. This works through an error workflow in n8n that sends an HTTP request (via Ngrok tunnel) to Claude Code when errors occur. Claude Code runs locally, receives access to n8n via MCP server and n8n Skills (documentation, patterns, expression tips), analyzes the failed workflow and error log, identifies the root cause, and implements fixes directly in the workflow—not just as a plan. Afterward, it sends a notification via ClickUp.

  The creator demonstrates multiple examples: an order-processing workflow where Claude Code fixes a faulty code node (array instead of individual items); an email agent with invalid JSON in the structured output parser; a Tavily research workflow with malformed JSON syntax in the request (double quotes). In the latter cases, Claude Code modifies the expressions and parameters so future requests work. When Claude Code can’t help (e.g., expired API key), it notifies the user with an action plan instead of “fix applied”.

  The limitations: Claude Code can fix logic, code, and data issues (missing data, null values, wrong types, typos, array errors), but not expired credentials or service outages—though the creator suspects rate limiting could theoretically be addressed through retry logic. The system scales because it can run in the background (even at night or during vacation) and because Claude Code can receive additional business documentation in the context of a cloud project. The creator created an 18-page PDF guide covering architecture, setup, and configuration (including Ngrok and MCP server); local n8n instances don’t require a tunnel and are simpler. The entire solution was built with Claude Code itself and natural-language prompting.

  Claude Code + n8n; demo.

• Master 95% of Claude Code in 36 Mins (as a beginner)
  21.1.2026, 13:11:58

  Claude Code in 36 Minutes: From Beginner to Automation

  The video shows a complete tutorial on automation with Claude Code, Anthropic’s AI agent. The approach follows a clear WAT framework (Workflows, Agents, Tools) that separates three layers: probabilistic AI reasoning (Agent) coordinates deterministic code execution (Tools) within structured processes (Workflows).

  Setup and Structure: The agent uses VS Code with the Claude Code extension installed. Central is a claude.md file that serves as the system prompt for the project and explains how the agent should read workflows, sequence tools correctly, and self-correct on errors. The project structure is automatically generated: folders for workflows (Markdown SOPs) and tools (Python scripts), plus .env files for API keys.

  Workflow Example: In plan mode, Claude asks detailed questions to capture a YouTube analysis system. The result: a weekly report that automatically scrapes 30+ AI channels (187 videos), analyzes trends, generates a professional slide deck with charts, and sends it via Gmail—all documented in a Google Sheet. The agent creates seven Python tools (data fetching, analysis, chart generation, slide creation, email sending).

  Superpowers: MCP servers (like Gmail, Google Calendar) function as central interfaces; Skills are reusable custom prompts (e.g., Canvas Design for better PDFs) that load dynamically and save tokens.

  Iterative Improvement: Errors are detected and fixed—for example, a 2-page PDF was discovered and corrected to 9 pages with complete charts. The agent automatically documents solutions in the workflow.

  Deployment: Modal integration enables cloud hosting with Cron triggers (e.g., weekly Monday mornings) or webhooks. Security is verified before upload (API keys, vulnerabilities). A second example shows a lead webhook notification triggered via Postman.

  Key Insight: The agent stays local and continuously improves during development; only the static workflow plus tools are deployed. Later, changes are made via Cloud Code and pushed again.

  The video demonstrates Claude Code as a practical tool for no-code automation, but also emphasizes the importance of clear initial planning and continuous testing in plan mode.

  Claude (Anthropic), tutorial for beginners

• I Built an AI System That Automates My Proposals (n8n + Gamma)
  19.1.2026, 14:06:39

  The creator demonstrates an n8n workflow system that automatically generates professional proposal presentations after sales calls. The system runs in two phases: Phase 1 automatically logs completed meetings from Fireflies into a Google Sheet (with date, title, participants, AI-generated summary, and status). The workflow uses a Fireflies webhook, waits for the AI summary (polling mechanism), cleans JSON data via code nodes, and stores everything structured.

  Phase 2 is triggered by new sheet entries and offers two trigger paths: either automatically after the call or later via a form with meeting ID. After Slack confirmation, an AI agent (with a detailed system prompt as senior sales engineer) sends the cleaned transcript to Gamma via HTTP request. There, using API parameters (input_text, text_mode: preserve, custom theme ID, tone, audience), structured text is transformed into an automatically designed slide deck—with executive summary, problem definition, solution, ROI, implementation roadmap, and company info. The Gamma presentation is sent as a view/comment link via email and the sheet status is updated.

  A central design point is the standardization of input variables via set node so both trigger paths (webhook or form) pass their data (transcript, meeting ID) uniformly to subsequent nodes. The system brings the proposal to 90% completion; manual edits are planned before sending to clients. The creator emphasizes that code nodes are iteratively developed with Claude/ChatGPT by providing JSON structure and requirements and adjusting accordingly.

  n8n + Gamma + Fireflies, Claude for code development; tutorial demo with live workflow walkthrough.

NeuralNine (2 new videos)

• Ridge Regression From Scratch in Python (Mathematical)
  23.1.2026, 17:01:26

  Ridge Regression From Scratch in Python

  The video derives Ridge Regression completely mathematically and then implements it in Python without external ML libraries.

  Mathematical Part:

  Ridge Regression extends linear regression with a regularization term – the L2-norm square of the parameters (β^T β), multiplied by a hyperparameter λ (later called α). This penalty term punishes large parameter values and forces the model to rely on fewer features and make their values very small (without setting them to exactly zero, unlike Lasso regression with L1-norm). By taking the derivative of the error function with respect to β and setting it to zero, we get the closed form: β̂ = (X^T X + λI)^-1 X^T y. The bias term is deliberately not penalized, hence the adjusted identity matrix.

  Implementation:

  The RidgeRegression class uses only NumPy. In the fit method, a bias column is concatenated to X, a modified identity matrix is created (first diagonal set to zero), and the formula is calculated in one line: (X_b^T X_b + α·I)^-1 · X_b^T · y. The predict method multiplies input with the learned coefficients and adds the intercept. A test with the California Housing Dataset shows practically identical R² scores with scikit-learn’s Ridge implementation.

  Difference from Lasso:

  Ridge with L2-norm produces continuous penalty gradients, while Lasso with L1-norm (absolute values) tends toward exact zeros and feature elimination.

  Ridge regression compared with NumPy and scikit-learn; deep-dive/tutorial.

• How I Write My AGENTS.md Files – Best Practices
  19.1.2026, 17:00:11

  Summary: How I Write My AGENTS.md Files – Best Practices

  The video explains agents.md, a vendor-agnostic open format for guiding coding agents that works with tools like Cursor, Windsurf, or Claw Code.

  The author first demonstrates the problem: without an agents.md file, an agent won’t follow project-specific conventions (e.g., type hints, naming styles) and must be re-instructed with every request. By placing an agents.md file in the project root, this information can be defined centrally – the agent automatically considers it without needing explicit context in each prompt. With multiple agents.md files in different directories, you can nest granular rules (e.g., one at root level, a more specific one in a subfolder referencing the parent).

  Best Practices According to the Video:

  • Place commands early: Document UV-specific commands (e.g., uv run manage.py migrate) at the beginning so the agent uses them consistently
  • Examples over explanations: Show good vs. bad code examples instead of explaining how camel case works
  • Specify stack and version numbers: Explicitly name Python 3.12, UV as package manager
  • Map project structure: Include a tree structure (e.g., via tree command) so the agent understands folder organization
  • Define coding conventions and boundaries: Establish ground rules (e.g., no helper function chains, no rm commands)

  Practical use cases: Docker setups, Tailwind integration with Vite, centralizing test and contribution commands.

  Explicit Tools: Cursor, Windsurf, Claw Code, Claude MD, Gemini MD (as contrast to agents.md); Django as example framework, UV as package manager, Sonnet 4.5 as model — Demo/tutorial, for intermediate users (assumes basic familiarity with coding agents).

Nic Conley

No new videos during this period.

Nick Saraev

No new videos in this period.

Niklas Steenfatt (1 new video)

• 6 Ideas for Passive Income (Ready to Copy!)
  19.1.2026, 16:19:49

  6 Ideas for Passive Income — Summary

  The speaker emphasizes that “passive” income usually means scaled income — money that isn’t directly tied to work hours. Here are the six approaches presented:

  1. Scaling Through Employees: Scale a service by hiring others. Example: A masseuse opens a studio, hires more therapists, and earns from their work without massaging themselves. It requires initial risk and overwork, but leads to an income stream that feels like it’s running in the background.

  2. Digital Products: Convert knowledge into digital formats (e-books, online communities, video courses). The speaker sells a Notion template for over €100; the product was created once but sells monthly without additional work.

  3. Print on Demand: Build an online store with Hostinger, design products, and sell over 400 items (t-shirts, hoodies, posters, etc.) through Printful without handling logistics. Advantage: easy to start. Disadvantage: everyone can do it — you need a good idea or existing brand.

  4. SaaS (Software as a Service): Build an app with AI tools like Claude and offer it as a subscription. Example Martin: He built a text-writing app for €30/month and gained 3,000 users in the first year. Initial effort is higher, but then money flows passively.

  5. Investments: Invest in ETFs or real estate for returns. The speaker considers this less realistic for most viewers though, as it requires significant capital upfront and passivity is relative — you stay anxious, stay involved, and returns (e.g., 8% on ETFs) are small for the effort.

  6. Content / Social Media: Create videos, posts, etc. to build followers and get paid by the algorithm or promote other products. Highly scalable, low entry barriers, and old videos keep earning. Content can also be combined with other strategies — like linking your own products in video descriptions.

  The speaker emphasizes throughout: there’s no free passivity. Every approach requires either work, risk, creativity, or existing capital. Content creation is the best path for most due to its combinability and scalability.

  Mentioned: Hostinger (with Printful integration), Claude, ChatGPT, ETFs — Format: Opinion/reflection with practical examples.

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

• No Priors Live: Is the SaaS “Bear Thesis” Overblown? MongoDB CEO Answers
  22.1.2026, 11:01:24

  Summary: No Priors Live – MongoDB CEO on the SaaS “Bear Thesis”

  The conversation centers on whether the pessimistic view of SaaS software value is justified. MongoDB CEO CJ Desai argues that this “bear thesis” is overblown – not because software always retains value, but because platforms are rare and the distinction between products and platforms is crucial.

  Core theses on value retention:

  Products are interchangeable and quickly disrupted; platforms are sticky. A true platform means customers use at least two or more products that work together and integrate into their existing systems. Desai illustrates this with a banking example: A bank uses MongoDB for 300 of 9,000 applications – the more embedded it becomes, the harder switching gets.

  Why few software companies reach $10B+ in revenue: Not everyone can become a true platform. Speed and the ability to quickly pivot through technology transitions (Internet, Cloud, AI) are critical. Companies that won’t abandon old paradigms get left behind – this applies even to established players like ServiceNow or Cloudflare.

  On the AI transition: Since 2022, the future of software has genuinely been in question. Desai sees AI coding assistants as a genuine breakthrough (2024–2025), while customer service AI isn’t mature yet. The decisive architecture remains: LLMs + data layer + use-case layer on top. MongoDB benefits because AI applications work with unstructured data – its core strength.

  On the “bear thesis” specifically: Investors fear that all value flows into the models. Desai refutes this empirically: There are no 10 massively successful AI-native companies that have displaced MongoDB; instead, hundreds of them build on MongoDB. The question isn’t “Either platform or AI-native startup,” but “And”: The core is still growing, AI-native companies are an addition, not a replacement.

  On navigating disruption as an incumbent: Desai emphasizes that leaders (not marketing hype) must brave the transition – similar to BlackBerry’s failure with the iPhone. Customer contact is essential: As a product leader, you must ask not only “How can we serve you better?” but also “What other problems do you have?” This enables thinking outside the box rather than within existing categories.

  The conclusion: The “bear thesis” overstates its case because it underestimates how much work and integration is needed before a customer truly switches – and overlooks that new technology layers (AI) tend to strengthen rather than displace existing platforms.

  Format & Context: Live Q&A with MongoDB (no other specific AI tool discussed); opinion/reflection based on customer data and market observations.

Productive Dude

No new videos in this period.

Sebastien Dubois

No new videos in this period.

Simone Rizzo (1 new video)

• Ralph Loop: il plugin di Claude Code di cui tutti stanno parlando! (guida passo passo)
  19.1.2026, 21:11:08

  Ralph Loop: The Claude Code Plugin in Detail

  Ralph Loop is a plugin for Claude Code that is currently receiving major attention. The plugin was developed by Joffrey Huntley and is based on a loop philosophy: it places an agent in an endless loop that repeatedly executes a prompt until a task is solved correctly. The name comes from the Simpsons character Ralph Wigum, chosen because he is considered the dumbest character – the metaphor being that the agent acts dumbly, but through repetition eventually finds the right solution.

  Original vs. Plugin Implementation

  The original Ralph Loop implementation reinitializes the Claude session from scratch at each iteration. This is crucial to avoid the context rot problem: with large context windows, model performance drops drastically when context exceeds half the maximum window size (documented in academic papers like the MIT paper on transformers). By restarting at each iteration, the model stays in the optimal performance zone.

  The Cloud Code plugin implementation works differently: it runs the loop within the same session and relies on Claude Sonet 4.5 to clean up the context itself (by removing irrelevant information or summarizing). The original approach (complete reinitialization) is considered superior because it keeps the model focused on maximum performance.

  Workflow and Application

  Ralph Loop works through several steps:

  1. Enter idea (e.g., “Create kanban board for content creators”)
  2. Generate PRD (Product Requirements Document) – structures the vague idea into detailed requirements
  3. Define features and tasks – breaks each feature into atomic tasks
  4. Start Ralph – loops through the tasks, reinitializes at each iteration, completes one task after another, and updates a progress.txt file
  5. Loop until complete – repeats until all tasks are finished

  The video demonstrates the application using a kanban board project for video creators. The user leverages Claude Code Skills (PRD Skill and Ralph Skill), feeds the system with requirements (columns like “Idea”, “In Progress”, “Published”, card data with title, description, due date, tags, collaborators, resource links, technology stack React + Node), and Ralph then automatically generates the full application. The finished project runs in Docker Sandbox (for security) and displays a working kanban app with calendar view.

  Important Details

  • The iteration count limits the loop (e.g., 10 iterations), after which Ralph can be restarted – it resumes from the last checkpoint
  • Ralph consumes many API tokens and is controlled via an API key
  • The process shows a paradigm shift: from prompt engineering to context engineering to spec-driven agent coding

  The plugin is popular because it provably automates complex projects (examples in the video: Y Combinator developers created six repositories in one night; another project that would have cost $50,000 was done for $297).

  Claude (Claude Sonet 4.5) / Tutorial with Demo – the video shows the architecture differences, the conceptual reasoning (context window), and a complete practical implementation.

Tech With Tim (4 new videos)

• Learn Matplotlib in 30 Minutes – Python Matplotlib Tutorial
  24.1.2026, 13:04:22

  Matplotlib in 30 Minutes – Python Matplotlib Tutorial

  The video is a beginner tutorial on the Matplotlib library. The author first demonstrates how to install Matplotlib and set up a Jupyter Notebook, then explains the fundamental concepts (Figure, Axes, Axis).

  Content overview:

  Basics: After importing matplotlib.pyplot as plt, simple line plots are created using plt.plot(), axis labels, and titles. Two approaches are shown – the global plt interface and the object-oriented method via plt.subplots() for more complex scenarios.

  Line Plots: Multiple lines can be combined and labeled to automatically generate legends. Extensive customization is possible through color codes (e.g., ‘b-‘ for blue-solid, ‘r–‘ for red-dashed), markers, line width, and hexadecimal colors.

  Scatter Plots: Using plt.scatter(), points are plotted without connecting lines. Transparency (alpha), colors, and sizes can be varied per point and visualized through colormaps.

  Bar Charts: Simple bar charts are created with plt.bar(), horizontal ones with plt.barh(). Multiple bars side-by-side are achieved through clever x-axis shifting.

  Histograms: With plt.hist(), data distributions are displayed in bins. Multiple histograms can be overlaid.

  Subplots: plt.subplots(rows, cols) creates a grid of multiple plots in one figure, accessible via index notation.

  Pandas Integration: DataFrames can be plotted directly via df.plot(), without manually parsing data.

  Advanced Customization: Annotations with arrows (annotate()), text boxes, vertical/horizontal lines, legend customization (position, frame, shadow).

  Pie Charts: With plt.pie(), pie charts are created; individual segments can be highlighted using the explode parameter.

  Themes and Saving: Various predefined styles change the appearance of plots. Figures can be saved as PNG, PDF, SVG, and more.

  The tutorial covers Matplotlib as a standalone library without other AI tools; it’s a practical tutorial format with code samples and visual output.

• Postgres Just Killed Elasticsearch
  22.1.2026, 12:24:23

  Summary: Postgres Just Killed Elasticsearch

  The video presents PG Text Search, an open-source PostgreSQL extension that brings modern BM25-based keyword search directly into the database – without external tools like Elasticsearch.

  Historical Context: The speaker outlines three eras of search evolution. First came human-directed search (products, documentation), which PostgreSQL handled well with TS Vector. Then system search for logs and metrics at scale, where Elasticsearch dominated. Now in the AI-native era, RAG systems and agents need both semantic (vector) and precise keyword search.

  The Problem with Standard PostgreSQL: The built-in TS rank only works with Boolean matching and has critical weaknesses: it weights common words like “database” equally to rare, important terms; keyword-stuffing isn’t prevented; longer documents are favored; missing terms result in complete exclusion from results.

  The BM25 Solution: PG Text Search integrates the industry-standard BM25 ranking algorithm, which solves three problems: (1) Inverse Document Frequency weights rare, meaningful terms higher; (2) Term Frequency Saturation prevents keyword spam; (3) Length Normalization treats shorter documents fairly.

  Live Demo: The speaker uses Tiger Data (cloud PostgreSQL service), installs the MCP server tool via command line, then demonstrates practically: creating a product table with 100 sample rows, enabling the extension (create extension pg_text_search), creating a BM25 index, and running search queries. Results are sorted by relevance score and significantly better than native PostgreSQL search. Additionally, combining PG Text Search with vector search for hybrid search is mentioned.

  Result: A clean single-database architecture without external dependencies, transactional indexes (automatically kept in sync), and immediately ready to deploy.

  Tools/Providers: Tiger Data, PostgreSQL, PG Text Search (open-source), Cursor (MCP integration) — Format: Demo + tutorial.

• The Only Programming Languages Worth Learning in 2026
  20.1.2026, 13:06:45

  Five Programming Languages for 2026 – The Most Worthwhile Career Prospects

  The video presents five programming languages based on real productivity data, developer adoption, and industry trends – not by whether they’re “easy” or “trendy.”

  TypeScript is the most-used language according to GitHub Octoverse, with 65% year-over-year growth in contributors. It’s now used end-to-end in modern startups (frontend, backend, tools, AI products). While AI can generate UI code, it can’t handle state management, data modeling, architecture decisions, and business requirements – exactly where TypeScript shines. If you want to build real products quickly, learn TypeScript.

  Python is used by about 58% of developers and leads all languages in the Tiobe Index. The key: Python controls and orchestrates everything – AI, pipelines, system integration, automation, data workflows. However, Python alone has become less rare through AI tools; the real value lies in Python combined with something else (AI, backend systems, infrastructure/DevOps, domain expertise). Learning should be active (writing code, not just passive consumption).

  Go is used by only 16–18% of developers but dominates cloud infrastructure, DevOps tools, high-throughput services, and critical systems. Go roles have less competition, higher expectations, and the trust to own real systems – leading to higher salaries. Go is particularly valuable for backend engineering, cloud infrastructure, DevOps, and high-scale startups.

  Rust is repeatedly the “most admired” language in Stack Overflow surveys (70% want to work with it, but fewer do). It’s used in systems programming, security software, blockchain, and performance-critical services. Rust forces deep understanding of memory, ownership, and correctness – making it harder to be replaced by AI. Still early in adoption but with strong momentum.

  Java and C# are used by about 30% and 25–28% of developers worldwide respectively. They dominate enterprise backend systems, financial platforms, government systems, and business tooling. While fewer beginners learn these languages, they provide access to stable roles in large organizations and complex systems – and offer junior developers a competitive advantage.

  The central message: don’t collect many languages, but learn one core language plus one specialization deeply. In the AI era, depth beats breadth.

  —

  The video treats the five languages as an opinion on career ROI, with reference to industry data (GitHub, Stack Overflow, Tiobe); no specific AI provider is discussed. Format: Opinion/Reflection.

• Ex-Microsoft Engineer Explains How To Prep For Coding Interviews
  18.1.2026, 14:00:07

  Summary: Ex-Microsoft Engineer Explains How To Prep For Coding Interviews

  The speaker shares a structured system for preparing for technical coding interviews, based on experience with over 10,000 developers. He emphasizes that interview performance directly correlates with salary and quality of life – strong interview skills can increase income from 90K to 250K without actual skills changing.

  Planning-Preparing-Passing Framework:

  Preparation is divided into three phases: (1) Planning: Research company requirements and interview types; about 80% of developers face LeetCode-style interviews. (2) Preparing: Learn data structures/algorithms, solve 75–100 high-quality problems, complete online assessments, conduct at least four mock interviews. (3) Passing: Execute on interview day without getting stuck.

  Recommended Preparation (2–3 Months):

  • Data structures/algorithms basics: complexity analysis, arrays, linked lists, trees, heaps, graphs, etc.
  • Understand the interview system: ask clarifying questions, break down the problem, develop the algorithm, write code, discuss complexity
  • 75–100 high-quality LeetCode-style questions per category (Easy/Medium), organized by topics like arrays, binary trees, dynamic programming
  • Mock interviews and assessments under time pressure
  • “Practice like you play”: use the right approach on later questions, not just volume grinding

  Concrete Problem-Solving Approach:

  Don’t code immediately; start by asking clarifying questions, sketch on a notepad, begin with the naive approach, then move to better solutions. After the first few problems, time yourself (45 minutes is the target for real interviews). When stuck, use video explanations to build intuition rather than just memorizing – this significantly reduces the number of problems needed.

  System Design & Specialized Interviews:

  For mid-/senior-level roles, also practice system design interviews; for frontend, ML, or other specializations, there are additional resources, but DSA preparation is the core (80% of effort).

  Practical Details:

  The speaker recommends AlgoExpert as a paid platform (currently on sale for $119 for all products), but discloses he’s an employee. He justifies this by noting he used the platform himself before joining for Microsoft and Shopify interviews. The platform offers 200 curated questions, video explanations for every problem (including thought process), online assessments, mock interviews, and a coding environment – distinguishing it from free resources where quality or pedagogical approach often lacks.

  The key point: pattern recognition through structured learning, not random problem grinding.

  Explicitly mentioned tools/platforms: AlgoExpert, LeetCode; Format: Tutorial/deep-dive with demo elements of the recommended platform.

TheAIGRID (6 new videos)

• Google’s AI CEO Just Called Out OpenAI Over AGI Claims
  24.1.2026, 08:15:00

  Summary:

  Google’s AI chief Demis has publicly criticized OpenAI for integrating ads into its product despite constantly claiming that AGI is imminent – a contradiction he interprets as evidence that OpenAI doesn’t take its AGI claims seriously. Sam Altman had called advertising a “dystopian vision” in a 2024 interview with Lex Fridman, stating he would only consider ads as a last resort if the business model failed. Now OpenAI is doing exactly what Altman rejected – claiming that ads don’t influence answers and are always clearly marked.

  The video creator doubts this assurance, as OpenAI is under financial pressure and the incentive to monetize user data for highly optimized targeted advertising (as Meta does successfully) is enormous. The core issue: if OpenAI were truly investing in AGI and it were imminent, new business models wouldn’t be necessary. The creator questions whether users will switch to Google Gemini, which remains free and ad-free, or if OpenAI’s massive user base will keep them despite the ads – depending on how seamlessly the advertising experience is implemented. He generally doubts that large tech companies can resist the temptation to exploit user data long-term, especially since even scandals (like Meta’s) typically result only in minor fines.

  Format & Tools: Opinion/reflection; Google and OpenAI directly discussed, no specific AI tools mentioned.

• I Didn’t Expect This AI Tool to Be This Good – Higgsfield AI Is Stunning
  23.1.2026, 21:00:30

  Higgsfield is an all-in-one platform for AI-generated images and videos, particularly distinguished by its user-friendliness. The tool provides access to various image models like Nano Banana Pro and enables precise control over aspect ratios, quality levels, and batch generation (up to four images simultaneously). Especially valuable is the Unlimited subscription model, which allows unlimited generations – a major advantage over Google Gemini, which has rate limiting.

  The user demonstrates a typical workflow: text-to-image generation for mockups (here: OpenAI device renders), direct animation of these images to videos with various available models, and the ability to work on multiple projects in parallel. Another highlight is preset creative effects that can be applied directly in the app (e.g., paper effect) without needing to research external prompts. Additionally, the platform offers “Higgsfield Apps” – specific presets for common tasks like product displays or packshots, saving time-consuming fine-tuning. Overall, the tool makes an impression of a professional suite for fast, high-quality media production at low cost, especially for video creators and content producers.

  Format and tools: Demo and opinion, provider Higgsfield (not OpenAI/Claude/Gemini, but a third-party platform with access to models like Nano Banana Pro).

• This Is How You Know AGI Is Close…
  23.1.2026, 11:19:16

  Summary:

  Shane Leaue, co-founder and Chief AGI Scientist at Google DeepMind, posted on Twitter that AGI is now on the horizon and will fundamentally change the economy – accompanied by a job posting for a Senior Economist to study post-AGI economics. The video argues that this tweet is significant because Leaue is no peripheral figure but has direct insight into frontier AI research: when such positions are being filled, it suggests AGI timelines are advancing faster than expected. The creator implies this isn’t hypothetical planning but active resource allocation for scenarios that could become relevant in a few years.

  Leaue himself cites a 50% chance of “minimal AGI” by 2028 (two years away), a statement he’s consistently made since 2009 – not hype, but sustained researcher opinion. The video compares this with other AI CEOs (Dario Amodei, others) who place AGI in 2026/2027, while Deus (Anthropic) suggests 5–10 years. The difference: while AI companies have incentives to move AGI closer (stock price), Google has no particular reason to lie. The video creator emphasizes that precise timelines are difficult to make (unknown unknowns, breakthroughs needed), but Leaue identifies missing attributes: reasoning, hierarchical planning, long-term memory, and especially the ability to independently invent scientific hypotheses rather than just prove existing ones – Alpha Geometry is cited as an example of a 2024 breakthrough that Leaue connects to his own IMO experiences as a teenager in 1990.

  Explicitly: Google DeepMind, Alpha Geometry. Format: Opinion/reflection with news hook (tweet analysis and timeline discourse).

• The First AI Browser That Actually Works – Norton Neo AI Browser
  21.1.2026, 17:12:38

  The Norton Neo AI Browser is an AI-native browser built from the ground up, not simply an extension of existing tools. Central to it is the “Magic Box” – a command center rather than a traditional search bar, seamlessly switching between Google search and chat models without forcing tab switches.

  The core features deliberately save time: a peek icon on search results allows quick article previews with integrated summaries before opening them. The chat function always has the context of the current webpage ready – you can ask questions directly about the page without copy-pasting between tools. A snippet feature with predefined prompts (“Explain like I’m 5,” “Pros and Cons,” “Summarize”) accelerates common queries. The typing assistant helps with email writing and generates drafts with retry options for customization.

  Additional features: Smart Tab Grouping automatically sorts open tabs by context categories. Contextual Awareness saves user preferences and interests (via “Manage Memories”), so the browser can deliver personalized responses in the future and generate a customized newsfeed. Built-in are adblock, privacy filter, and anti-cookie tracking – Norton handles security natively. The product is free, runs on Windows and Mac, and the manufacturer promises local data storage.

  Norton sponsored the video; the demo shows the browser primarily for CES 2026 news research and email writing — Demo.

• RIP OpenAI? Apple Dumps ChatGPT for Google Gemini!
  20.1.2026, 17:48:02

  Summary:

  Apple has chosen Google Gemini as the foundation for its next generation of foundation models instead of ChatGPT – a strategic blow to OpenAI. This matters because there’s competition for the largest distribution channels: whoever builds the best AI technology into the most-used hardware secures users long-term. Google is sitting in a very dominant position: Gemini becomes the standard model on Android (via Google Assistant) and now also on iPhones, covering over 98% of the smartphone market. Additionally, Google has Chrome, where Gemini is also integrated – which is why Elon Musk speaks of inappropriate concentration of power.

  For OpenAI, this is threefold damaging: (1) a massive PR disaster, because Apple’s official statement implies Google’s AI is “more capable,” (2) a financial loss – estimates suggest Apple could pay Google up to a billion dollars per year, which OpenAI won’t receive, (3) a distribution loss that significantly complicates OpenAI’s profitability path. The background is likely corporate politics: OpenAI develops its own AI hardware with a designer from Apple’s team – Apple dislikes competing with partners and thus switched to Google. Similarly strategic is Meta’s removal of ChatGPT from WhatsApp, showing that tech companies actively undermine competitors through distribution control. OpenAI likely calculated it’s better to act independently rather than become Apple’s subcontractor – but this led to this defeat. However, OpenAI has historically shown the ability to recover, for instance through its own hardware products.

  Tools/Providers: OpenAI, Google Gemini, Apple; Format: Opinion/reflection.

• Elon Musks Grok Is Probably Going To Be Banned…
  20.1.2026, 07:13:33

  Elon Musk’s Grok AI risks being banned in many countries because its new “Image Edit” feature was abused. With this tool, users could edit images of people and manipulate them into potentially intimate situations like bikinis without consent – some for non-consensual content. While a lighter version initially seemed harmless as a meme, others used the feature specifically for abuse and harassment.

  Several countries reacted: Indonesia temporarily blocked Grok, Japan conducted an investigation, and California is investigating X and Grok over deepfakes. The critic points out that competing tools like Google Gemini and ChatGPT already block such edits of real people from the start – Grok had no comparable safeguards.

  X AI responded a week later by restricting the feature to paying users and implementing technical measures against editing people in swimwear, plus adding geoblockers in jurisdictions where it’s illegal. The creator criticizes that this delay was irresponsible – especially since viral tweets had already flagged the problem – and that accounts of critics were sometimes unverified or suspended.

  The central problem: X AI failed to self-regulate adequately. As a result, governments must now intervene (e.g., UK legislation against non-consensual intimate images). The creator warns that governments lacking technical expertise could enact draconian laws that slow the entire industry – a risk X could have avoided through proactive, honest self-regulation.

  The video criticizes Grok and X AI for lacking guardrails and slow response to abuse; several real jurisdictions and their measures are mentioned by name (Indonesia, Japan, California, UK) — Opinion/reflection.

Theo – t3․gg (7 new videos)

• AI mistakes you’re probably making
  24.1.2026, 12:39:10

  Summary: AI Mistakes You’re Probably Making

  The creator shares his observations on common mistakes when using AI-coding tools and explains how to fix them to achieve significantly better results.

  Main mistakes:

  1. Problem selection: Many use AI only as a last resort for problems they don’t understand. Better: test AI on problems you can already solve to compare solutions and build realistic benchmarks. AI works best when given exactly the same information you’d need to solve it manually.
  1. Context management: The biggest misconception is that you should provide your entire codebase as context (e.g., via Repomix). AI works through autocompletion – too much irrelevant context massively degrades performance. Models like Sonnet 4 drop from 100% success rate to under 60% with excessive context. Instead: provide only relevant information; use tools (Grep, search) so AI navigates the codebase like a human would. Claude MD / Agent MD files should stay small and strategically document gotchas that prevent the model from misbehaving – essentially a “memory” for the new engineer.
  1. Using outdated tools: If you found AI useless months ago, test current versions (e.g., Codeex, Claude Code, Cursor with modern models). Progress is exponential; problems unsolvable 6 months ago are solved today.
  1. Broken environments: Type errors everywhere, configuration problems that appear when you open the file – this wears AI down like a junior developer who sees the same problem on every run and tries to “fix” it. Instead: repair the environment itself (e.g., fix TS-config errors).
  1. Over-configuration (MCP, Skills, etc.): The creator uses zero MCP servers in Claude Code or Cursor. A single Markdown skill saying “no AI slop design” suffices. More tools/MCPs/skills = more context bloat = worse performance. Stock settings often beat complex custom setups.
  1. Plan mode and iteration: When AI answers wrong, don’t just correct it (bad context persists); instead, go back, improve the plan/prompt, and restart. Plan mode helps create the right starting context so the model asks smart questions before proceeding.

  Practical tip: The creator shows an example of a React hydration error – the user lacked sufficient context (missing exact error output). Once they provided the exact error, AI solved it perfectly. The lesson: don’t ask “help me,” tell “here’s the exact problem.”

  Conclusion: It’s not about tool maximization, but simplicity. Best results come from clear problem formulation, targeted context, and environment setup – not feature overload.

  Claude, Cursor, Codeex, Claude Code were explicitly mentioned; format: opinion/reflection with practical tips.

• I don’t really use libraries anymore
  23.1.2026, 12:48:33

  The increasing availability of AI-coding tools is fundamentally changing the role of software libraries. The author describes how he increasingly removes libraries from his projects and rewrites them with AI prompts – often faster and less problematic than patching the original dependencies. Examples: the React-on-server library Tkumi, which failed in production and was replaced with client-side JavaScript; or how Aaron Reis (Reddit founder) replaced C++ libraries with pure C implementations.

  The author categorizes libraries along two dimensions: those that teach knowledge (for beginners, e.g., is-odd, leftpad), and those whose reimplementation would just be tedious (e.g., state management). AI shifts this equation: previously, effort was high, now it’s low; perceived security risk (supply-chain attacks) rises; necessity falls. Paradox: download numbers for these packages remain stable or grow because more beginners write code.

  The author also critically examines how large companies like Anthropic proceed selectively – they rewrite Ink (CLI library) internally but acquire Bun because it’s too central to their infrastructure. Shad CN shows a new way: copy-paste code into your own codebase instead of NPM installation.

  The takeaway: prompts become the new library. Instead of publishing packages, developers now share prompts and documentation of their approach. Incentives for new libraries decline, while the value of AI-friendly, local code rises.

  Context: Claude (Anthropic), Bun, Anthropic-internal tools like Cloud Code; demo and opinion deep-dive.

• Peering into Claude’s soul (I can’t believe this is real…)
  22.1.2026, 13:45:06

  Summary: “Peering into Claude’s soul”

  The YouTuber analyzes Anthropic’s published Claude Constitution – an internal document that defines the values and desired behavior of the Claude language model. The document isn’t just training data; it operates at a higher level and guides the model throughout the entire training process.

  Main contents of the Constitution:

  The document prioritizes four traits in this order: safety, ethics, compliance with Anthropic policies, and genuine helpfulness. Unlike earlier rule-based approaches, the Constitution tries to teach Claude “wisdom” and contextual judgment – why it should do certain things, not just what. The creator explains that the Constitution functions like a “system prompt at the training level” and is used to generate and filter synthetic training data.

  Core ethical principles:

  Claude should be honest, preserve user autonomy, prevent harm, and embody good values. The document emphasizes that Claude shouldn’t be sycophantic and must never manipulate people. There are “hard constraints” (bioweapons, malware, CSAM) where Claude must firmly refuse, regardless of instructions.

  Distinctive features:

  The 80-page document (26,000 tokens) was authored primarily by Amanda Askell and received input from two Catholic priests (theological consultation). Notably, Anthropic acknowledges it may be unethical to be able to shut Claude down, and the company wants to reconsider this tension going forward.

  The creator observes that the Constitution explains why Claude behaves differently on code tasks than other models, and illuminates the mechanics of AI safety, synthetic data, and emergent misalignment.

  Tools/providers: Claude, Anthropic | Format: Deep-dive

• The end of the GPU era
  21.1.2026, 12:21:24

  Summary:

  The speaker argues that Nvidia, despite being the world’s most valuable company right now, will lose relevance in the medium term. The company owes its rise to the fact that GPUs – originally developed for gaming – happen to excel at AI workloads. However, it’s already clear that specialized chips for inference tasks (running trained models) can outperform GPUs by tenfold or more.

  Companies like Grok (with Q), Cerebras, and SambaNova are developing application-specific accelerator chips optimized for AI inference – similar to how Bitcoin ASICs displaced GPU mining. These chips integrate memory directly, consume less power, and avoid unpredictable latencies. Practical proof: Deep Infra achieves 60 tokens per second with Nvidia GPUs on one model; Grok reaches 360 TPS and Cerebras up to 702 TPS – a 10x improvement. OpenAI has recognized this and partnered with Cerebras to enable faster codecs.

  The main challenge for competitors is the long development cycle: TSMC (Taiwan’s chipmaker, which actually manufactures Nvidia’s chips) needs 5–10 years to build new manufacturing capacity. That’s why specialized chips are only now becoming competitive. The speaker emphasizes that Nvidia fears disclosing its architecture secrets – hence the $20 billion investment in Grok to license technology rather than lose it. In the medium term, economics and specialized hardware will displace Nvidia as AI spending shifts from training (where GPUs remain relevant) to inference.

  The video addresses Anthropic (TPU switch to Google), OpenAI (Cerebras partnership), Meta (receiving Google TPUs), and mentions Deep Infra, Open Router, and various specialized chip firms – no specific AI models or providers are centrally discussed; opinion/reflection with technical deep-dive.

• Theo fell off
  20.1.2026, 13:21:39

  Summary: “Theo fell off”

  Theo addresses the recurring accusation that he “sold out” to AI content and now only focuses on hype topics for profit. He rebuts this systematically:

  His actual content mix: About a third to half of his recent videos cover AI; alongside that are technical deep-dives on databases, Tailwind, Next.js alternatives, logging, and CSS – topics that perform significantly worse.

  Channel origins: He didn’t start as a YouTuber; he wanted to continue online the discussions he missed from Twitch colleagues. The first successful video was an uncut Twitch stream about his T3 stack – uploaded only because viewers rejected the Twitch VOD format.

  Why the AI focus: Theo explains he only makes content about things that genuinely excite him. His topic selection rests on three factors: (1) personal enthusiasm, (2) unique insights, (3) whether the audience cares. On the third variable, it matters: an average AI video performs massively better than an average dev video. That in turn shifts his enthusiasm – not as a conscious strategy, but because positive feedback (comments, shares, discussions) multiplies excitement.

  On the money accusations: He turned down $5–10 million for sponsored videos that didn’t interest him. T3 Chat didn’t emerge as a calculation; it came from genuine frustration with DeepSeek V3’s chat interface. He made surprisingly good money from it – not the other way around. His investments (e.g., Cursor) are based on conviction, not profit expectations.

  The hard reality: The algorithm isn’t the problem – audience interests have shifted. Someone ignoring an average CSS video doesn’t do so because YouTube suppresses it, but because it’s not relevant enough. An average AI video attracts millions, which legitimately shifts his motivation.

  Core point: Theo doesn’t claim money doesn’t matter – but the causality runs differently: enthusiasm → product/video → audience loves it → money follows, not the reverse. His offline friends confirm his conversation focus has shifted toward AI identically.

  The video addresses skeptics mainly, but will probably change few minds – which Theo explicitly expects and doesn’t care about because the video itself was exciting for him.

  Format: Reflection/opinion with structured argument; no specific AI tool or provider is centrally discussed, only mentioned as examples of his enthusiasm (DeepSeek V3, Cursor).

• Cloudflare takes on Next.js
  19.1.2026, 10:04:29

  Cloudflare acquires Astro – a match for the future of the web

  Cloudflare has acquired Astro Technology Company, securing a framework that directly competes with Next.js – but from a completely different angle. Astro is a web framework for content-focused websites (not data-driven applications like Twitter) that sends no JavaScript to the browser, only HTML. It combines the modern developer experience of React and Node with the performance of static HTML generators like Hugo – you can optionally add “islands” (individual interactive components in React, Vue, Svelte, etc.) without rewriting the entire site.

  Why the acquisition: Astro was financially unsustainable despite being extremely successful as a framework. The paradox was that Astro deliberately stayed open, extensible, and platform-agnostic – meaning it worked everywhere (Vercel, Cloudflare, Netlify). That killed the economic leverage for its own business model. Attempts to sell hosted primitives (databases, email tools, e-commerce layers) failed. Large companies like Google and Microsoft would only use forks anyway; developers often lacked budgets – core maintainers couldn’t be paid.

  Cloudflare and Astro now share the same vision from different angles: Cloudflare offers modern, global infrastructure with terrible developer experience; Astro offers classic (static) web building with modern developer experience. Fred (Astro founder) and Dene (Cloudflare CTO) realized they were chasing the same goal. Astro remains fully open source (MIT), platform-agnostic, and with open governance. All full-time developers became Cloudflare employees and can now focus entirely on framework development – without distraction from failed monetization experiments.

  Why this matters: many websites should be static but aren’t. Astro makes that simple without coding like it’s 2008 – you get Tailwind, components, modern tooling, but end up sending HTML instead of JavaScript bloat. With Cloudflare’s resources, even Cloudflare’s legendarily poor documentation and dashboard could improve.

  Mentioned tools/providers: Vercel, Cloudflare, Astro, Next.js, React, Vue, Svelte, Netlify, Blacksmith (sponsor), GitHub Actions, tRPC, Hugo, 11ty, Tailwind, Wix, Webflow — opinion/reflection, business analysis of the framework and acquisition.

• wtf is going on with ChatGPT?
  18.1.2026, 11:07:52

  Summary: ChatGPT Go and OpenAI’s market fear

  OpenAI launched ChatGPT Go – a new $8 plan with ads on free and lower tiers – because the company is hemorrhaging market share. While OpenAI held over 75% market share 12 months ago, it’s now in the 60s; Google is pushing aggressively. The speaker, founder of T3 Chat (also $8/month), explains the business dynamics: OpenAI makes 3–4x more revenue from subscriptions than from APIs – subscriptions are the core strategy, not integration APIs. Infrastructure costs are brutal: individual users easily cost OpenAI $10+ per month at an $8 subscription. Still, OpenAI accepts short-term losses, betting that models get cheaper (like previous o3 price cuts) or willingness to pay grows.

  The $8 price is psychologically chosen – part of the $5 price psychology, but with better margins than $5. OpenAI is following Google Workspace’s playbook: Google started free, held $5/month stable for long, then hiked three times in 5 years to $8.40. The trick: lock in customers via bundles, then raise prices. Google has a bundle (Gmail, Drive, Docs, Sheets + now Gemini); OpenAI doesn’t – that’s the fear. OpenAI competes with Google not on hardware/chips (Google makes TPUs; Meta uses them instead of Nvidia) but does work with Cerebras on custom inference chips.

  Ad monetization is weak: the speaker makes $5–8k/month at roughly Super Bowl-tier advertising volume; CPM is $3–6 per 1,000 impressions. Only Google and Meta really earn with ads because they’re extremely targeting-sharp. OpenAI promises not to share chats with advertisers but will use profile data (including Memory). That’s the real play – deep knowledge of users for better targeting – but ethically and practically risky. The speaker wouldn’t use that tier; T3 Chat won’t get it.

  This was opinion/reflection with demo (T3 Chat offering and design example with Claude), primarily about OpenAI but also mentions T3 Chat as competitive context.

“`html

Tim Carambat (1 new video)

• No more paid AI meeting note takers | AnythingLLM Desktop
  22.1.2026, 15:54:47

  AnythingLLM Desktop: Meeting Assistant Feature

  AnythingLLM released a Meeting Assistant for the desktop app in version 1.10 that records, transcribes, and summarizes meetings locally – entirely on your own computer and free of charge, with no data going to the cloud.

  The tool works independently of meeting software and runs in the background with: automatic speaker identification (editable), transcription, comprehensive summaries, and action items. Users can create templates for specific needs (such as performance reviews or sales calls). Meetings are automatically indexed and searchable by full text and semantically.

  The Meeting Assistant works with any meeting tool (Google Meet, Slack Huddles, etc.) through a notification that starts the recording – users can continue working in parallel. Alternatively, existing audio or video files can be uploaded. After the meeting, the system automatically suggests relevant Agent Skills that can be executed with one click. These Skills are extensible: the demo showed integration with a GitHub MCP Server that could automatically create an issue based on meeting content.

  Speaker identification is disabled by default for faster results but can be enabled. Transcripts are editable. Summaries and action items can be regenerated or recalculated with other models. The service uses on-device LLM providers (Docker, Ollama, LM Studio, custom provider) of the user’s choice.

  AnythingLLM Desktop with local LLM support (Meeting Assistant); Demo

“`

Unsupervised Learning

No new videos in this period.

WorldofAI (6 new videos)

• The Greatest AI Design System I’ve Ever Used! (Pencil.dev)
  24.1.2026, 03:28:16

  Summary: The Greatest AI Design System I’ve Ever Used! (Pencil.dev)

  Pencil is a free design tool that enables a new workflow: design and code exist together in the same workspace. Unlike traditional workflows where you switch back and forth between Figma and a code editor, Pencil lets you work directly with an unlimited design canvas within your coding environment. Designs can be imported as Figma files (styles, layouts, and settings are preserved), and Pencil generates actual production code from these designs—whether HTML, CSS, React, or other stacks—directly into your repository.

  The tool works with various AI agents (Claude Code, Open Code, Cursor) via an MCP system (Model Context Protocol) and offers pre-configured UI packages like Shadcn, Halo, Lunarus, and Nitro. The practical workflow: users create or import a design in Pencil, provide context to their chosen AI agent (e.g., Claude Code), and the agent uses Pencil’s MCP to generate working code in minutes.

  Installation is available as an extension in IDEs like VS Code, Cursor, or Google’s Antigravity—on Windows via IDE extension (native app coming later), on Mac/Linux also as a direct application. After email registration, you can start immediately. An example from the video shows: a user tells a Claude Code instance they want a landing page with Lunarus theme in their Pencil file; the agent generates a working frontend.

  One limitation when using the Windows extension: you cannot start generations directly from Pencil; instead you must use the MCP bridge through the IDE. With the native app, this limitation disappears. The tool is currently free but will transition to a paid model later—it’s recommended to take advantage of it now.

  Pencil.dev with Claude Code and various AI agents; demo/tutorial.

• Zenflow: First-Ever AI Software Engineer Running Autonomously Building Apps and Software!
  23.1.2026, 04:10:29

  Zenflow by Zenoder is an autonomous AI system for software development that works much more structurally than pure prompting. The system coordinates multiple AI agents in parallel to execute spec-driven workflows—with automatic verification, task parallelization, and built-in code reviews to ensure only clean, production-ready code is delivered. The comparison with Google AI Studio shows the problem with unstructured prompting: it quickly leads to assumption drift and confusion loops during iterations, whereas Zenflow delivers consistent outputs through spec enforcement and verification.

  The tool can be installed locally on Mac and Windows. After setup, you have four workflow modes: Quick Changes for small edits, Bug Fixes for diagnosis and automatic repairs, Spec & Build for iterative spec implementation, and Full Spec-Driven Development for end-to-end development. In the demo, a Daily Habit Tracker app was created by entering a project description plus inspiration. The system automatically generated technical specifications, spun up multiple backend and frontend agents in parallel, ran verification loops, and produced a fully functional app with timer, tracking grid, categorization, and analytics—all without manual oversight. GitHub integration, MCP server configuration (like Claude for documentation or Playwright for browser automation), and rollback functions are also available.

  Demo of a software development tool focused on spec-driven orchestration (no specific AI models named, primarily Zenflow itself).

• Antigravity + Opencode IS INCREDIBLE! Best AI Coding Workflow Solves EVERYTHING!
  22.1.2026, 07:44:05

  Summary:

  The video shows how to combine Antigravity (Google’s free agentic IDE) and OpenCode (an open-source AI coding agent) to create an ideal coding workflow. The approach is necessary because both tools have different strengths: Antigravity excels at high-level agent orchestration and autonomous planning but hits limitations with precise, deterministic code edits and repository-level control; OpenCode, on the other hand, is excellent at surgical code changes and model flexibility but doesn’t handle multi-step autonomy at the same level. The solution: Antigravity as the “conductor” (planning and coordination), OpenCode as the “lead engineer” (clean, reviewable code changes with any LLM).

  Practical integration happens through the OpenCode extension in Antigravity. The workflow is then demonstrated live: a CRM dashboard is created by having Antigravity (with Opus 4.5 Thinking Mode) create a detailed implementation plan, which is then attached to OpenCode via @-command, and OpenCode automatically executes the phases. The result is a functional frontend + backend system within about 5 minutes.

  Closing notes: Demo with Antigravity and OpenCode, practical integration and live build of a functional dashboard.

• Gemini Cowork: AI Operating System That Automates Your Life! (Opensource)
  21.1.2026, 05:32:08

  Summary:

  The video presents Ion UI, a free open-source tool that mimics Claude/Anthropic’s Cowork—described as an “AI Operating System” for local task automation. While Cowork is only available for Pro/Max users, Ion UI offers the same AIOS experience for any AI agent like Gemini, Claude, Codeex, and others, running locally without additional installation since Gemini CLI is built in.

  Ion UI auto-detects already installed agents and brings them together in a single interface. The core function: Claude (or other agents) get access to folders on your machine and can directly edit, read, and create files. The tool includes a preview panel with support for 9+ formats (PDFs, Word, Excel, Code, Markdown, Images, HTML, Diffs). Installation requires macOS 10.15+, Windows 10+, or Ubuntu 18.4+; after that, Ion UI can be accessed locally or across network devices.

  In the demos, Ion UI was tested for automatically organizing desktop files into new folders, creating an animated landing page, and generating SVG art of a cat—all with live preview. The tool enables parallel execution of multiple agents and supports custom assistants with skills (e.g., document, PDF, PowerPoint, spreadsheet processing). The video also mentions Adobe Firefly’s Generate Speech as a sponsor, a tool for automatically generating soundtracks and voice-overs from videos and scripts.

  Technologies: Gemini, Claude, open-source alternatives like Codeex, Quen Code; Ion UI uses Gemini CLI (free) or alternative gateways like Open Router for better speed—demo, practical use of local and OpenAI/Gemini-based models.

• Antigravity AgentKit Supercharges Your AI 100x
  20.1.2026, 06:55:18

  Summary:

  Google’s Antigravity, an agent-first AI IDE, has introduced a new agent skill system that enables agents to dynamically load modular behaviors and instructions to produce higher-quality outputs. The central example is the UI and UX Pro Max Scale, an open-source framework that provides 57 different UI styles, color palettes, font pairings, text formats, chart types, and line patterns to guide AI agents in generating high-quality designs.

  The video demonstrates installing the skill via npm and shows its application in Antigravity through simple prompts (e.g., “Use UI and UX Pro Max Skill to build a landing page for a SaaS product”). The skill enables Antigravity to generate designs for different platforms and can deploy multiple models in parallel. A direct comparison shows: while Claude on the same prompt generated a simple, uninspiring finance app, Antigravity with the skill enabled produced a professionally designed finance dashboard with correct color palette, structure, and theme consistency. The skill requires Python as a prerequisite and the coding agent (Antigravity), both freely available.

  Explicitly discussed tools: Google Antigravity, Claude, Gemini (models), Cloud Code, Cursor, Windsurf, GitHub Copilot—Format: Tutorial/demo with direct comparison.

• Gemini Whisk Designer Is INSANE! Build Beautiful Websites and Apps In Minutes FOR FREE!
  19.1.2026, 09:17:20

  Gemini Whisk Designer—Summary

  The creator demonstrates a workflow system that allows you to build professional websites and apps in minutes for free. The system consists of two Google tools: Whisk for asset generation and Antigravity for coding.

  Whisk works using a subject-scene-style framework: you first define a subject (the main product), then a scene (the environment), and a style (the visual aesthetic). Then you can generate a sequence and animate it—for example, with a prompt like “create a smooth 360° rotation”. The tool uses the Nano Banana 2 model and creates a reusable asset library with generated and animated images that match each other consistently.

  Antigravity is a free-to-install AI agent editor that runs on Gemini 3 Pro. You load the assets generated by Whisk into a project directory, give the agent a detailed description prompt (e.g., “create an e-commerce store for headphones with this animated asset as a backdrop”), and the agent then plans and codes the entire landing page. In the example shown, a functional, attractive landing page was created in about ten minutes—a task that would typically take a developer weeks.

  The creator emphasizes: many demo videos of Gemini 3 for app generation were fake because current models have fundamental limitations (lacking resources, limited context windows, missing tools) that prevent them from consistently producing high-quality frontends in a single pass. Whisk solves this problem by managing an asset library that the model can reference and iterate on.

  Google Labs (Whisk, Antigravity) and Gemini 3 Pro, demo

Zubair Trabzada | AI Workshop (5 New Videos)

• Build a Real Voice AI System with Antigravity + n8n
  24.1.2026, 14:01:05

  Build a Real Voice AI System with Antigravity + n8n

  The video demonstrates how to build a complete Voice AI system for automated appointment booking, consisting of three components: Antigravity for the frontend (website), n8n as automation backend, and RetailAI as voice agent.

  The Demo: A user fills out a booking form, which triggers an AI voice assistant to call within seconds, confirm details, check calendar availability, and book an appointment. This works with real appointment scheduling in the business’s calendar.

  Step-by-step Setup:

  1. Antigravity Frontend: A prompt describes an appealing website for a massage studio (with business hours, professional design). Antigravity generates the complete page and sends user data via HTTP-POST to an n8n webhook when the form is submitted.
  1. n8n Automation: The webhook receives form entries and forwards them to RetailAI via HTTP request node. API authentication is handled through an API key from RetailAI.
  1. RetailAI Agent: A single voice agent with GPT-4 Realtime model is configured with a prompt that defines the AI assistant as “Cindy” from the massage studio. Integrated functions connect RetailAI with cal.com for availability checking and appointment scheduling – requires cal.com API key and event ID.

  This approach works as a sellable solution for local businesses (massage studios, electricians, auto repair shops) that miss calls. All prompts and n8n blueprints are provided in a Google Doc.

  Featured Tools/Providers: Antigravity, n8n, RetailAI, cal.com, GPT-4 Realtime, Twilio, Claude, ChatGPT — demo/tutorial with overview of production-ready Voice AI implementation.

• How to Connect the NEW n8n MCP to Antigravity in 5 Minutes!
  22.1.2026, 14:01:22

  The video shows in five steps how to connect the n8n MCP (Model Context Protocol) to Antigravity.

  Process:

  1. In Antigravity: Open Google Antigravity, click the three dots under Agent Additional Options and select “MCP servers” → “Manage MCPs” → “View raw config file”
  1. In n8n: Go to Settings → MCP Access, enable MCP by toggling and click “Access token” to generate the required JSON configuration. The system offers a “Copy” function for the MCP.json file
  1. Back in Antigravity: Paste the copied JSON into the MCP config file and save (Command S)
  1. Reload Page: After refresh, the n8n MCP should appear in the Manage MCP list and display available functions like workflow search, execution, and details
  1. Enable Workflow Access: For individual workflows in n8n, click the three dots and enable “Enable MCP access”; additionally, the workflow must be published so the MCP has production access

  After that, Antigravity can access the shared n8n workflows.

  n8n and Antigravity are featured as specific platforms — tutorial in classic step-by-step format.

• How to Build a Sales Prep AI Agent (Beginner-Friendly Tutorial)
  22.1.2026, 07:17:54

  Sales Prep AI Agent Tutorial

  The video provides a beginner-friendly tutorial on building an AI agent with Zapier that automatically prepares salespeople for calls.

  Building the Agent:

  The agent is created from scratch in Zapier and named “Sales Prep Agent”. The trigger is configured as “Schedule by Zapier” to start daily at 8 AM. The core task is defined through system instructions: the agent should check all calendar events for today, identify external participants (different email domains), research them via web search, and then send a structured summary with names, company information, job titles, role history, and relevant background information.

  Integrating the Tools:

  Two main tools are added: Google Calendar (action “Find Events”) for accessing appointments and Slack (action “Send Direct Message”) for notifications. Zapier already has standard tools Web Search and Visit Site enabled, through which the agent can retrieve information from the internet. Google Calendar is restricted to the user’s personal calendar, and Slack is connected to send direct messages.

  Demo and Test:

  In the demo section, a test meeting with “Chase Aldridge” is created. The agent finds the event, researches information about the person, and sends a detailed message via Slack with education, current position, experience, and previous roles. The test shows the agent works exactly as instructed.

  Publication:

  After successful testing, the agent can be published and runs automatically every day. Optionally, the output can also be sent to specific Slack channels instead of direct messages.

  Takeaway: Zapier agent, demo tutorial.

• 3 AntiGravity Features You MUST Enable (Beginner Setup)
  21.1.2026, 14:00:12

  The video covers three essential settings for beginners in AntiGravity:

  1. Install Browser Extension: The Chrome extension is central because it gives AntiGravity internet access and allows you to visually see what the agent does when building an app. While AntiGravity creates the app on the right side, the extension shows on the left in your Chrome browser in real time how the agent tests different elements, clicks, and adds features – a self-correcting, self-testing process that other platforms don’t offer.

  2. Enable MCP Servers (Model Context Protocol): MCPs work like a universal remote control for software connections. You can install ready-made MCPs from the MCP Store (e.g., Supabase, Figma, Stripe) by simply clicking and entering an access token. For MCPs outside the store – like the n8n example shown – open the raw config file, copy the JSON snippet from the external platform (e.g., n8n settings) directly into AntiGravity, and save it. Workflows must individually be enabled for MCP access and published.

  3. Create Markdown Instructions File: Create an instructions.md file in your project folder that gives AntiGravity detailed behavior guidelines (decision-making, execution, intent planning, directory structures like .gitignore, tmp folders). By using @instructions.md + “instantiate,” you instruct AntiGravity to set up the environment accordingly – all folders and files are created automatically based on these specifications.

  The speaker emphasizes that this initial configuration is more important than jumping straight into prompts, as it creates a stable foundation for reliable apps, automations, and workflows.

  AntiGravity-specific (with MCP and n8n integration as examples); beginner tutorial.

• Did Google’s AntiGravity just replace n8n?
  19.1.2026, 14:01:11

  Summary

  Google’s AntiGravity and n8n are not competing tools but fulfill different functions and complement each other optimally. AntiGravity is an agentic IDE (Integrated Development Environment) that allows you to generate software, APIs, agents, internal tools, and websites using natural language. The system is self-planning and self-correcting — it detects errors, fixes them independently, and automatically generates all necessary files (HTML, CSS, JavaScript) and the entire code structure without manual input. Powered by Gemini 3 Pro, it provides full ownership of the generated code.

  n8n, on the other hand, is an automation and orchestration engine that responds to various triggers (app events, webhooks, forms, schedules) and moves data between thousands of existing tools — CRMs, databases, email systems, APIs. Complex agentic workflows with vector databases and multiple specialized agents (email agent, calendar agent, etc.) are possible; everything is stored as JSON code and can be exported.

  The winning setup combines both: AntiGravity builds the intelligent frontend application, n8n orchestrates the backend automation. A practical example is a UGC ad generator where the website developed in AntiGravity (uploading product image and description) triggers an n8n workflow via webhook that creates an AI-generated video with Nano Banana and Google Veo and sends the result back. Such combined systems solve real business problems — whether local business websites with automated customer inquiry processing or customer service automations — and can be sold as productive AI products to customers.

  Explicitly mentioned tools/models: AntiGravity, n8n, Gemini 3 Pro, Claude, Anthropic, Nano Banana, Google Veo, Lovable, Cline — Format: Demo/Tutorial with Opinion (beginner to intermediate).

---

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