All Videos

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.

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

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

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.

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)

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).

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.

Vague prompts and “vibe coding” can leave teams with code that’s hard to trust, review, or evolve—especially once a codebase is already in motion. This tutorial walks through OpenSpec, a spec-driven toolkit that aims to align humans and AI assistants on what to build before implementation, with a workflow designed for ongoing development and changes.

Key takeaways

• How OpenSpec structures work into proposals, tasks, and spec updates to keep scope changes auditable and transparent
• How it separates “current” specs from proposed updates to handle evolving systems more cleanly
• A hands-on setup: installing via npm, initializing in a project, and generating project context files for an AI agent
• Moving from a change proposal to implementation while keeping results more deterministic and reviewable

Tech planning gets harder when hype cycles, shifting job signals, and platform churn collide. This video runs through a fast-paced set of 2026 tech trends aimed at developers—mixing market talk with what’s changing across AI, hardware, and the JavaScript ecosystem.

Key takeaways

• Covers what the speaker says about the 2026 developer job market, including openings data, a BLS forecast, and how AI coding tools affect roles.
• Breaks down where the AI “bubble” might be headed, plus signs the speaker watches for (including IPO talk).
• Walks through robotics and wearable AI examples mentioned in the transcript, and how they’re being positioned for work and consumers.
• Reviews platform shifts: VR/AR outlook, chip dominance and power constraints (including nuclear), quantum computing milestones, and Node/Deno/Bun/React updates.