Topic

Build Engineering

All digests tagged Build Engineering

Training Agents 4: From reward functions to environments. thumbnail

· 1:13:40

Training Agents 4: From reward functions to environments.

This session details the evolution of agent training from simple functional reward signals to complex, stateful environments. The core concept is the `reset()/step()` contract, which allows agents to interact with a simulated world (the environment) over a sequence of actions. The discussion covers the OpenM framework, which standardizes environment definition, and its integration with TRL (Transformer Reinforcement Learning) using isolated compute environments like Hugging Face sandboxes. This enables training sophisticated agents, such as coding agents (OpenCode), on complex, multi-step tasks while maintaining reproducibility and isolation.

Key takeaways

  1. The Shift to Stateful Environments 1:42

    For agents performing sequences of actions (e.g., tool calls, file edits), the reward signal must come from the environment's state after an action, rather than being a simple Python function evaluated once. This requires adopting the standard `reset()/step()` contract, moving from sparse signals to continuous interaction loops.

  2. The OpenM Ecosystem 5:30

    OpenM provides a standardized, containerized way to define any task as an environment. It packages the task, the runtime (compute backend), and the grading components (verifiers, rewards) into a single, shareable unit that can be deployed on various platforms (e.g., Hugging Face Spaces, Kubernetes).

  3. Advanced Agentic Training Loops 9:10

    Training can be managed by two models: the 'White Box' (where the training framework owns the loop) and the 'Black Box' (where the agent/harness owns the loop). The latter requires a 'capture proxy' to intercept agent calls and send the resulting rollout graph back to the trainer for policy updates.

  4. Reproducibility and Isolation 7:30

    Environments are designed to be self-contained applications, often deployed in isolated compute environments (like HF sandboxes). This ensures that training runs are reproducible and prevents the agent from accessing or manipulating the verifiers or task description to 'hack' the reward signal.

Watch on YouTube Full article

One Designer + AI. Hundreds of Deliverables. — Vincent Wendy, AI Engineer thumbnail

· 16:48

One Designer + AI. Hundreds of Deliverables. — Vincent Wendy, AI Engineer

This talk details how one designer managed the massive scale of deliverables (signage, stickers, landing pages, etc.) for a large conference (7,000 attendees, 140+ sponsors, 300+ speakers). The solution involves implementing a structured design system and automating workflows using AI agents (like Devin) and tools like Figma. The core methodology emphasizes shifting from manual, linear processes to highly automated, validated pipelines to solve the 'scale problem.'

Key takeaways

  1. The Five Pillars of Scaling Design 0:04

    To manage massive deliverables, the process must focus on: 1) Building a solid foundation (design system, typography, components); 2) Making designs reusable; 3) Automating workflows; 4) Validating output; and 5) Removing friction. (4:45)

  2. AI Agents for Automation 0:09

    AI agents (e.g., Devin) are used to automate complex tasks, such as generating speaker announcement graphics and trading cards for 300+ speakers, or pulling live schedule data and exporting it as PNGs. (9:16)

  3. Systemic QA and Validation 0:13

    AI can be used for visual quality assurance (QA), such as checking 140+ sponsor logos on a banner for missing assets or detecting visual inconsistencies on merchandise. (13:15)

  4. Thinking as a User 0:14

    The most critical shift is to think like an end-user (attendee) rather than a designer, focusing on handling exceptions and ensuring all elements (wayfinding, schedules) are interconnected. (14:21)

Watch on YouTube Full article

Generative UI... in Python? — Jeremiah Lowin, Prefect thumbnail

· 17:38

Generative UI... in Python? — Jeremiah Lowin, Prefect

This talk introduces Prefect, a Python DSL designed to solve the challenge of delivering rich, interactive UIs within the MCP (Messaging/Communication Protocol) ecosystem. While MCP apps allow tools to bypass the agent and render full HTML/CSS/JS interfaces, the primary user base (Python engineers in enterprises) needed a way to build these UIs without writing complex frontend code. Prefect achieves this by allowing developers to compose UIs using Python context managers and classes, which are then serialized into a JSON protocol and rendered by a React app. A key optimization is streaming the Python code itself over the wire and executing it in a sandbox, resulting in a 70% reduction in size compared to streaming the JSON representation.

Key takeaways

  1. MCP Apps and Agent Bypass

    MCP apps are an extension of the MCP protocol that allows tool results to bypass the agent and be delivered directly to the user as a full UI (HTML, CSS, JavaScript), enabling rich, interactive experiences.

  2. The Prefect Solution 9:03

    Prefect is a Python DSL that allows developers to compose UIs by nesting components using context managers, avoiding the need to write traditional frontend code.

  3. The Core Pipeline 10:37

    The process involves using a Python DSL to build a declarative representation, which is serialized into a JSON protocol. This JSON is then rendered by a React app hosted as the MCP app.

  4. Efficiency Improvement 16:40

    The system was optimized to stream the Python representation of the UI over the wire and execute it in a sandbox, which was found to be approximately 70% smaller and more efficient than streaming the full JSON protocol.

Watch on YouTube Full article

Baz, Docker & Meta on Verifying Agent Code thumbnail

· 10:14

Baz, Docker & Meta on Verifying Agent Code

The session discusses the critical limitation of current AI coding agents: while they excel at generating code, they often fail at verifying that the code meets complex specifications. Speakers from Baz, Docker, Meta, and Christopher Batey presented advanced strategies—such as using real systems as test oracles, implementing anti-test slop initiatives, and elevating human review to Architectural Decision Records (ADRs)—to ensure reliability and maintain system integrity when integrating AI-generated code.

Key takeaways

  1. Verification is the Hard Part

    The primary challenge with coding agents is not writing code, but proving that the generated code accurately implements the required specification. Agents are optimized for feature generation, not full spec extraction or verification.

  2. Specifying Bugs, Not Features

    Baz demonstrated that providing explicit evidence of a bug (e.g., a screen recording of an overlapping button) is far more effective than general specs, as agents may fail to replicate specific, subtle behavioral constraints.

  3. Test Oracles Over 100% Coverage

    Attempting to achieve 100% test coverage is inefficient. Instead, pointing tests at a real, stable system (a 'test oracle,' like S3) and running a limited set of critical tests can effectively lock down behavior and validate system interactions.

  4. Anti Test Slop Initiative

    Meta implemented an anti test slop initiative, using a separate AI tool to judge the quality and necessity of AI-generated tests, thereby reducing CI overhead from useless or redundant tests.

  5. Elevating Human Review to ADRs

    When reviewing large pull requests (e.g., 7,000 lines), human review must move earlier into the process. Architectural Decision Records (ADRs) should capture system-level decisions, allowing agents to check implementations against a structured, human-reviewed architectural baseline.

Watch on YouTube Full article

MCP Apps: Give the Model Data, Give the User a UI — Dustin Mihalik, Indeed thumbnail

· 15:34

MCP Apps: Give the Model Data, Give the User a UI — Dustin Mihalik, Indeed

This talk details the architectural challenges of building Model-Composable Platform (MCP) applications for large language models (LLMs) like Claude and ChatGPT. The core thesis is that for a UI widget to function effectively, it must be treated as a data layer, not just a visual display. The speaker outlines three critical rules for developers: all displayed information must be provided as data to the model; the tool description must explicitly state that a UI exists; and, most importantly, data processing must be strictly separated from UI rendering to maintain model context and reasoning capability.

Key takeaways

  1. Data-First Design Principle

    When building MCP apps, developers must focus on defining the data the model needs to process before considering the UI. The UI should be viewed as a side effect or result of the model exploring the underlying data.

  2. Rule 1: Show the Model Everything 5:13

    Any information displayed to the user via the UI must also be provided as structured data to the model. Failing to do so creates a 'black box' that prevents the model from answering follow-up questions about the displayed content.

  3. Rule 2: Declare the UI in the Description 8:26

    The tool description must explicitly state that a UI exists. Otherwise, the model will attempt to narrate the results underneath the widget, leading to redundant and confusing output.

  4. Rule 3: Separate Data Processing from UI Rendering 13:39

    This rule supersedes the others. The architecture must split the job into two distinct tools: one for pure data retrieval (e.g., `search_jobs`) and a separate, dedicated tool for rendering the results (e.g., `render_jobs`). This allows the model to perform complex data exploration without being limited by the UI's single call.

Watch on YouTube Full article

Your agents lack context: Here's how to fix "You're absolutely right!" — Brandon Waselnuk, Unblocked thumbnail

· 14:09

Your agents lack context: Here's how to fix "You're absolutely right!" — Brandon Waselnuk, Unblocked

AI agents require more than just access to information; they need a 'context engine' to achieve true understanding of a company's operations, business logic, and historical decisions. The talk details how agents fail when they lack deep, organizational context, leading to wasted tokens and time. The solution involves building a context engine that ingests data from disparate sources (e.g., ticketing systems, code repos) and provides structured, conflict-resolved context to the model in a token-optimized manner.

Key takeaways

  1. The Context Gap

    AI-generated code must feel like it was written by a long-term team member, which requires deep operational context that current agents lack. This gap compounds as agents scale from simple tab completion to background processes.

  2. Failure Modes of Context 7:00

    Common approaches like the 'curated context trap' (where documentation rots) and the 'MCP plateau' (where agents suffer from satisfaction of search bias) fail because access to information is not the same as understanding it.

  3. The Role of the Context Engine 9:12

    A proper context engine must perform conflict resolution (e.g., resolving conflicting architecture diagrams vs. Slack messages), respect permissions (OAuth/SSO), and deliver context in a token-optimized way.

  4. Efficiency Gains 13:00

    Implementing a context engine can lead to significant efficiency gains, demonstrated by a reduction from 21 million to 10.8 million tokens and a two-hour reduction in wall-clock time for the same task.

Watch on YouTube Full article

Agentic Sites: Building Hyper Personalized Websites — Carlos Sanchez, Adobe thumbnail

· 20:43

Agentic Sites: Building Hyper Personalized Websites — Carlos Sanchez, Adobe

The presentation details 'Agentic Sites,' a system for building hyper-personalized websites that adapts content in real time based on user intent and browsing behavior. Instead of generating entire pages, the architecture focuses on customizing specific content blocks (e.g., hero sections, product lists) while grounding all generated content within the site's existing corpus to maintain strict brand guidelines. Key technical advancements include continuous model evaluation across multiple providers for both accuracy and speed, achieving impressive generation latencies as low as 1.1 seconds.

Key takeaways

  1. Hyper-Personalization (Audience of One)

    The goal is to personalize pages in real time based on the user's intent or actions, moving beyond one-size-fits-all web experiences. This drives higher engagement and conversions.

  2. Block-Level Personalization 3:40

    Personalization occurs at the block level (e.g., hero card, product list) rather than generating entire pages, which is crucial for adhering to strict brand guidelines and preventing hallucinations.

  3. Speed is Critical for Conversion 10:58

    The system emphasizes speed, noting that a page generation time of 1.1 seconds was significantly faster than the runner-up's 4.6 seconds, demonstrating that low latency is critical to user experience and conversion rates.

Watch on YouTube Full article

AITX Austin Hackathon Winners Spotlight thumbnail

· 36:43

AITX Austin Hackathon Winners Spotlight

This technical spotlight details two winning autonomous agent applications from the AITX Hackathon: MasteryWrite and 8kEdu. Both projects demonstrate advanced capabilities beyond simple chat, focusing on taking real-world action in educational technology (EdTech). Key architectural takeaways include using specialized frameworks like NemoClaw/OpenShell to enforce policies around student PII data, implementing continuous self-improvement loops for assessment grading, and leveraging Visual Language Models (VLMs) to transform video lectures into interactive learning widgets.

Key takeaways

  1. MasteryWrite: Autonomous Assessment Engine 2:00

    This agent scores student essays against a rubric, explains its reasoning, and uses an autonomous evaluation loop to improve its own grading criteria over time. The system is designed to handle complex educational assessment while maintaining strict policies around student PII data.

  2. 8kEdu: Interactive Video Learning 5:05

    The agent transforms YouTube lectures into interactive learning experiences. Instead of relying on the entire transcript, it focuses on specific video frames (e.g., a matrix calculation) to generate editable widgets (charts, notebooks), allowing users to learn concepts from multiple sources and build recursive learning graphs.

  3. Local Model Deployment for Edge Cases 7:50

    The teams highlighted the utility of running models locally (e.g., using DGX Spark) to manage costs, ensure privacy, and run complex video-based inferences without constant reliance on external APIs.

Watch on YouTube Full article

How Anthropic Builds: Lessons from Labs — Mike Krieger, Anthropic thumbnail

· 26:11

How Anthropic Builds: Lessons from Labs — Mike Krieger, Anthropic

Mike Krieger discusses the evolution of building with AI models, emphasizing that ambition requires being 'unreasonable' in tool usage and process design. He details advanced development workflows—such as porting large codebases (e.g., Python to TypeScript) over a weekend using LLMs—and outlines modern organizational structures for research labs (like Anthropic's), which prioritize rapid iteration through 'persevere or pivot' cycles rather than rigid project management. Key technical shifts include moving from task delegation to expressing end-state goals, and utilizing advanced features like tagging for multi-agent, proactive code development.

Key takeaways

  1. Be Unreasonable in AI Usage 4:15

    The first generation of AI products often constrained access to tools and degrees of freedom. To maximize potential, users must be 'unreasonable' in their prompts, moving beyond simple task delegation to defining the desired end state.

  2. The Importance of Intent Over Code Lines 17:17

    In large codebases (e.g., 2,000 line PRs), the bottleneck is no longer review time but human comprehension. The trend is shifting toward sharing 'Claude code artifacts' that explicitly lay out intent, trade-offs, and rationale alongside the code.

  3. Labs Structure for Rapid Iteration 19:13

    Anthropic Labs operates on a two-week 'persevere or pivot' cycle. Teams are assembled around 'bets,' and the structure deliberately avoids tying people to specific projects, allowing for quick disbandment and reassembly.

  4. Scaling Requires Pre-Measurement 23:50

    Drawing from Instagram's scaling experience, it is crucial to pre-measure everything that might be needed (metrics) and implement thoughtful knobs and feature flags for dynamic runtime configuration.

Watch on YouTube Full article

The Missing Layer in Agentic AI — Giedrius Šteimantas, Oxylabs thumbnail

· 15:04

The Missing Layer in Agentic AI — Giedrius Šteimantas, Oxylabs

The video addresses a critical gap in agentic AI: the lack of robust infrastructure for interacting with the open web. The speaker argues that relying solely on large language models (LLMs) or general browser automation is inefficient, expensive, and unreliable. By applying principles from professional web scraping—specifically prioritizing cost control, validating content before processing, and using a browser only when absolutely necessary—the agent's performance can be dramatically improved across all stages of the purchase workflow.

Key takeaways

  1. The Core Problem in Agentic AI 13:55

    Many agents fail or waste resources because they assume an HTTP 200 status code means valid content. Feeding LLMs large HTML blocks containing CAPTCHAs or non-product data leads to wasted tokens (e.g., wasting 70% of tokens when only three out of ten pages are valid).

  2. Discovery Stage Optimization 9:50

    Instead of using a browser with a predefined list of retailers, the agent should use a dedicated search API. This approach returns compact JSON (<2,000 tokens), is fast (<700ms), and allows the agent to fan out queries across many popular search engines.

  3. Decision Stage Optimization

    The decision stage can be optimized by replacing browser scraping with a dedicated scraper API. This ensures only valid content is returned, fails loudly (with explicit errors on blocks), supports markdown, and allows parallel requests while billing only for successful results ('No cure, no pay').

  4. Checkout Stage Enhancement

    Since the checkout process requires highly dynamic interaction, a browser is necessary. The solution involves hardening the agent using Playwright MCP combined with an Oxylabs headless browser that provides stealth, residential proxy support, and geolocation capabilities.

Watch on YouTube Full article

Intelligence EXPLOSION: Harness Engineering with Pi Agent, Deepseek, and Gemini thumbnail

· 28:05

Intelligence EXPLOSION: Harness Engineering with Pi Agent, Deepseek, and Gemini

The video addresses the current 'Intelligence Explosion' in Large Language Models (LLMs), noting rapid model releases and aggressive pricing wars. The core thesis is that modern agentic engineering requires moving beyond selecting a single best-in-class model; instead, engineers must build flexible systems to combine compute from multiple models (e.g., Gemini 3.7 Flash, Deepseek V4 Pro, Claude Fable 5) to achieve superior performance, speed, and cost efficiency. The speaker demonstrates three advanced multi-agent orchestration patterns—Opinion, Debate, and Collaborate—using a custom Fusion Harness V2.

Key takeaways

  1. The Principle of Flexible Systems 2:00

    In an era of rapid technological change, the most flexible system wins. Engineers should focus on combining compute rather than selecting a single model (Combine compute, don't select compute).

  2. Multi-Agent Orchestration Patterns 7:10

    Three advanced patterns are demonstrated for leveraging multiple LLMs: **Opinion** (fire one prompt to N models for diverse perspectives); **Debate** (agents argue a claim across multiple rounds, sharing refutations and positions); and **Collaborate** (models propose plans which an 'architect agent' merges into a structured task list with dependencies).

  3. Cost-Performance Analysis 10:20

    While state-of-the-art models like Claude Fable 5 are powerful, they can be vastly more expensive than 'A tier' workhorse compute (e.g., Gemini 3.7 Flash or Deepseek V4 Pro), offering better effective agent hour per token cost.

Watch on YouTube Full article

How AI Coding Agents Understand Your Codebase & Developer Tools thumbnail

· 6:54

How AI Coding Agents Understand Your Codebase & Developer Tools

While AI coding agents excel at generating fast, syntactically correct code, their utility in production environments hinges on 'understanding' rather than just speed. The core argument emphasizes that good code must not only run but also fit the existing architectural patterns and rules of a codebase. To improve, AI tools must demonstrate deep repository awareness, respect established architectural boundaries (like service layers), and adopt a structured workflow: Read $ ightarrow$ Plan $ ightarrow$ Patch $ ightarrow$ Verify $ ightarrow$ Review.

Key takeaways

  1. Codebase Integrity Over Speed

    AI agents often create 'fast chaos' by making technically correct but architecturally inappropriate changes, such as bypassing established service layers (e.g., for logging or permissions).

  2. The Need for Contextual Awareness 2:05

    Effective AI requires more than just the file being edited; it needs repository awareness to understand API contracts, type definitions, and existing utilities without dumping irrelevant files into the prompt.

  3. Structured Workflow is Essential 5:40

    AI tools should not immediately patch. The ideal workflow involves making reasoning visible (planning), allowing developers to review assumptions before any code changes are made.

Watch on YouTube Full article

Inside 847 Production Clinical AI Notes — Sebastian Fox, Composo thumbnail

· 19:48

Inside 847 Production Clinical AI Notes — Sebastian Fox, Composo

This talk addresses the critical challenge of evaluating high-stakes AI systems, particularly ambient scribes in healthcare, where dangerous failures often manifest as subtle omissions or hallucinations rather than obvious errors. The speaker argues that traditional verification methods (like fixed rubrics or simple difference checks) fail because the 'standard of good' is tacit, contextual, and constantly evolving. A proposed solution involves building a continuous evaluation loop: Discovering failure modes from real-world outputs, capturing expert judgment on these modes, and calibrating every new output against this accumulated, case-specific context rather than a static rule set.

Key takeaways

  1. High-Stakes Failure Modes 2:09

    In clinical notes, the most dangerous failures are often subtle omissions (e.g., missing jaw pain symptoms) or hallucinations that look technically correct but are factually wrong. In large studies, nearly 1 in 20 notes carried an error serious enough to cause significant harm [1:29].

  2. Limitations of Current AI Evaluation 11:43

    Verification is only easy for the 'easy half' (e.g., spotting differences between transcript and note). The hard part is determining which difference—an omission, change, or addition—actually matters in context [7:03]. This judgment is tacit, contextual, and moving.

  3. The Continuous Evaluation Loop

    To overcome the limitations of static rubrics, the recommended approach is a continuous loop: 1) Discover failure modes from real outputs (building a 'failure mode ontology'), 2) Capture expert judgment on these modes, and 3) Calibrate every output against this accumulated, case-specific context, rather than relying on fixed weights or prompts [13:49].

Watch on YouTube Full article

Building Agents Is Trivial Now, Context Is the Next Frontier — Jeff Ng, Unblocked thumbnail

· 13:22

Building Agents Is Trivial Now, Context Is the Next Frontier — Jeff Ng, Unblocked

While cloud primitives and frameworks have made defining AI agents trivial—reducing complexity from requiring dedicated systems for checkpointing, sandboxing, and observability—the primary failure point remains missing organizational context. The speaker argues that simple access layers (like Multiple Connectors/MCPs) are insufficient because 'access is not understanding.' A Context Engine solves this by connecting disparate data sources (docs, code, tickets, conversations) to provide a synthesized, task-relevant understanding that agents can act upon, preventing critical errors and outages.

Key takeaways

  1. Agent Development Complexity Has Decreased

    Six months ago, building an agent required significant effort to solve infrastructure problems like state persistence (checkpointing), isolated sandboxes, and observability. Modern cloud primitives (e.g., Cloudflare, Vercel) have absorbed this 'plumbing,' simplifying agent definition to selecting a model, instructions, tools, and sandbox location.

  2. The Context Gap is the New Bottleneck 7:01

    Agents struggle with institutional knowledge—the decisions, failures, and postmortems stored across different systems (Slack threads, documentation). An agent lacking this full picture can make confidently wrong recommendations, potentially causing outages.

  3. Context Engines Provide Synthesized Understanding

    A Context Engine goes beyond simple data access by building a model of the organization. It reconciles conflicting results across multiple datasets (docs, code, tickets, conversations) and delivers a synthesized understanding that an agent can act on, rather than just raw documents.

Watch on YouTube Full article

Your Fine-Tuned Model Is Tech Debt: A 50x ROI House of Cards — Dan Bjornn, Lease End thumbnail

· 16:39

Your Fine-Tuned Model Is Tech Debt: A 50x ROI House of Cards — Dan Bjornn, Lease End

The video argues that relying heavily on fine-tuned LLMs for production applications can create 'calcification tax'—a form of technical debt characterized by rigid architecture and complex maintenance cycles. The speaker details migrating from a fine-tuning approach to an agentic framework built on skills, prompts, and context. This shift drastically reduced the time required to deploy fixes (from weeks/days to under an hour), improved accuracy, maintained model agnosticism, and ultimately lowered total operational costs.

Key takeaways

  1. The Calcification Tax 10:04

    Fine-tuning creates technical debt by locking systems into specific models and architectures. The complexity of retraining—which involves gathering examples, synthesizing data, manual validation, and iterative fixing—is costly and slow (up to a week per cycle).

  2. Agentic Frameworks Over Fine-Tuning

    The rebuild swapped the fine-tuned model for skills, prompts, and context on a model agnostic framework. This allowed fixes to ship by simply uploading files to an S3 bucket.

  3. Cost vs. Accuracy Tradeoff

    While the new agentic approach increased cost per message (due to using better models), overall total cost decreased significantly because the time spent on maintenance and retraining was drastically reduced.

Watch on YouTube Full article

How I automate my own job at Hugging Face using agents — Niels Rogge, Hugging Face thumbnail

· 20:37

How I automate my own job at Hugging Face using agents — Niels Rogge, Hugging Face

Niels Rogge details how he automated his role at Hugging Face—the 'Google Drive to the hub' team—which focuses on improving the discoverability of machine learning artifacts. He built two systems: an initial deterministic workflow for outreach (using cron jobs and LLM APIs) and a subsequent fully autonomous agent loop for follow-up actions. The architecture leverages modern tooling like Modal, Bash CLI skills, and advanced models (e.g., GLM 5.2) to scale the process of identifying missing artifacts and prompting researchers to publish them on Hugging Face.

Key takeaways

  1. The Problem: Artifact Discoverability

    ML weights and datasets are often published on third-party services (Google Drive, Zenodo) rather than the centralized platform (Hugging Face), hindering discoverability. The goal is to automate outreach to authors.

  2. Initial Automation: Deterministic Workflow 11:43

    The first phase used a deterministic workflow, running as a nightly cron job on GitHub Actions. This approach utilized LLM APIs in predefined steps without an agent framework, offering high predictability and control.

  3. Advanced Automation: Autonomous Agent Loop 15:36

    The follow-up process was automated using a fully autonomous agent loop (e.g., leveraging the Claude agents SDK). This flexible approach allows the agent to use tools and skills, such as Bash and the Hugging Face CLI, to interact with GitHub issues.

Watch on YouTube Full article

How to build an AI-Native Health Company — Dan Feng, Maven Clinic thumbnail

· 17:19

How to build an AI-Native Health Company — Dan Feng, Maven Clinic

The transition to an AI-native company requires a fundamental shift in process and culture, moving away from lengthy planning cycles toward rapid, iterative development. While building software is now fast (minutes), the expense lies in arguing requirements. Build engineers must adapt by adopting short-cycle planning (2–4 weeks) and implementing rigorous, multi-layered testing strategies to manage AI-specific risks like hallucination. Key process changes include limiting Pull Request (PR) size (capped near 500 lines) and running integration tests multiple times to ensure reliability.

Key takeaways

  1. Shift Planning Focus 10:32

    Instead of spending weeks or months finalizing requirements, focus on delivering value in the next two to four weeks. Long-term plans (1 year) should only serve as directional inspiration, not rigid commitments.

  2. Redefining Code Review

    Due to increased code output from AI tools, traditional code review must change. Engineers can self-certify simple PRs, and large features should be stacked into multiple smaller PRs (capped near 500 lines) to maintain meaningful review quality.

  3. AI Reliability Testing

    For GenAI solutions, failure modes must be categorized (tolerable vs. not acceptable). Critical processes require consensus among multiple models (e.g., using different LLMs to review the same receipt) and running integration tests many times, rather than just once.

Watch on YouTube Full article

Guardrails First: Engineering Member-Facing Health AI — Rashi Agrawal, Hinge Health thumbnail

· 21:49

Guardrails First: Engineering Member-Facing Health AI — Rashi Agrawal, Hinge Health

The talk outlines critical architectural guardrails necessary for deploying member-facing healthcare AI. The core argument is that most safety failures are not model flaws but architectural decisions made before any tokens are generated. Safety must be built into three non-negotiable foundations: protecting PHI at the pipeline boundary, ensuring deterministic code layers handle high-stakes decisions (like emergency routing), and implementing continuous monitoring using multiple signal sources.

Key takeaways

  1. Architectural Failures vs. Model Failures

    Most AI safety failures in healthcare are architectural decisions, not model failures. The system must be designed to prevent failure at the structural level before considering prompt engineering.

  2. Three Non-Negotiable Foundations 3:55

    1) Constraint is the architecture (not just policy). 2) Deterministic rules must belong above the model layer, as anything that can never be wrong cannot be left to probability. 3) Safety must be a continuous evaluation layer, not a one-time gate.

  3. PHI Protection at Ingestion 8:47

    Instead of treating PHI redaction as a runtime problem (on the dashboard), the architecture must strip PHI at the pipeline boundary during ingestion, ensuring it is never stored in the data lake.

  4. Deterministic Code Layer for High Stakes 13:35

    Irreversible decisions (e.g., emergency escalation to 911/988, intent routing) must be handled by a deterministic code layer that runs *before* the LLM processes the turn. The model should not get a vote on high-stakes calls.

  5. Decision Framework: Worst Case Wins

    When stakeholders disagree on a feature launch, severity must be set by the worst plausible outcome (the maximum potential harm), not the average case or current capacity. When unsure, default to the safer mistake.

Watch on YouTube Full article

JSON Schema 2020-12 and the Contract for Context | ​Ola Hungerford | MCP Release Party - Seattle thumbnail

· 16:08

JSON Schema 2020-12 and the Contract for Context | ​Ola Hungerford | MCP Release Party - Seattle

This talk details the critical evolution of the Model Context Protocol (MCP), emphasizing that the schema acts as the 'contract for context' between tools and LLMs. The major update is the adoption of JSON Schema 2020-12 for tool definitions, replacing previous limited subsets. This upgrade significantly enhances expressiveness in both input and output schemas, allowing developers to use advanced keywords (like `allOf` and conditional constraints) and enabling better pre-LLM validation.

Key takeaways

  1. Schema as Contract

    In MCP, the schema defines the contract for context—how a tool specifies what data it accepts and returns. This is crucial for reliable LLM interaction.

  2. Adoption of JSON Schema 2020-12 2:34

    MCP now conforms to JSON Schema 2020-12, aligning with the default dialect used by OpenAPI 3.1. This was achieved via SEP 2106 and expands support beyond previous limited subsets.

  3. Enhanced Input/Output Schemas 3:55

    Input schemas gain full JSON Schema 2020-12 support, allowing for complex conditional keywords (e.g., `allOf`). Output schemas no longer face the same restrictive limitations as before.

Watch on YouTube Full article

How to Kill the Code Review — Ankit Jain, Aviator thumbnail

· 16:26

How to Kill the Code Review — Ankit Jain, Aviator

The traditional code review process is failing due to increasing code churn and reliance on AI agents, leading reviewers to only skim results. The speaker argues that code review must shift its focus from verifying line-by-line correctness (semantic accuracy) to preserving crucial non-technical aspects like knowledge sharing, mentorship, and architectural alignment. The proposed solution involves capturing the entire development session's decisions (the 'intent'), converting these into formal acceptance criteria, building an AI Slop Registry of recurring feedback, and generating a verifiable test plan that serves as the new review surface.

Key takeaways

  1. The Code Review Crisis 2:07

    Code churn is high (861%), leading to increased bottlenecks at the review stage. Currently, over 30% of changes merge without any review, and even when AI reviews are used, human involvement often reduces to skimming rather than deep reading.

  2. Review Must Preserve Alignment 5:05

    Code review's most critical function is not just catching bugs (semantic accuracy), but facilitating knowledge sharing, mentorship, and architectural alignment. This 'alignment' aspect must survive the shift to automated development.

  3. The New Review Surface: Intent vs. Diff 12:38

    Instead of reviewing code diffs, the review surface should become a verification of 'intent' and 'evidence.' This is achieved by capturing user decisions from development sessions, converting them into acceptance criteria, and generating a test plan that runs against a live preview.

Watch on YouTube Full article