Firehose

This talk argues that "skills" are the primary repository of organizational know-how in AI-native workflows, and that failing to govern them creates a new form of technical debt. The speaker advocates for treating skills like microservices—implementing registries, versioning, and clear ownership—to move beyond ad-hoc agentic tasks toward deterministic, scalable systems.

This talk explains how to use Lean4 to mathematically verify that code matches a human-defined specification, moving beyond probabilistic testing. The presenter details a workflow where AI agents generate both code and proofs, using Cedar as a real-world example of reconciling Lean-based semantics with production Rust code.

This talk argues that AI adoption in physical services businesses—like property management or construction—requires a shift from "co-pilot" tools to asynchronous "co-worker" agents that can handle multi-step, real-world tasks. The speaker explains that because his firm, Long Lake, owns these businesses, they focus on "diffusion" by treating knowledge work like code and building systems that can handle the messy, non-internet-native ground truth of physical operations.

This talk outlines a pragmatic approach to integrating AI agents into a large engineering organization by prioritizing verification over blind adoption. The speaker argues that senior engineers are the most skeptical for good reason, and suggests that teams should focus on "planning over prompting"—spending significant time defining clear, verifiable goals before letting agents handle the implementation.

This talk breaks down how Amazon teams achieved 4.5x to 10x productivity gains by shifting from "AI-assisted" coding to "frontier development." The speaker argues that the tool itself is rarely the variable; success depends on adopting specific habits like pruning agent context, restructuring brownfield codebases for agent readability, and shifting testing left to enable autonomous self-correction.

This talk demonstrates how to use Stripe Projects to provision a sandbox billing environment via CLI, using a coding agent to scaffold complex logic like credit pools and metered usage. The speaker argues for a "human-in-the-loop" approach, emphasizing the use of portable skills files and verbose error messages to help agents self-correct during the development phase without pushing untested billing logic to production.

This talk provides a pragmatic framework for building LLM gateways, focusing on the inevitable trade-offs between availability, latency, cost, and guardrails. The speaker argues against standard engineering defaults like circuit breakers and aggregate latency tracking, advocating instead for per-request fallbacks and model-specific timeouts to prevent silent outages.

This is a walkthrough of a Google Cloud Builders Lab that uses Google AI Studio to generate a basic portfolio site. The video demonstrates the "build mode" interface, showing how to prompt for a layout, iterate on sections, and deploy the result to Cloud Run.

This is a walkthrough of a Google Cloud Codelab that demonstrates how to use Google AI Studio to generate a simple task-management application. The video shows how to integrate Firebase for authentication and Firestore for real-time data syncing, followed by a one-click deployment to Cloud Run.

This tutorial walks through building a turn-based web game using Google AI Studio and Firebase. The video focuses on implementing event sourcing to track game history, using Firestore for real-time multiplayer state, and deploying the result to Cloud Run.

This talk outlines DoorDash’s shift from treating AI evals as an engineering-only task to a cross-functional workflow. By exposing stable APIs rather than building custom UIs, their platform team enables non-technical operations staff to "vibe code" their own annotation interfaces, effectively decentralizing quality control across the organization.

This is a technical case study on building an internal multi-agent code review system at scale. The speakers focus on the operational reality of managing AI-generated feedback: specifically, how they used addressal rates, sentiment analysis, and agent trajectory tracking to move beyond naive prompting and reduce costs by 60%.

This talk is a technical post-mortem on building the Figma MCP server, focusing on the architectural trade-offs required to bridge design files and codebases. The speaker details why they moved from raw pixel-perfect React/Tailwind output to a Code Connect-based approach, and explains why they shifted from manual spreadsheet evals to an automated LLM-judge pipeline.

This is a promotional conversation between a16z partners announcing their new "Machine Age Fund." The participants discuss why they believe AI infrastructure—ranging from power and cooling to specialized hardware—is currently the primary bottleneck for AI growth, rather than the models themselves.

This video provides a conceptual overview of modular "skills" for coding agents, specifically tailored for the Antigravity framework. It categorizes these skills into seven design patterns to help manage agent context and workflow: * GitHub skills repository — A collection of pre-built skill templates. * Google skills repo — Specialized skills for Google Cloud services. * Skills setup guide — Instructions for configuring skills in Antigravity. * Codelab — A step-by-step guide for creating and installing custom skills. * Whitepaper — Best practices for evaluating and testing agent skills.

This is a pitch for Unblocked, a tool designed to feed organizational context—like Slack threads, architecture docs, and past PR decisions—into AI agents to prevent them from hallucinating or getting distracted. The speaker argues that without this "context engine," agents act like new employees who reset their knowledge every task, and he demonstrates how providing this data improves the accuracy and efficiency of code generation in tools like Claude Code.

This talk examines the growing performance gap between GPU compute and network interconnects, arguing that standard communication libraries like NCCL are no longer sufficient for modern, fine-grained AI workloads. The speaker introduces ParallelKittens as a primitive-based approach to kernel optimization and presents ParallelKernelBench, a benchmark evaluating how well frontier LLMs can generate optimized CUDA kernels that leverage NVLink.

This is a wide-ranging interview with Mike Krieger about his transition from CPO to individual contributor at Anthropic Labs. He discusses the shift toward "unreasonable" AI-assisted workflows—such as porting massive codebases over a weekend—and how his team at Anthropic structures rapid, two-week "persevere or pivot" cycles to manage high-velocity development.

This talk breaks down the shift from brittle, browser-automating agents to standardized commerce protocols like MCP, ACP, and UCP. The speaker explains why merchants are moving toward structured product feeds and delegated payment mandates rather than letting agents scrape websites, using a live demo to illustrate the state transitions required for reliable, autonomous checkout.

This is a conversational breakdown from the a16z partners who backed Cursor. They discuss the startup's early strategic bets—specifically why they chose to fork VS Code rather than build a plugin—and how the founders maintained product focus while ignoring conventional advice from investors and competitors.

This talk explains how to optimize agentic LLM workloads by moving beyond standard inference benchmarks, which ignore the high cache hit rates and volatile token ratios typical of multi-turn sessions. The speakers detail two architectural levers: KV cache-aware routing to maximize locality, and LLM-D’s prefill-decode disaggregation to prevent long prompts from stalling token generation.

This is a high-level conceptual overview of why public leaderboard scores often fail to predict production performance. The video categorizes evaluation into two buckets—model accuracy (using benchmarks like MMLU or LLM-as-a-judge) and system performance (latency and throughput)—and explains why you must tailor your testing to your specific workload's token distribution.

This video provides a technical breakdown of the Gemini Live API, explaining how to manage bidirectional audio streaming, voice activity detection, and tool calling via WebSockets. It is a straightforward walkthrough of the core loop—open, send, receive, play—using the provided code to demonstrate how to build a responsive voice agent from scratch.

This video is a 90-minute workshop recording that walks through three specific labs for using AI agents on Google Kubernetes Engine (GKE). The presenters demonstrate how to use the Kubernetes-sigs Agent Sandbox for automated testing, troubleshoot infrastructure using Gemini with the Model Context Protocol, and build a knowledge graph pipeline in BigQuery.

This is a technical overview of four methods for moving JAX models from notebooks to production environments: using `jax.jit` for Python services, AOT compilation for predictable latency, `jax.export` for portable artifacts, and `jax2tf` for integration with TensorFlow-based serving stacks.

This is the third installment of a JAX on NVIDIA GPUs crash course, focusing on how to distribute training workloads using JAX's sharding primitives like `Mesh`, `PartitionSpec`, and `NamedSharding`. It provides a practical look at scaling a transformer model across multiple devices while managing state with Flax NNX and Orbax.

This is the second installment of a JAX on NVIDIA GPUs Crash Course, focusing on the mechanics of writing efficient training loops. It covers standard practices like keeping operations on-device, using `jax.jit` effectively, and replacing naive attention implementations with optimized `jax.nn.dot_product_attention` calls.

This is a technical primer on debugging JAX performance on NVIDIA GPUs. The speakers walk through a checklist for identifying common pitfalls, specifically focusing on verifying device visibility, managing XLA compilation triggers, avoiding host-to-device data transfers, and ensuring accurate timing for asynchronous operations.

This talk argues that developer relations isn't dying, but shifting focus from human-only engagement to "agent advocacy." The speaker shares data from CodeScaleBench, demonstrating how to instrument and optimize your tools for AI agents by treating them as first-class users who evaluate software based on latency, token efficiency, and clear documentation.

Justin Joyce explains how Cloudflare uses a three-pillar framework—scaling analysis, pushing insights, and agentic self-service—to bridge the gap between expert and ramping sales reps. The talk focuses on using "skill files" to let non-technical staff query data and deploying a multi-agent pipeline to automate weekly go-to-market reporting.