Topic

DevOps

All digests tagged DevOps

Dexter Horthy: Why We Stopped Trusting AI to Write the Plan thumbnail

· 56:12

Dexter Horthy: Why We Stopped Trusting AI to Write the Plan

The discussion explores the shift in software development from writing code to managing 'software factories' powered by AI agents. The central thesis is that while AI agents can automate much of the implementation, the primary value shifts to defining and codifying *intent* (specs) and *preferences* (taste). The speaker argues that the process of continuous improvement—building the factory itself—is more critical than the act of reviewing individual code pull requests. Human review, therefore, evolves from checking syntax to verifying high-level architectural intent and system constraints.

Key takeaways

  1. The Spec is the New Code 3:44

    The industry trend is moving toward treating specifications (specs) as the primary, verifiable, and executable artifact. This approach aims to capture the full intent of a feature, which can then be compiled into code, rather than relying on the code itself as the source of truth.

  2. Context Engineering and the 'Dumb Zone' 10:03

    Context engineering is crucial for effective agentic development. Early models exhibited a 'dumb zone' where performance degraded significantly when the context window exceeded a certain token count (e.g., 100,000 tokens), emphasizing the need for intentional context management.

  3. The Value of the Software Factory 28:23

    A 'software factory' is a system that automates the entire development lifecycle (planning, building, reviewing, rolling out). The goal is to shift focus from fixing individual bugs to continuously improving the factory's processes and skills, thereby increasing overall velocity.

  4. The Persistence of Human Review 53:52

    While AI is powerful, the speaker asserts that there will always be 'alpha in reviewing something.' Human review will shift from checking code correctness to verifying high-level architectural decisions, business logic, and unique organizational 'taste' that models cannot inherently replicate.

Watch on YouTube Full article

Netlify's Dana Lawson: 'We Ain't Precious No More' thumbnail

· 10:06

Netlify's Dana Lawson: 'We Ain't Precious No More'

The landscape of software development is shifting from developer-centric to builder-centric, driven by AI agents. While agents enable non-technical users (Product Managers, designers) to open pull requests (PRs) and build applications, this transition introduces new challenges. Agents can fail by missing crucial product or design context, even when passing automated CI checks. Successful adoption requires platforms to be designed for these diverse 'builders' and necessitates that Product Managers evolve into 'agent orchestrators' who define the system's boundaries and ensure proper human control planes.

Key takeaways

  1. Agent Failure Due to Context Loss 2:24

    An agent, despite having access to skills, CI requirements, and passing automated checks, can fail by using a generic component (e.g., a generic React button) instead of a specific, context-aware component that holds critical requirements like accessibility patterns. (Marc Sloan, 00:00:24)

  2. Non-Technical PR Merge Metrics 3:26

    Across hundreds of organizations, 74% of PRs opened by non-technical individuals get merged, and 84% of those merge without any developer needing to push follow-up commits. (Tammuz Dubnov, 00:03:26)

  3. The Builder Persona Shift 5:21

    The platform is no longer built solely for developers. The rise of agents means that anyone—therapists, students, small business owners—can build, making the builder persona far broader. (Dana Lawson, 00:05:41)

Watch on YouTube Full article

The Hidden 50% Drop in AI Agents Following Your Rules thumbnail

· 29:18

The Hidden 50% Drop in AI Agents Following Your Rules

The increasing complexity of multi-agent AI coding systems has led to a critical loss of control, evidenced by a reported 50% degradation in agents' adherence to static instruction files like `AGENTS.md` and `CLAUDE.md` [00:14:28]. The talk argues that traditional agile rituals are being replaced by structured, technical controls: detailed specifications (specs), automated verification steps, and advanced merge tactics (like merge queues). To maintain control, developers must move beyond plain text instructions and adopt structured rule sets, such as those used by CodeRabbit, which force adherence across different models.

Key takeaways

  1. 50% Drop in Agent Adherence 10:28

    Baz's data shows a severe, almost overnight, degradation in the usage of static instruction files (`AGENTS.md`, `CLAUDE.md`) by coding agents, suggesting that model releases can break steering capabilities [00:14:28].

  2. The Shift from Rituals to Structure 19:12

    The bottleneck in software development has shifted from human capacity (PR bottleneck) to system consistency. The process is now being governed by three technical pillars: detailed specs (written in Markdown or linked to issues), automated verification, and advanced merge tactics [00:19:32].

  3. Structured Rules Outlast Plain Files 24:20

    Structured rule sets (e.g., CodeRabbit's JSON rule set) are significantly more effective at forcing agent adherence than plain instruction files (`CLAUDE.md`) because they provide a stronger, more consistent constraint across models [00:23:40].

  4. Long-Horizon Tasks are More Consistent 26:30

    While short tasks show high variability, long-horizon code sweeps demonstrate a larger likelihood of agents adhering to correct instructions due to the sheer number of turns and iterations, though users currently prefer faster, shorter loops [00:23:40].

Watch on YouTube Full article

How to set up Herdr for multi-agent coding (full guide) thumbnail

· 28:40

How to set up Herdr for multi-agent coding (full guide)

This guide details setting up Herder, a tool described as the 'meta' for multi-agent coding, allowing developers to manage and orchestrate multiple AI coding agents and projects within a persistent terminal environment. The setup emphasizes creating isolated 'spaces' for different projects, integrating various AI model harnesses (e.g., Grock, Codeex, Claude), and optimizing the workflow using advanced CLI tools like zoxide, Neovim, and Lazygit. The core benefit is achieving a single, persistent interface for complex, multi-agent development cycles, minimizing context switching and session loss.

Key takeaways

  1. Persistent Session Management

    Herder allows developers to maintain persistent terminal sessions (spaces) that survive terminal closures, similar to T-Mix, ensuring continuous work history and state for CLI-based coding tools.

  2. Agent Orchestration and Delegation

    The Herder skill enables agents to communicate and delegate tasks across different sessions and models (e.g., using Claude to review code started by Grock), providing full transparency into the multi-agent workflow.

  3. Customization via config.toml 20:32

    All aspects of Herder—including colors, spacing, and keyboard shortcuts—can be customized using the `config.toml` file, which can even be configured by an AI agent.

  4. Optimizing Navigation and Workflow

    Integrating tools like zoxide for faster folder navigation and Lazygit for Git status review allows the entire development process to be contained within a single, optimized terminal interface.

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

NVIDIA, Docker & Hud on Agents in Production thumbnail

· 10:04

NVIDIA, Docker & Hud on Agents in Production

The discussion explores the operational challenges of deploying AI agents in a production environment (24/7 operation). Key insights emphasize that successful agent deployment requires shifting focus from root cause analysis to comprehensive context and observability. Speakers covered topics including using agents with combined data sources (Elastic logs + ServiceNow), redesigning automated fixes for human consumption, optimizing GPU utilization during tool calls, and leveraging AI-built tracing frameworks for debugging rare bugs.

Key takeaways

  1. Context over Root Cause Analysis 2:10

    When agents are running 24/7 in production, the most critical resource is context—understanding what changed yesterday and the relationships between services. This proactive data knowledge is more valuable than traditional root cause analysis.

  2. Automated Fixes Must Convince Humans 5:40

    Simply automating investigations and opening pull requests (PRs) for high-impact fixes is insufficient, as developers often ignore them. The output must be rebuilt to convince the human developer of its value and priority.

  3. GPU Idle Time During Tool Calls 7:10

    A counterintuitive finding is that when an agent makes a tool call, the GPU sits idle. Properly accounting for this CPU-intensive period allows users to serve roughly twice as many users compared to benchmark predictions that ignore tool calls.

  4. AI-Built Tracing Frameworks 9:00

    For debugging rare bugs, the most useful investment is getting AI to build a tracing framework. Providing traces from an overnight run allows the agent to pinpoint the exact problem rather than guessing or failing to reproduce the issue.

Watch on YouTube Full article

GitHub Next & Tessl on the Self-Merging Repo thumbnail

· 10:36

GitHub Next & Tessl on the Self-Merging Repo

The discussion outlines the evolution of software development from traditional CI/CD to a new paradigm: Continuous AI. Speakers presented models where automated agents handle code improvements, testing, and merging (Paul Stack). Key shifts include viewing continuous improvement as a system-level problem rather than an individual productivity issue (Don Syme), prioritizing fixing the build system over fixing the code itself (Patrick Debois), and leveraging advanced AI tools for knowledge retrieval and proactive information gathering (Robert Overweg).

Key takeaways

  1. Continuous AI is the Third Pillar 0:20

    The development process requires three pillars: Continuous Integration (CI), Continuous Deployment (CD), and continuous AI, which focuses on automated code improvement in the repository.

  2. Agent-Driven Merging Process 2:33

    Advanced pipelines allow agents to open a pull request, pass multiple reviews/gates, push changes, and auto-merge upon successful completion. The UAT (User Acceptance Testing) gate remains critical for preventing regressions before end-user release.

  3. Focus on System Improvement 8:07

    The primary mistake is fixing the code when an agent fails; the correct approach is improving the system that produced the faulty code. This shifts focus from 'fix the code' to 'fix the system.'

  4. Knowledge Retrieval and Briefing 9:20

    AI agents can transform company knowledge into a searchable resource, allowing users to query complex information in plain language or receive daily briefings rather than managing a backlog.

Watch on YouTube Full article

850 PRs a Week: How Tessl Runs a Software Factory thumbnail

· 51:18

850 PRs a Week: How Tessl Runs a Software Factory

The video outlines the concept of a 'Software Factory'—a modern development paradigm where most work is managed by self-improving AI agents. This factory model progresses from defining foundational standards (Skills) to creating automated, iterative workflows (Loops), culminating in full automation. Key insights emphasize that success requires prioritizing context engineering and standardization over raw speed, as the primary gains are increased code quality and functional fungibility across teams.

Key takeaways

  1. The Factory's True Gains 11:57

    Increased capacity does not solely lead to feature velocity; two major benefits observed are an increase in overall code quality (e.g., fixing consistency, copy, and brand voice) and improved fungibility, allowing non-engineering teams (like GTM) to make high-leverage changes without waiting on support.

  2. Context Precedes Automation 13:56

    The core principle is that before automating a process, one must first define 'what correct looks like.' This context definition serves as the manual for operating the company and is critical for building resilient, scalable agents.

  3. Skills $\rightarrow$ Loops $\rightarrow$ Factory 6:10

    The factory model is a continuum: Skills are defined units of work or policies; Loops are automated skills that improve with each run (compounding gains); and the Factory is the system where most development effort shifts to maintaining and improving these loops.

  4. Enforcing Standards: Verifiers and Evals 27:20

    To ensure quality at scale, systems must implement verifiers (generating LLM-judge tools from skills) and evals. These mechanisms enforce standards in CI/CD pipelines, moving code review checks 'left' into the development process.

Watch on YouTube Full article

Don't Build Agents, Build Environments Instead thumbnail

· 27:19

Don't Build Agents, Build Environments Instead

The talk argues that the most critical challenge in building agentic workflows is not the agent itself, but the underlying environment (the 'background part'). Teams should focus on 'environmental engineering'—designing robust, fast, and persistent development environments ('dev boxes') rather than optimizing the agents. Key architectural shifts involve treating sessions as long-running, stateful processes that require sophisticated isolation between the control plane (planning) and the data plane (execution).

Key takeaways

  1. Focus on Environments, Not Agents

    The difficulty in background agent systems lies in the environment they operate within. The focus should be on building reliable 'dev boxes' that provide necessary resources beyond a bare sandbox.

  2. Jobs vs. Sessions 20:04

    Traditional CI/CD treats runs as stateless 'jobs.' Agents require long-running, resumable 'sessions' that must persist state (e.g., file system snapshots) and potentially outlive the initial machine runtime.

  3. Dev Boxes vs. Sandboxes 3:58

    A sandbox is bare; a 'dev box' must be rich enough to handle complex tasks (e.g., running local servers, taking screenshots, profiling on GPUs), requiring more than just basic Linux access.

  4. Architectural Separation 24:16

    To prevent failure, the system must separate the agent's planning logic (Control Plane) from the risky execution tools (Data Plane). The agent should issue remote calls to a dedicated sandbox rather than running tools collocated with its own process.

Watch on YouTube Full article

Stripe Paid $7.5 Billion For OpenRouter. You Are Living In The Age Of Startups. thumbnail

· 25:19

Stripe Paid $7.5 Billion For OpenRouter. You Are Living In The Age Of Startups.

Stripe's reported $7.5 billion acquisition of OpenRouter (a company valued at $1.3 billion in May) signals a fundamental shift toward the 'intelligence age.' The speaker argues that this massive investment reflects Stripe's belief that intelligence consumption is becoming a core economic flow, necessitating new infrastructure for agent-to-agent commerce. Key technical shifts include the rapid growth of token volume (doubling every 11 weeks), the rise of agents using APIs and command lines directly, and the need for protocols to manage payments, fraud, and routing across hundreds of AI models.

Key takeaways

  1. Stripe's Strategic Bet on Intelligence

    Stripe paid a reported $7.5 billion for OpenRouter, which provides developers one route to over 400 AI models from 80+ providers. This premium suggests Stripe views intelligence consumption as a critical economic flow requiring ownership of the underlying infrastructure.

  2. The New Moore's Law 6:15

    Token volume is cited as the new metric, with OpenRouter's weekly token volume having grown roughly 24,000x since August 2023 and doubling every 11 weeks. This rapid growth indicates that demand for AI services is outpacing traditional organizational absorption.

  3. The Agent-to-Agent Economy 18:05

    The shift involves agents becoming workers, buyers, and suppliers within a company. Stripe's infrastructure (e.g., Stripe Projects) supports this by handling payments, fraud, and billing for machine interactions, moving beyond the traditional human customer journey.

  4. Singularity as an Economic Event 7:45

    Stripe has set January 1, 2026, as the singularity date. This timing is linked to observed parabolic rises in new firm creation and the explosion of command-line usage by coding agents, suggesting a confluence of business formation and non-human actors entering the system.

Watch on YouTube Full article

Agentic SDLC at Uber — Uday Kiran Medisetty & Adam Huda, Uber thumbnail

· 18:26

Agentic SDLC at Uber — Uday Kiran Medisetty & Adam Huda, Uber

Uber has implemented a comprehensive 'Software Factory' powered by agentic AI to revolutionize its SDLC. Key infrastructure investments include a centralized Model Gateway for security and latency control, an MCP Gateway for token optimization, and a Context Graph that unifies knowledge across disparate systems. These building blocks enable autonomous agents (like Minion) to accelerate development from idea generation (via Cortana) through drafting PRs, validating changes in inner loops (e.g., comparing simulator screenshots against Figma specs), and managing maintenance tasks.

Key takeaways

  1. Agentic Adoption Metrics

    Over the last year, agentic AI led to more than 70% of Uber's Pull Requests (PRs) originating from local or cloud agents, resulting in double the lines of code per engineer year-over-year.

  2. Model Gateway Performance 2:06

    The Model Gateway handles all internal model calls through a single endpoint, ensuring PII redaction for over 20 types and running five specialized safety models under a strict 100 millisecond guardrail budget. It processes over 100 million requests daily across 800+ projects.

  3. Token Optimization 5:51

    The MCP Gateway, combined with projecting MCPS into CLI patterns and using Omni MCP, cut fleetwide token usage by more than 40%.

Watch on YouTube Full article

LangSmith Preview Builds: Test agent changes before production thumbnail

· 8:01

LangSmith Preview Builds: Test agent changes before production

LangSmith Preview Builds extend standard software development workflows to AI agents. By automatically creating a temporary deployment for every GitHub Pull Request (PR), teams can test agent changes and validate functionality in a production-like environment without impacting the main branch. This system ensures that agents are thoroughly tested on preview branches before being merged, while also guaranteeing automatic teardown of the temporary deployment upon PR merge.

Key takeaways

  1. Preview Builds for Agents

    LangSmith automatically generates a temporary deployment for every pull request, allowing teams to test agent changes safely before they reach production. This brings standard software development workflows (PR testing) to AI agents.

  2. Local Testing and Validation

    Agents can be tested locally using `langgraph dev`, which automatically opens LangSmith Studio for validation. Changes made in the local project are reflected in the preview deployment.

  3. Automated Revisioning

    The system supports continuous iteration: every new commit added to a PR triggers a new revision of the preview deployment, allowing for granular testing before final merge.

  4. Automatic Cleanup (DevEx)

    Once the pull request is successfully merged into the main branch, LangSmith automatically tears down and removes the temporary preview deployment, ensuring clean resource management.

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

Inside Kikimora: We Built a Dark Software Factory thumbnail

· 15:51

Inside Kikimora: We Built a Dark Software Factory

The presentation introduces the concept of a 'Dark Factory'—an autonomous software development model where processes run without constant human supervision. The speaker details how rapid advancements in coding agents have broken traditional bottlenecks built for slow software. This factory approach uses tools like Tessl Agent to automate workflows (e.g., taking an issue from Linear, solving it with an agent, and opening a GitHub PR that self-corrects until merged). The core shift is moving the engineer's value proposition from writing code to understanding complex systems and trusting autonomous results.

Key takeaways

  1. The Dark Factory Concept 1:41

    A dark factory involves building software in a highly autonomous way, where human supervision is minimized. It is modeled after manufacturing factories with no lights on (i.e., no humans inside).

  2. Bottleneck Breaking Point 3:23

    As coding agents increased speed, existing processes designed for slower development began to break down, necessitating a fundamental shift in how software was built.

  3. The Shift in Engineering Value 7:16

    The value of an engineer is shifting from the ability to write code (which agents can do) to understanding the system's architecture and interlocking technical/business constraints. Trusting autonomous results is the new challenge.

Watch on YouTube Full article

Inside Kikimora: We Built a Dark Software Factory thumbnail

· 15:51

Inside Kikimora: We Built a Dark Software Factory

The video details the concept of a 'Dark Factory'—an autonomous software development model where processes run without continuous human supervision. The shift was catalyzed by coding agents (like Claude Code) accelerating development speed, which exposed bottlenecks in traditional workflows. This led to building internal orchestrators (e.g., Kikimora, Night Shift) that automate tasks from issue creation (Linear) through code generation and PR management (GitHub), fundamentally changing the role of the engineer from primary coder to system architect and trust validator.

Key takeaways

  1. The Dark Factory Concept 2:05

    A dark factory is an autonomous software building process where no humans are required for supervision. The core workflow involves creating a Linear issue, which is then picked up by an autonomous agent that solves it and opens/manages a GitHub PR until merge.

  2. The Bottleneck Effect 3:23

    As coding agents increased development speed (starting around November), existing processes designed for slower software began to break down, forcing the company to adopt a fundamentally different, highly autonomous model.

  3. Shift in Engineering Value 11:20

    The value of an engineer shifts from writing code (which agents can do better) to understanding complex system constraints, business logic, and the overall interlocking technical architecture. Trust in the automated results becomes the critical skill.

Watch on YouTube Full article

Building Governed Agents: A Framework for Cost, Control and Compliance thumbnail

· 52:28

Building Governed Agents: A Framework for Cost, Control and Compliance

As autonomous agents scale in production environments, they introduce significant governance challenges related to cost control, data security, and regulatory compliance. This presentation outlines the necessity of implementing centralized runtime controls—such as an LLM Gateway—across the entire Agent Development Lifecycle (ADLC). Centralized governance is critical for managing unpredictable spend, ensuring reliability through fallbacks and rate limits, and maintaining consistent policy enforcement across diverse agent interactions (LLM calls, tool use, and inter-agent communication).

Key takeaways

  1. The Three Pillars of Agent Governance 5:40

    Production agents introduce three main pressure points: Cost (unpredictable spend from looping/context growth), Reliability (need for fallbacks and clear failure behavior), and Compliance (consistent policy enforcement required by regulated industries).

  2. Centralized Runtime Controls are Essential 8:30

    Governance must be implemented as a central infrastructure layer, rather than being bolted on application-by-application. This centralized approach manages interactions with external services (LLMs, tools) and ensures visibility across the entire system.

  3. Comprehensive Risk Management is Required 12:30

    Governance controls must cover four distinct interaction points: LLM calls (cost/data risk), Tool calls (unintended actions/permissioning), MCP calls (data leaving infrastructure), and Agent-to-Agent calls (identity and compounding errors).

  4. Compliance Requires Multi-Layered Guardrails 23:20

    For regulated industries, governance must address specific regulations like GDPR, CCPA, HIPAA, and the EU AI Act. This involves implementing guardrails for PII/secrets detection, role definition, and audit logging.

Watch on YouTube Full article

How I Tamed Claude - Emmz Rendle - NDC Copenhagen 2026 thumbnail

· 59:38

How I Tamed Claude - Emmz Rendle - NDC Copenhagen 2026

The talk details a structured methodology for leveraging advanced coding agents, particularly Claude, to achieve production-grade code generation and maintainability. The core principle is moving away from 'vibe coding' by implementing a spec-driven workflow that enforces separation of concerns among multiple specialized AI agents (Orchestrator, Worker, Reviewer). This process emphasizes defining clear requirements, maintaining an auditable development history, and managing context to ensure the final solution is robust and reliable.

Key takeaways

  1. Spec First, Code Second 12:04

    The workflow must begin with a detailed specification (the 'spec'), which acts as the source of truth for the entire project. The speaker recommends using OpenSpec's four phases: Explore $ ightarrow$ Propose $ ightarrow$ Apply $ ightarrow$ Archive [~10:35].

  2. Separation of Agent Powers 30:30

    The system must enforce a clear separation of duties among agents. The Worker writes code, the Reviewer validates it against the spec and design, and the Orchestrator manages commits and pushes; crucially, neither the Worker nor the Reviewer can approve or commit work [~18:30].

  3. Definition of Done (DoD) 40:15

    A rigorous Definition of Done is critical for preventing scope creep and ensuring quality. This includes mandatory checks like all tests being green, achieving good coverage, running `net format` twice, and completing the entire task group [~24:15].

  4. Context Management 52:05

    To prevent agents from becoming confused or hallucinating outdated information, context must be actively managed. Techniques include using Graphify (for code mapping), Context Mode (to summarize raw output and reduce token count by 70-80%), and dedicated MCP services like Context 7 for accessing up-to-date documentation [~31:25].

Watch on YouTube Full article

Multiplayer agentic engineering — Arjun Singh, Superconductor thumbnail

· 18:44

Multiplayer agentic engineering — Arjun Singh, Superconductor

The talk outlines 'multiplayer agentic engineering,' focusing on how human teams and AI agents can collaborate effectively across diverse systems. Key recommendations include making workflows model-agnostic, integrating agents into every human interface (Slack, GitHub), ensuring work visibility via artifacts, and treating all external signals (emails, meetings) as code inputs. Crucially, the speaker emphasizes that these advanced agentic workflows must operate within isolated cloud environments to enforce least privilege and prevent data exfiltration.

Key takeaways

  1. Model Agnosticism is Critical 5:01

    Do not rely on a single LLM or harness, as the best model changes frequently. Utilizing open-weight models (like GLM 5.2) allows teams to stay in control of costs and maintain workflow continuity.

  2. Agent Interfaces Must Be Universal 6:48

    Agents should not be trapped on a single laptop or platform (e.g., Slack). The agent session must maintain context when moving between relevant interfaces like Slack, the desktop app, and GitHub.

  3. External Signals Must Become Code 10:10

    Treat all external signals—customer calls, meetings (e.g., a Google Meet bot), bug reports from Sentry, or emails—as inputs that can automatically trigger and prioritize work for the coding agent.

  4. Work Must Be Visible Everywhere 9:09

    To improve collaboration, agents should make their work visible across all platforms using standardized artifacts (screenshots or videos), eliminating context switching.

  5. Use Isolated Cloud Environments 12:22

    Running agents in a cloud sandbox is essential for security, enabling non-technical staff to trigger real work without having development environments on their local machines. This enforces the principle of least privilege.

Watch on YouTube Full article

Always-on agents run production without the on-call tax — Justin Smith, Resolve AI thumbnail

· 24:56

Always-on agents run production without the on-call tax — Justin Smith, Resolve AI

The talk introduces the concept of 'always-on agents' designed to automate operational tasks in complex production environments, thereby reducing the burden of manual on-call work. While CI/CD handles baseline checks well, the biggest gap is monitoring non-alerted changes—such as feature flag rollouts or infrastructure updates—that require continuous context understanding. Background agents can run autonomously (on schedules, events, or messages) to perform deep analysis, root cause investigations, and proactive health checks across systems like Kafka pipelines.

Key takeaways

  1. The Operational Bottleneck 2:05

    A significant portion of an engineer's time (estimated at 70%) is spent running code in production—maintaining platforms, debugging incidents, and handling alerts—rather than writing it. This complexity increases with the velocity of change driven by AI.

  2. Background Agents vs. Incident Response 10:40

    While on-call agents handle immediate alerts and incidents, background agents address the 'long tail' of operational work—such as routine health checks, summarizing handoffs, or watching for subtle performance drifts (e.g., P99 drift) that don't trigger an alert.

  3. The Importance of Context 12:00

    Execution is easy; production context is hard. The value lies in building knowledge systems that can determine if a metric 'smells wrong' or understand the causal chain impact of a change, rather than just loading a dashboard.

Watch on YouTube Full article

Agents Write 95% of Our Code. Here's the Catch thumbnail

· 29:43

Agents Write 95% of Our Code. Here's the Catch

As AI agents assume control over an estimated 95% of code production in advanced software factories, traditional code review processes are insufficient. The talk introduces the role of the 'harness engineer,' a new skill set focused on system-level controls: defining invariants, performing deep analytics on agent logs and PR data, and implementing fine-grained risk/operations policies (like auto-merge ladders). This shift requires engineers to move from writing code features to building robust guardrails that ensure consistency and quality across agent-driven pipelines.

Key takeaways

  1. The Paradox of AI Adoption 25:24

    While AI coding tool adoption is high, benchmarks are becoming saturated. Concurrently, the number of reported bugs and incidents is rising, indicating that agents may generate code that lacks maintainability or systemic health (00:15:24).

  2. The Rise of the Harness Engineer 9:34

    Engineering focus must shift from pure feature building to defining and enforcing system invariants. The three critical new skill sets are Systems Thinking, Analytics, and Risk/Operations (00:09:34).

  3. Instruction Following Gap in Skills 8:23

    Tessl's internal skills benchmark revealed that while agents achieved high task completion rates, they only followed approximately 70% of the total instructions defined within a skill (00:08:22).

  4. Systemic Control through Invariants and CI Gates 12:56

    Engineers must identify general principles (invariants)—such as design system rules or desired code structure—and encode them into deterministic checks, verifiers, or CI gates to ensure consistency across the codebase (00:12:56).

Watch on YouTube Full article