All Videos
Master Coding Agents Like a Pro (Anthropic’s Ultimate Playbook)
The opening of the talk defines “vibe coding” as more than just using AI to help write code. The speaker argues that true vibe coding means letting the model handle the implementation to the point that you “forget the code exists,” while you focus on the outcome. He explains why this matters: as AI systems get better, they will be able to handle larger and larger chunks of work, making it unrealistic for humans to stay in a tight line-by-line review loop forever. He then frames the core challenge as how to use this approach safely in production. His answer is that engineers should stop obsessing over every implementation detail, but still stay accountable for the product’s behavior and quality. He compares this to managers or executives overseeing work they cannot personally execute in full detail: they succeed by verifying outcomes, requirements, and checkpoints rather than inspecting everything directly. A key caveat in this early section is tech debt. He says that unlike product behavior, tech debt is still hard to validate without actually understanding the code. Because of that, he recommends using vibe coding mainly on leaf nodes of a codebase, meaning isolated features where problems are less likely to spread into the core architecture.
13:25
Ralph: Autonomous Coding Loops for Claude
Autonomous coding loops can move fast—but without visibility and control, they can become hard to trust (and easy to run too long). This video walks through how Ralph Loop and the Ralph TUI add structure to long-running agent workflows, so you can track progress and intervene when needed. Key takeaways Covers what Ralph Loop is and how continuous iteration differs from a single-pass run in Claude Code. Breaks down why a task tracker and TUI matter as projects grow, including live task status and output streaming. Walks through setup: choosing a tracker (e.g., a local PRD JSON file), selecting an agent (Claude Code or OpenCode), and setting iteration limits. Demonstrates generating a PRD, turning it into a task list, and running sub-agents with pause/resume and session persistence.
14:45
OpenSource Kimi K2.5 just dropped
Open-source weights are back—but for professionals, the real question is whether the latest drop meaningfully improves day-to-day coding, vision work, and agent workflows. This video walks through what Kimi K2.5 claims to deliver, where it benchmarks well, and what it looks like in hands-on demos. Breaks down Kimi K2.5’s focus areas: coding, vision tasks, and “self-directed” agent swarms Covers benchmark results across agentic, coding, and vision/video evaluations, plus cost vs. performance claims Shows practical examples like generating front-end websites and recreating a site from screenshots (no code provided) Demonstrates tool-using behavior, including a web-based price comparison and discussion of local runtime/VRAM needs
25:28
From Vibe Coding To Vibe Engineering
Frontend teams have always ridden hype cycles—but LLMs change the day-to-day work: you can “accept” code fast, and just as quickly land in the wrong abstraction. This talk reframes “vibe coding” into “vibe engineering,” focusing on how professionals can collaborate with AI without losing control of quality, context, and maintainability. Breaks down what “vibe coding” means in practice and why the definition keeps shifting Contrasts hands-off prompting with “vibe engineering” using agents—plus why you should stay skeptical of generated code Shares tactics the speaker uses (e.g., voice-to-code, starting from solid primitives, and supplying rules/docs/memory) Covers when vibing is appropriate (one-off scripts, simple features) and when it’s risky for teams and juniors
17:44
Researchers solved the Context Window Limit
Context windows cap what you can reliably ask an LLM to reason over—and as inputs grow, “context rot” can make quality drop fast. This video breaks down an MIT paper proposing recursive language models: a way to process arbitrarily long prompts at inference time without changing the core model. Key takeaways Covers why stuffing more tokens into a prompt can degrade retrieval and reasoning, even before hitting the physical limit. Walks through the RLM setup: storing the long prompt in a Python/REPL environment and giving the model tools to search it. Explains the “recursive” step—re-querying relevant sections to go deeper without summarization or compression. Reviews how the approach is evaluated on long-context tasks (e.g., BrowseComp+, Oolong, code repository understanding) and what tradeoffs show up in cost variance.
15:36
Building Cursor Composer
Building agentic coding systems often fails on a familiar constraint: you can make them fast, or you can make them smart—but professionals need both to stay in flow. This talk walks through how Cursor built Composer, focusing on the infrastructure, training setup, and evaluations behind a low-latency coding agent model. Breaks down the “fast vs. smart” trade-off and why token-generation efficiency matters in real workflows Explains the rollout-based RL setup, including how tool calls (read/edit/search/lint/shell) are used and scored Covers scaling challenges like bursty compute, consistency between training and production, and load balancing for uneven rollouts Shows why matching the production environment—and integrating semantic search—shapes stronger agent behavior (e.g., better search/read before editing)
1:03:50
Spec-Driven Development: Sharpening your AI toolbox
AI coding tools are powerful—but without a solid spec process, delivery can become hard to reproduce and hard to trust. This talk walks through spec-driven development in Kiro and shows how structured artifacts can bring more control and reliability into an AI-assisted workflow. Key takeaways Covers how Kiro turns a prompt into requirements (with acceptance criteria), design, and a task list you can execute. Breaks down the EARS format (Easy Approach to Requirements Syntax) and why structured natural language matters for later automation. Explains how requirements can be translated into correctness properties for property-based testing, tying specs to code behavior. Shows how to use MCP servers across requirements, design, and implementation—and how to customize artifacts (e.g., wireframes, explicit test cases).
16:22
Don't Build Agents, Build Skills Instead
Agents can be smart and still unreliable for real work when they lack domain expertise. This talk argues that the next step isn’t more agent scaffolding—it’s packaging reusable expertise as “Skills” that agents can load when needed. Key takeaways Breaks down what Skills are: organized folders of procedural knowledge (including scripts/tools) that can be versioned, shared, and composed. Explains why code and the file system can act as a universal interface, while Skills supply the missing domain context. Walks through “progressive disclosure” to protect the context window and enable libraries of hundreds or thousands of Skills. Maps an emerging architecture: agent loop + runtime environment + MCP servers for connectivity, with Skills providing expertise—and how that supports deployment across domains.
Showing 1 to 9 of 30 results