Coding Agents

In the Land of AI Agents, the Verifiers Are King — Tariq Shaukat, Sonar

Jul 20, 2026 · 18:53

Tariq Shaukat, CEO of Sonar, argues that rigorous verification is the key to unlocking sustained value from AI coding agents, introducing the Agent-Centric Development Cycle (AC/DC) framework: Guide, Verify, Solve. He warns that without it, the initial 3–5x productivity boost from agents dissipates within three months as technical debt—security issues, maintainability issues, and complexity—compounds. Sonar's tests show that multi-layered, zero-trust verification (combining algorithmic and agentic methods) reduces AI-derived production outages by 44% and, in a trial with a large bank, achieved a 92% reduction in issues. Clean codebases, he argues, make agents faster and cheaper, with over 30% fewer tokens consumed when guided by context and constraints. The framework embeds verification into three loops—agentic, CI, and code maintenance—to create a self-reinforcing positive cycle, countering the downward spiral of neglected code quality.

From Blind Spots to Merged PRs: Continuous Agentic Performance Optimization - May Walter, Hud

Jul 19, 2026 · 22:46

May Walter, CTO of Hud, presents a case study on using coding agents with runtime intelligence to automate continuous performance optimization in production. The system analyzes real production traces, queries, and latencies to surface high-ROI fixes like N+1 queries and missing indexes, scoring them by complexity and impact. It runs weekly via GitHub Actions and Claude Code, generating reports with verified fixes and evidence of impact, such as P90 latency improvements after deployment. Key challenges included 'plausible unverified' fixes, complex ClickHouse queries, and lazy fixes that only mask exceptions rather than root causes. Walter emphasizes the need for prod-to-code context mapping, scoring guardrails, and human review to achieve reliable automation. The talk concludes that context over cleverness works, and agents can automate the investigation phase that teams rarely do proactively, turning dormant performance debt into actionable merged PRs.

The Great Loops Debate — Dex Horthy, Geoff Huntley, Ian Livingstone, Greg Pstrucha, @insecure-agents

Jul 17, 2026 · 1:00:16

In the 'Great Loops Debate' hosted by Ali Howe, Geoff Huntley, Ian Livingstone, Dex Horthy, and Greg Pstrucha argue whether there is a delta between the hype behind loops in AI-assisted development and what works in practice. Team No Delta (Ian, Geoff) contends loops are inevitable and already cost-effective at $10.42/hour, with models surpassing average coders. Team Delta (Dex, Greg) counters that hype outruns discipline: loops work only for deterministic tasks, quality remains low, and token spend scales unsustainably. The debate covers loop history, anatomy (verification, context windows), and the feasibility of fully autonomous software factories, concluding that while loops boost productivity 2-3x, the vision of lights-off factories is premature.

"Software engineering is not about writing code" — Benoit Schillings, Google DeepMind VP of Research

Jul 17, 2026 · 20:26

Benoit Schillings, VP of Technology at Google DeepMind, argues that the era of syntax generation is over, with AI now capable of superhuman code writing, shifting the bottleneck to architecture and validation. He explains that 80% of new code on GitHub is machine-generated, leading to a saturation of human training data and the need for self-play techniques inspired by AlphaZero. Schillings highlights DeepMind's use of self-play to generate and verify coding challenges, enabling models to reach superhuman performance. He emphasizes the shift to inductive architecture, where models must plan, decompose complex problems, and transfer knowledge across domains. Additionally, he calls for new programming languages designed for models rather than humans, and explores how AI's rapid experimentation will transform fields like chemistry and biology by uncovering patterns invisible to humans.

Claude Fable, Claude Tag, and Anthropic's Culture — Cat Wu & Thariq Shihipar ft Simon Willison

Jul 15, 2026 · 51:30

This episode features Anthropic's Cat Wu and Thariq Shihipar discussing Claude Code, Claude Tag, and Claude Fable, arguing that these tools have shifted engineering from slow spec-driven processes to rapid, ambitious building. Thariq notes that with each model generation, delegation increased, and Claude Fable now enables one-shot features. Cat says engineers now need product taste over execution, as timelines shrink from six months to a week. Claude Tag, a proactive multiplayer agent, lands 65% of product engineering PRs internally by monitoring channels and remembering preferences. The team reduced Claude Code's system prompt by 80% for frontier models by removing examples and hard constraints, relying on model judgment. Auto mode, used internally since January, mitigates prompt injection through thousands of evals and Sonnet classifiers. Cultural hacks include default-public channels and a 'don't negotiate against ourselves' mindset, leading to ambitious builds like Thariq's Claude-powered video editing and a Street Fighter game.

RLM: Recursive Language Models for Large Codebases - Shashi, Superagentic AI

Jul 12, 2026 · 17:27

Shashi from Superagentic AI explains how Recursive Language Models (RLM), a pattern from MIT, solve the context window problem in large codebases by externalizing context management into a programmable REPL where the model writes code to inspect, slice, and compute relevant chunks, and recursively delegates sub-questions via llm_query. The RLM loop loads the repo as data, produces bounded observations, and can recursively call another model for deeper insights. Shashi demonstrates RLM Code, an open-source independent implementation running locally and on Gemini with a Docker sandbox, showing two tool calls and a complete trajectory. He notes that similar RLM concepts are used in proprietary systems like Codex, Claude managed agents, and dynamic workflows, making it a practical pattern for AI engineers dealing with monorepos.

A Song of Types and Agents - Roberto Stagi, Ratel

Jul 12, 2026 · 14:16

Roberto Stagi (Ratel) argues that TypeScript is overtaking Python as the dominant language for building AI agents and applications, driven by the rise of coding agents like Lovable, Claude Code, and Cursor that default to TypeScript. He notes that Python still rules training, research, and GPU serving, but the application layer—where AI is shipped inside products—now belongs to TypeScript. Stagi highlights that TypeScript surpassed Python as the most used language on GitHub in August 2025, with GitHub attributing the shift to AI agents. He cites the Vercel AI SDK growing from 1.6M to 15.1M weekly downloads in one year and npm's rich ecosystem of authentication, payments, and UI packages as reasons to build agents in TypeScript. Consistent end-to-end typing via Zod and a unified codebase for agent loops, tools, backends, and UIs further strengthen the case. Stagi concludes by invoking Atwood's Law: any application that can be written in JavaScript will eventually be written in TypeScript, urging developers to build agents in TypeScript to avoid falling behind.

ReviewDebt: a practical framework for scoring every pull request — Sachin Gupta, Ebay

Jul 12, 2026 · 25:00

Sachin Gupta introduces ReviewDebt, a deterministic framework scoring every pull request on the hidden review burden it creates, arguing that coding agents produce code faster than humans can responsibly review, accumulating an unmeasured debt. He defines 5 signal families—diff size and coupling, test evidence gap, directory and ownership spread, AI authorship indicators, and evidence and rational gaps—with 10 deterministic checks computable from PR data without LLMs, to produce a 0–100 score. Real PR examples show a clean human PR scoring 0, a high-debt AI PR scoring 60 with 86 estimated review minutes, and a well-shaped AI PR scoring 7. A cross-repo scan of 524 PRs over 27–90 days found 228 senior reviewer hours accumulated, with 5–20% of PRs weekly firing AI indicators but none of those landing in the high-burden band—complexity, not authorship, drives burden. Gupta advises teams to backfill the scorer on last 200 PRs, set a threshold (e.g., 50), surface scores as PR comments, aggregate weekly per team, and bring the number to retrospectives, turning vibe into measurement for 2027's governance conversation.

remobi.app: Don't change your terminal workflow for mobile

Jul 12, 2026 · 9:21

Connor Adams presents remobi.app, a progressive web app that lets developers check on their terminal-based coding agents from a mobile phone without changing their existing workflow. Built for TMUX users, it mirrors a user's remote terminal session with gesture controls for zoom, scroll, and pane switching. Adams argues that unlike Claude Code's built-in handoff or dedicated mobile terminals, remobi is agent-agnostic and preserves custom TMUX setups with tools like lazygit and critique. The app uses Tailscale by default for secure remote access, though users can substitute Ngrok or Cloudflare tunnels. Open source and installable via npm, remobi aims to satisfy the compulsive need to monitor agents while away from the desk.

Develop at Idea Velocity - Jeffrey Lee-Chan, Snapchat

Jul 11, 2026 · 15:28

Jeffrey Lee-Chan (Snapchat) and Austin (CMUX) explain how to achieve 'idea velocity' by building parallel multi-agent harnesses that let one engineer direct 10–20 coding agents instead of becoming the bottleneck. Lee-Chan argues the key is separating 'Agent Orchestrator Managers' from specialized workers to prevent low-level implementation bias, using OpenClaw for frictionless Slack-based communication and CMUX terminals for real-time parallelization and unbiased manager oversight. He demonstrates two apps—an AI RPG with dice-roll mechanics and a multi-AI analysis tool—built with this stack, and discusses token-burn tradeoffs between models like Codex 5.3, GPT-5.4, and Minimax. The episode also covers staging environments to avoid doubling token usage, the benefit of persistent memory and contextual guardrails, and the importance of pushing human interaction to the start or end of the workflow for improved parallelization.

Understanding is the new bottleneck — Geoffrey Litt, Notion

Jul 10, 2026 · 19:33

Geoffrey Litt from Notion argues that understanding code written by AI agents is crucial for creative participation, not just correctness checking. He presents three techniques: explanations via his 'explain diff' skill, which generates HTML or Notion documents with background, intuition, interactive figures, and literate code diffs, capped by a five-question quiz to ensure understanding before sharing code; micro-worlds, like a step-by-step debugger for a Prolog interpreter or a 'video game' that walks through migrating a website; and shared spaces in Notion where humans and agents can collaborate in multiplayer chat threads and comment on documents. Litt emphasizes that agents can build ephemeral UIs and simulations to help humans understand better, leveraging education principles to stay deeply in the loop.

Should AI Engineers Still Read Code in 2026? The Z/L Continuum — Alex Volkov, ThursdAI

Jul 10, 2026 · 21:35

Alex Volkov examines the debate sparked by Ryan Lopopolo's claim that 'code is free' and Mario Zechner's counter that engineers must 'read every fucking line' of critical code, arguing that the Z/L Continuum is about task-level proof rather than personality. Citing a Ferrous AI survey showing an 861% increase in code deletion per PR and a 242% rise in incidents, he notes Anthropic's recursive self-improvement essay admitting human code review is a new bottleneck. Volkov's routing table prescribes reading every line for authentication, money movement, and irreversible data, while letting agents handle less critical changes. He also introduces loops—cron-like agent systems that self-verify—as the next frontier, quoting Adi Osmani that automated loops don't remove judgment. Volkov concludes that capability drift moves where proof belongs, but every system still requires human judgment.

The Golden Age of AI Engineering — Alexander Embiricos & Romain Huet & Peter Steinberger, OpenAI

Jul 9, 2026 · 25:13

OpenAI's Alexander Embiricos, Romain Huet, and Peter Steinberger reveal how AI engineering is entering its golden age, with model releases accelerating from every 15 months to roughly every 6 weeks and frontier-level intelligence now available at $1 per million input tokens and $6 per million output tokens. They demonstrate Codex's evolution from a model that couldn't test its own code to one generating 750 tokens per second, enabling a 10-second pull request, and emphasize that the product is built on the same open-source stack—responses API, AGENTS.md format, and harness—that ships to developers. The trio argue that the future is not about automating engineers but empowering them via value maxing over token maxing, with agents moving from local/cloud distinctions to persistent, long-running managers that orchestrate work and only require human steering at key decision points, as illustrated by an automated open-source issue resolution workflow.

Building an ACP-Compatible Agent Live — Bennet Fenner, Zed

Jul 8, 2026 · 18:19

Bennet Fenner from Zed demonstrates building an ACP-compatible coding agent live, showing how the Agent-Client Protocol lets agents and editors communicate over JSON-RPC. He starts with a minimal agent that reads and edits files, then adds ACP support using the TypeScript SDK—implementing initialize, session creation, and prompt handling. Next, he streams model tokens via session updates, emits tool call progress with file paths and diffs, and proxies file system operations through the client. The demo culminates in the agent bootstrapping itself to add a terminal tool, which then runs shell commands inside Zed. ACP currently works over stdio; a remote transport is in development.

Field Guide to Fable — Thariq Shihipar, Anthropic

Jul 6, 2026 · 19:28

Thariq Shihipar of Anthropic discusses Fable and argues models improve in "spiky" ways: a chat model fails to list Pokémon ending in "aw" (Croconaw and Dreadnaw), but Claude Code fetches and filters the list in seconds – a gap he calls "capability overhang." He explains that to unlock Fable, Claude Code cut 80% of its system prompt because heavy instructions now constrain a more imaginative model, and the "ask user question" tool evolved from barely working under Opus 4 to generating embedded HTML questionnaires. He shares techniques like blind-spot passes and interviews to surface unknown unknowns, and reflects on the grief of moving from hand-coded programming to agentic workflows. Shihipar urges engineers to reject trade-offs – "good, fast, cheap: pick three" – and instead demand all three, citing a four-hour keynote deck built with Fable as proof that agents can deliver ambitious work faster.

The Prompt is the Platform - Dominik Tornow, Resonate HQ

Jun 29, 2026 · 17:33

Dominik Tornow, founder and CEO of Resonate, argues that coding agents will retire general-purpose platforms by 2026, replacing them with bespoke implementations generated on demand from reusable specifications. He details Resonate's shift from delivering implementations to offering specifications — the product becomes the protocol. Tornow recounts how agents initially failed to build a production-grade Resonate server on Postgres due to the gap between abstract specs and concrete implementations. By inserting a concrete specification and deterministic simulation environment, agents could design correct algorithms for distributed systems. Working with NATS I/O, he explains how simulation exposes hidden facts like stale reads, letting agents debug failures. The resulting workflow — abstract spec, simulated implementation, concrete spec, production code — enables agents to drive design, not just coding, making "the prompt the platform."

A Genius With Amnesia - Victor Savkin, Nx

Jun 26, 2026 · 20:00

Victor Savkin, creator of Nx and Polygraph, argues that current coding agents are like a genius with amnesia – they see only a tiny portion of the codebase and forget everything between sessions – and introduces Polygraph, a meta-harness that gives agents full organizational context and perfect memory. He explains that agents are repo-bound and lack episodic memory, forcing humans to re-explain changes (e.g., seven explanations for one UI change across four repos). Polygraph builds a unified dependency graph by analyzing thousands of repos without code changes, lets agents work across multiple repos in a single session, and captures all traces so sessions can be resumed by any agent (Claude or Codex) on any machine. It also enables context-aware queries like 'find every repo that depends on version X of this library' and allows referencing past sessions for best practices. The result is an agent that sees the entire organization's code and remembers every decision, effectively creating a hive mind.

Self Driving Products: Product Signals to Pull Requests — Joshua Snyder, PostHog

Jun 10, 2026 · 15:39

Joshua Snyder of PostHog explains how they're building a pipeline that turns product signals—errors, Slack messages, session replays—into automated pull requests. He reveals that off-the-shelf embedding models cluster signals by structural similarity, so they embed LLM-generated queries instead. He argues specificity determines whether the agent produces a useful PR, with error tracking being immediately actionable while Slack and replay usually are not. He advises starting with costly agents to discover patterns, then collapsing expensive steps into one-shot calls.

Benchmarking semantic code retrieval on Claude Code — Kuba Rogut, Turbopuffer

Jun 3, 2026 · 16:08

Kuba Rogut from Turbopuffer benchmarks semantic code retrieval on Claude Code, finding that raw Claude Code wastes one in every three file reads (65% precision), windowed grep drops that to one in five, and adding semantic search cuts it to one in eight (87% precision). Semantic search wins on behavior-adjacent tasks where files share no keywords; grep wins on import tracing. Cursor's production numbers show a 24% relative improvement in answer accuracy from semantic retrieval plus a 2.6% increase in code retention in large codebases. Rogut explains Cursor's model knows when and why to call semantic search, while Claude Code treats it as just another tool, limiting gains.

Can LLMs generate Enterprise Quality Code? — Prasenjit Sarkar, Sonar

May 31, 2026 · 15:12

Prasenjit Sarkar from Sonar evaluates whether LLMs generate enterprise-quality code using SonarQube analysis of 4,444 Java assignments across 53 models. While Gemini 3.1 Pro High achieves 84.17% pass rate, GPT-5.4 Pro High generates 1.2 million lines (high bloat), and Claude Sonnet 4.6 has 300 security issues per million lines. The ACDC framework addresses these gaps: Guide (Sonar Sweep and Context Augmentation), Verify (SonarQube Agentic Analysis in 1–5 seconds pre-commit), and Solve (Remediation Agent that fixes issues and checks regressions before presenting fixes). Sonar's leaderboard at sonar.com/leaderboard provides detailed pass rates, cyclomatic/cognitive complexity, bug density, and security metrics per model.

Beyond Code Coverage: Functionality Testing with Playwright MCP — Marlene Mhangami, Microsoft

May 16, 2026 · 19:45

Marlene Mhangami of Microsoft and GitHub argues that AI boosts developer productivity only when paired with clean code practices, citing a Stanford study of 120,000 developers and GitHub Octoverse data showing 275 million weekly commits in 2026 with a growing share co-authored by AI. She advocates test-driven development (TDD) with Playwright for functional testing over unit tests, as AI-generated tests often affirm code behavior rather than user experience. In a live demo, she uses GitHub Copilot CLI and Playwright MCP server to automatically write failing Playwright tests for a toy store's search and filter features, then generate code to pass them. She emphasizes testing one feature per test, capturing screenshots for PRs, and committing code before fixes to preserve context. She closes with advice on using Playwright agents for complex state management and confirming cross-screen-size support.

CI/CD Is Dead, Agents Need Continuous Compute and Computers — Hugo Santos and Madison Faulkner

May 13, 2026 · 18:37

Madison Faulkner and Hugo Santos (Namespace) argue that traditional CI/CD is dying because it was built for humans pushing one or two diffs a week; at agent scale, thousands of autonomous agents opening PRs cause runner saturation, cold Docker builds, cache thrash, and merge queues that behave like serialized database locks. They propose replacing PRs with intent and plan fed into an agent loop that performs fast inline validation—builds and tests in the inner loop—while humans review intent-plus-outcome instead of diffs in a premerge queue. The future they envision involves agents exploring multiple commits in parallel for the same plan (a multiverse) where the inner loop must be stateful and extremely fast to keep up with the moving tip of the repo. CI doesn't disappear but shifts into continuous enforcement of invariants and governance within the agent harness.

Harness Engineering: How to Build Software When Humans Steer, Agents Execute — Ryan Lopopolo, OpenAI

Apr 17, 2026 · 46:21

Ryan Lopopolo, a member of technical staff at OpenAI, argues that software engineers must shift to 'harness engineering' where agents produce all code and humans focus on delegation, system design, and guardrails. He describes how his team banned editors, using Codex with skills to manipulate apps, and reduced review friction by automating lint rules and review agents. Lopopolo explains that code is free but human time and model context are scarce, so teams should structure repositories for consistency and use 'garbage collection days' to eliminate recurring slop. He shares practical techniques like writing tests about source code (e.g., file length limits) and using review agents that inject prompts. His future vision involves agents autonomously executing long-horizon work based on token budgets and success metrics, freeing humans for higher-level activities.

Platforms for Humans and Machines: Engineering for the Age of Agents — Juan Herreros Elorza

Apr 8, 2026 · 21:15

Juan Herreros Elorza, team lead at Banking Circle, argues that the same platform engineering best practices—self-service, API-first design, local-first workflows, and rich observability—that serve human developers are now prerequisites for AI coding agents to autonomously build, debug, and ship software. Drawing from his experience building the internal platform Atlas, which handles over €1 trillion in cross-border payments annually, he explains how exposing platform capabilities via well-defined APIs (and optionally MCP servers) lets agents iterate locally, fail fast, and close the loop using API-accessible logs and metrics. He stresses structured documentation, including agent.md files and skills, to guide agents on how to contribute to the platform, and recommends combining guardrails for security with context files for best practices. Finally, he advises measuring outcomes like DORA metrics, support requests, and developer satisfaction, and suggests using AI as leverage to finally implement these long-known best practices.

Welcome to AIE CODE - Jed Borovik, Google DeepMind

Jan 5, 2026 · 4:10

Jed Borovik, Google DeepMind's Gemini assistant and lead of the Jewels coding agent product engineering team, opens the 2025 AI Engineering Code Summit in New York by declaring that the most important problem in applied AI is code. He frames the event as a single-track summit designed to push the entire AI coding industry forward, not any single company. Borovik highlights the previous leadership track, which covered how AI transforms software organizations, and sets the day's focus on patterns, systems, and products enabling that transformation. He thanks DeepMind as presenting sponsor, noting the timely release of Gemini 3 and Nano Banana Pro, along with Anthropic as platinum sponsor and other gold and silver sponsors. Borovik encourages attendees to visit sponsor booths in the expo area and expresses excitement for the keynotes to come.

AGI: The Path Forward – Jason Warner & Eiso Kant, Poolside

Dec 27, 2025 · 15:56

Jason Warner and Eiso Kant, co-founders of Poolside, present their vision and roadmap towards AGI-level capabilities for knowledge work, demonstrating their second-generation model Malibu Agent converting ADA code to Rust live on stage. They argue that next-token prediction paired with reinforcement learning is the key breakthrough, a contrarian bet they made two and a half years ago. The episode centers on their work in high-consequence code environments for defense and government, where agents must operate with tight permissions. They announce a large compute cluster of over 40,000 GB300s coming online and a public API release early next year via AWS Bedrock. Warner recounts meeting Kant through a failed GitHub acquisition, and Kant invites the audience to build with their models, emphasizing that future agents will handle tasks over days as intelligence scales.

Developer Experience in the Age of AI Coding Agents – Max Kanat-Alexander, Capital One

Dec 23, 2025 · 18:20

Max Kanat-Alexander, Capital One executive distinguished engineer, argues that developer experience teams should invest in a 'No Regrets' framework to prepare for an agentic future, regardless of unpredictable AI advancements. He identifies six key inputs that benefit both humans and AI agents: standardized development environments using industry-standard tools, native CLIs and APIs instead of browser automation, deterministic validation with clear error messages, refactoring legacy codebases for testability and reasoning, documenting external context and intentions, and improving code review velocity and quality through assignment and apprenticeship. Without these, bad codebases lead to rubber-stamped PRs and a vicious cycle of decreasing agent productivity; with them, a virtuous cycle accelerates software engineering velocity. Kanat-Alexander emphasizes that what's good for humans is good for AI, and these investments will help developers no matter what the future holds.

AI Kernel Generation: What's working, what's not, what's next – Natalie Serrino, Gimlet Labs

Dec 17, 2025 · 19:15

Natalie Serrino, cofounder of Gimlet Labs, presents how AI-generated kernels can automatically speed up custom PyTorch code by up to 24% on Apple M4 hardware using the Metal framework, with a 40% speedup from kernel fusion. The agentic system iterates through compilation, execution, correctness, and optimization, but faces challenges like validation of floating-point results and reliable benchmarking. Successes include rewriting average pool 1D as a convolution for 80% improvement, while failures occur on heavily optimized ops like matrix multiply. A real-world audio encoder model saw 70% faster inference on RTX 6000 Blackwell via six custom fused kernels. Serrino emphasizes that AI is best for rapidly searching optimizations and porting code to new hardware, not for surpassing human experts on novel algorithms.

Future-Proof Coding Agents – Bill Chen & Brian Fioca, OpenAI

Dec 5, 2025 · 17:48

Bill Chen and Brian Fioca from OpenAI argue that coding agents are booming but fragile, with teams rebuilding harnesses every time models change. They present Codex, OpenAI's combined model and harness, as a stable abstraction layer that handles complexity like context compaction, parallel tool calls, and MCP integration. Key lessons include avoiding overprompting—letting the model use its trained habits rather than forcing foreign instructions—as demonstrated when GPT-5 ran slowly because users told it to examine every file. They describe patterns for using Codex as an SDK, enabling products like GitHub and Cursor to integrate without maintaining their own harness, and highlight future improvements in longer-horizon tasks and self-healing software. The episode concludes that building where models are going, with Codex's SDK, lets teams focus on differentiation rather than infrastructure rewrites.

Vision: Zero Bugs — Johann Schleier-Smith, Temporal

Nov 24, 2025 · 36:03

Johann Schleier-Smith, Technical Lead for AI at Temporal, argues that zero-bug software is achievable by applying aerospace-grade techniques like rigorous specification, modular design, and formal verification, now made practical by AI. He cites the Airbus A320's control software (no incidents from software in decades) and the Space Shuttle (1 error per 420,000 lines) as proof. Schleier-Smith demonstrates Dafne, a language that embeds proofs inline with code for automated verification, and shows how agentic coding can reduce high-assurance code costs by ~100× compared to traditional development. He concludes that agents generating verified code will overcome current quality limitations and trigger widespread adoption.

Infra that fixes itself, thanks to coding agents — Mahmoud Abdelwahab, Railway

Nov 24, 2025 · 18:08

Mahmoud Abdelwahab from Railway presents Railway Autofix, a system that uses Inngest for durable execution and OpenCode as a coding agent to automatically detect infrastructure issues and open pull requests to fix them. The system runs scheduled workflows to fetch project architecture, resource metrics, and HTTP performance data, then analyzes services exceeding thresholds. For affected services, it gathers additional context like logs and generates a detailed fix plan using an LLM. The coding agent then implements the plan and opens a PR with a summary of changes. The talk demonstrates how this shifts developers from manually investigating alerts to simply reviewing auto-generated fixes.

Z.ai GLM 4.6: What We Learned From 100 Million Open Source Downloads — Yuxuan Zhang, Z.ai

Nov 22, 2025 · 19:39

Yuxuan Zhang from zAI details the technical roadmap behind the GLM 4.6 open-source model series, which has surpassed 100 million downloads and tied for number one on the LMSYS Chatbot Arena alongside GPT-4o and Claude 3.5 Sonnet. The training pipeline uses 15 trillion tokens of pre-training data, followed by 7 trillion tokens of code and reasoning data, repo-level contexts at 32,000 tokens, and 100 billion tokens of long-context agent trajectories up to 128,000 tokens. Zhang introduces SLIME, a hybrid synchronous/asynchronous RL framework that decouples agent-environment interaction from GPU training to avoid bottlenecks. He explains why single-stage RL at 64,000 tokens outperforms multi-stage approaches for preserving long-context abilities, and shows that token-weighted loss converges faster than sequence-average loss for code RL. The multimodal GLM 4.5V model handles native resolution images and video with temporal index tokens, enabling GUI agent capabilities. Deployment is supported via vLLM and SGLang, with an API at z.ai and an open-source coding assistant.

Building the platform for agent coordination — Tom Moor, Linear

Jul 28, 2025 · 19:43

Tom Moor, Head of Engineering at Linear, explains how the company is evolving from an issue tracker into an operating system for engineering teams that treats AI agents as first-class teammates. He details Linear's pragmatic AI journey: starting with embeddings and PG vector, then moving to a hybrid search index using TurboPuffer and Cohere embeddings, leading to features like Product Intelligence (query rewriting, reranking, deterministic rules for suggestions), natural language filters, Slack-to-issue creation, and daily audio pulses. The core of the talk is Linear's agent platform, launched two weeks ago, where coding agents like CodeGen, Bucket, and Charlie integrate via OAuth, GraphQL, and new webhooks, allowing users to assign, mention, and interact with agents just like human teammates. Moor emphasizes best practices for builders: respond fast, inhabit the platform's language, move issues to 'in progress,' and clarify plans before acting, all while keeping interactions concise and value-adding. The episode argues that with this platform, engineering teams can build more, faster, and with higher quality by offloading grunt work to infinitely scalable cloud-based teammates.

Ship Production Software in Minutes, Not Months — Eno Reyes, Factory

Jul 25, 2025 · 16:06

Eno Reyes, cofounder and CTO of Factory, argues that AI agents can orchestrate the entire software development lifecycle, moving beyond vibe coding to agent-native development where enterprises delegate planning, coding, testing, and incident response to autonomous droids. He explains that AI tools are only as good as the context they receive—missing context from meetings, whiteboards, or Slack is the primary cause of failure, not LLM quality. Factory's droids search codebases, leverage organizational memory, and question unclear tasks before executing, from generating PRDs and tickets to creating runbooks and RCAs from sentry alerts. Reyes demonstrates how an agent can convert user transcripts and ad-hoc notes into a full feature plan, then break it into parallel tickets for multiple code droids. For incident response, droids pull logs, historical runbooks, and team discussions to produce mitigation plans in minutes, cutting response times in half and shifting from reactive to predictive operations. He emphasizes that the future belongs to engineers who manage agents—thinking clearly and communicating effectively—rather than those writing every line of code.

Software Development Agents: What Works and What Doesn't - Robert Brennan, OpenHands

Jul 25, 2025 · 16:46

Robert Brennan, creator of the open-source coding agent OpenHands (formerly OpenDevin), argues that while coding is going away, software engineering remains about critical thinking, not typing. He explains that agents like OpenHands operate via a loop between an LLM and tools like a diff-based editor, terminal, and web browser, all sandboxed in Docker. Brennan advises starting small with rote tasks like merge conflicts (99% success) or PR feedback, being specific about frameworks and files, and always reviewing AI-generated code to avoid tech debt. He shares that 90% of his code now goes through the agent, with 10% requiring manual intervention, and warns against auto-merging without human accountability—OpenHands now assigns PRs to the human who triggered them. Key use cases include fixing failing tests, infrastructure changes, database migrations, and greenfield internal apps where vibecoding is acceptable.

Devin 2.0 and the Future of SWE - Scott Wu, Cognition

Jul 25, 2025 · 16:13

Scott Wu of Cognition AI describes an AI 'Moore's Law' for coding agents, with capability doubling every 70 days, propelling Devin from simple migrations to autonomous project work. He traces Devin's evolution through tiers: first repetitive migrations using Playbooks for instruction-following, then isolated bugs with VM snapshots, then multi-file changes with codebase intelligence, and finally backlog killing with self-testing. Each tier required solving different bottlenecks—memory, language server integration, iterative planning, and confidence calibration. Wu argues that the interface and key capabilities shift every 2-3 months, and predicts another 16-64x improvement in the next year.

RL for Autonomous Coding — Aakanksha Chowdhery, Reflection.ai

Jul 16, 2025 · 19:27

Aakanksha Chowdhery, CEO of Reflection AI and former lead researcher on PaLM and Gemini at Google, argues that reinforcement learning (RL) scaling is the next frontier for autonomous coding agents. She explains that inference-time techniques like majority voting and self-revision improve accuracy but require many samples (e.g., 10,000 for rare correct generations). RL training can learn to generate correct outputs directly, especially in verifiable domains like code with unit tests. Reflection AI aims to build superintelligence starting with autonomous coding, leveraging automated verification to design better reward functions. She notes challenges in scaling RL, including system complexity and reward hacking, but sees coding as ideal due to execution feedback.

To the moon! Navigating deep context in legacy code with Augment Agent — Forrest Brazeal, Matt Ball

Jun 27, 2025 · 15:24

Forrest Brazeal and Matt Ball demonstrate how Augment Agent helps developers navigate and modernize legacy codebases using the Apollo 11 guidance computer as an example. They show that Augment's chat mode can instantly explain the 1202 program alarm—indicating the computer was overloaded but could continue—by reading assembly code and web context. Then, using agent mode, they prompt the tool to write a Python implementation of the P65 vertical descent algorithm from the original assembly, run a simulator, and land the lunar module within expected parameters. The episode argues a three-step strategy for any legacy codebase: use chat to understand, write tests via agent, and then modernize modularly—proving AI agents can turn toil like Java 8-to-17 migrations into automated tasks.

Mastering Engineering Flow with Windsurf - Eashan Sinha, Windsurf

Jun 27, 2025 · 15:20

Eashan Sinha, a Deployed Engineer at Windsurf, explains how engineering teams can master agentic IDEs using Windsurf's Cascade agent. He argues that developers should treat AI as a teammate rather than a tool to abuse, emphasizing Windsurf's flow awareness—tracking user actions, edits, and terminal commands to infer intent. Sinha details Windsurf's evolution from copilots to agents, combining collaborative chat with autonomous tool calling, and introduces features like state-of-the-art context engine, workflows for deterministic steps, rules, memories, and simultaneous Cascades. He provides a practical four-step framework—explore, plan, build, test—for maximizing agentic flow, including using planning files, checkboxes, and automated test generation. The episode delivers a concrete guide to integrating AI into development without sacrificing quality, recorded at the AI Engineer World's Fair in San Francisco.

Supercharging developer workflow with Amazon Q Developer - Vikash Agrawal

Jun 10, 2025 · 13:22

Vikash Agrawal and Linda show how Amazon Q Developer can drive every stage of the software development lifecycle. They build a 2048 game with FastAPI and Poetry using Q's /dev command in the CLI, then add unit tests with /test, generate documentation with /doc, and integrate with GitHub for automated pull requests. After deploying to AWS, they use Q in CloudWatch to debug a runtime import error by analyzing logs and resource topology. The episode emphasizes that planning infrastructure and prompts upfront, along with security scans, are critical for production-ready AI-assisted development.

The Many Ends of Programming - Ray Myers

Jun 10, 2025 · 27:12

Ray Myers, Chief Architect at All Hands AI, argues that the future of software engineering is not predetermined and we have a say, categorizing competing visions into six distinct endgames: extreme completion, dev apocalypse (innovator's paradise), abstraction leap, uncharted waters, review economy, and infinite pile of garbage. He illustrates extreme completion with a real example where an AI agent generated a 48-file pull request from a Slack message, and abstraction leap via domain-specific languages (DSLs) shown in the Parcel paper’s 61 prompts producing a 220-line Lisbon interpreter. Myers warns that dev apocalypse is desirable but not yet feasible, while the review economy is a pit stop where manual review bottlenecks must be managed using Theory of Constraints. He cites contradictory studies: UpLevel found developers with coding assistants had higher bug rates, while GitHub Copilot claimed improved quality; he notes 2024 was the first year copy-pasted code exceeded refactored code, a red flag for tech debt. Ultimately, Myers urges deliberate choices: whether we want no programmers or everyone to be a programmer, and whether we prioritize quality over quantity.

Self Coding Agents — Colin Flaherty, Augment Code

Apr 21, 2025 · 17:23

Colin Flaherty, founding researcher at Augment Code, describes how the company built an AI coding agent that wrote over 90% of its own 20,000-line codebase with human supervision. The agent autonomously added third-party integrations like Google Search and Linear by searching its own codebase and even used its own Google Search tool to look up Linear API docs. It profiled and optimized itself, replacing synchronous file hashing with a process pool after adding print statements and running sub-copies. Flaherty argues that agent capabilities improve with better context engines, code execution environments, and test harnesses—adding test-driven iteration boosted a bug-fixing benchmark by 20% versus 4% from just upgrading the foundation model. He cautions that agents are general-purpose, not category-specific, and have different strengths than humans, making knowledge bases crucial for onboarding. With code becoming cheap, the focus shifts to product insights and design, while better tests enable greater autonomy and accelerate agent self-improvement.

AI Engineers: The Next Generation — Stefania Druga, Google Gemini

Apr 13, 2025 · 21:47

Stefania Druga, a research scientist on Google Gemini, presents Cognimates and its new AI copilot that teaches children to become AI engineers. Built on Scratch’s visual programming, Cognimates lets kids train custom models, program robots, and build games, shifting their perception from ‘AI is magic’ to understanding data and confidence levels. Druga’s design studies with 18 kids from 11 countries showed the copilot doubled programming time by supporting ideation, debugging, and creative agency—never giving answers unless stuck three times. The tool now integrates screenshot analysis and asset generation, with plans to embed the agent across the OS. Druga ties this to the EU AI Act’s mandate for AI literacy, arguing early, hands-on creation is the path to informed users.

Building AI Agents with Real ROI in the Enterprise SDLC: Bruno (Booking.com) & Beyang (Sourcegraph)

Apr 8, 2025 · 20:56

Beyang Liu, CTO of Sourcegraph, and Bruno Passos, Group PM at Booking.com, explain how their partnership built AI coding agents that deliver measurable ROI in enterprise software development. Booking.com, with 3,000 developers handling 250,000 merge requests and 2.5 million CI jobs yearly, used Sourcegraph's Cody and custom agents to automate code migration and review, cutting cycle times. They report that daily Cody users ship 30% more pull requests and are 30% faster, with lighter MRs. Agents like a GraphQL generator for a million-token schema and a code review tool with customizable rules emerged from joint hackathons. Bruno emphasizes education as critical: training turned skeptical developers into daily users, driving adoption and productivity gains. The goal is to shift-left compliance and reduce tech debt, making the SDLC self-healing.

How Windsurf writes 90% of your code with an Agentic IDE - Kevin Hou, Windsurf

Mar 11, 2025 · 20:50

Kevin Hou, head of product engineering at Codeium, introduces Windsurf as the first AI agent-powered editor, arguing that agents are the future of software development. The editor is built on three principles: trajectories, a unified timeline that lets the agent read the user's mind and execute commands like 'continue my work'; meta-learning, which auto-generates memories of user preferences and codebase context; and scaling with intelligence, removing legacy features like chat and @-mentions as models improve. Windsurf launched three months ago and has already generated 4.5 billion lines of code, with 90% of code now written via its Cascade agent. Hou emphasizes that the agent reduces human-in-the-loop effort by inferring context, running terminal commands in the user's environment, and dynamically retrieving documentation—allowing developers to contribute less input while getting more production-ready output.

GitHub Next Explorations: Rahul Pandita

Feb 8, 2025 · 18:18

Rahul Pandita, a researcher at GitHub Next, presents two explorations: Copilot Next Edit Suggestions and Copilot Workspace. Next Edit Suggestions extends GhostX by suggesting multi-location edits beyond the cursor, such as updating method definitions and documentation when a parameter is added. Copilot Workspace addresses developers' pain points of getting started on tasks, trusting AI output, and retaining control by offering a one-click proposal, built-in runtime verification, and an iterative, collaborative environment. Pandita demonstrates updating a MonoSpace website to add Rust syntax highlighting via a GitHub issue, showing specification generation, planning, and terminal command synthesis. He emphasizes that GitHub Next explores uncertain futures rapidly, learning from experiments like Copilot (which started as a Next project) to shape AI-augmented software engineering without waiting decades.

[Full Workshop] How to add secure code interpreting in your AI app: Vasek Mlejnsky

Feb 6, 2025 · 1:48:16

Vasek Mlejnsky, CEO of E2B, demonstrates how to add secure AI code execution to any app using E2B’s Code Interpreter SDK alongside Anthropic's Sonnet 3.5 and Vercel’s AI SDK. The workshop builds an open-source version of Claude’s artifacts UI, running Python code in isolated Firecracker VMs that start in ~900ms and support custom environments via Dockerfiles. Vasek explains how E2B’s Jupyter-server-based sandbox returns stdout, stderr, runtime errors, and rich outputs like PNG charts, which are streamed to the front end using Vercel’s stream data. He covers security architecture—full root access in a VM that self-destructs on escape—and plans for AWS/GCP self-hosting and snapshot-based agent branching. The episode also addresses customizing sandboxes with private packages, mounting cloud storage (S3, GCS), and interpreting table previews as HTML or images.

The Rise of the AI Software Engineer: Jesse Han

Feb 5, 2025 · 3:48

Jesse Han, CEO of Morph Labs, announces the Morph Code Index and RiffCoder 7B model as milestones toward the personal AI software engineer. The Code Index is a neurosymbolic code database that enables semantic search over codebases, makes entire Git history visible to coding assistants, and transmutes code into training data. It uses static analysis, vector embeddings, and graph algorithms for state-of-the-art code search, with a query language guaranteeing precise results. RiffCoder 7B, trained on data from the Code Index, is the only open-source code editing model that runs on laptops and IDEs. Morph Labs is building a platform for managing personal AI software engineers, available via waitlist. The future of software should belong to everyone, and the tools are open-source and free.

Code Generation and Maintenance at Scale: Morgante Pell

Oct 17, 2024 · 18:54

Morgante Pell, founder of Grit, argues that AI agents for code generation must be built for modifying large existing codebases rather than generating new apps, and that combining static analysis with AI enables reliable migrations at scale. Grit has merged more PRs than any other company by focusing on supercharging top engineers, using GritQL to precisely find code via syntactic and semantic queries, and relying on compilers like TSC to catch errors that LLMs miss. They overcome slow enterprise builds (10 minutes for type checking) by precomputing in-memory indexes and using Firecracker to snapshot and fork environments for parallel agent execution, achieving PRs with only a few iterations. For editing, they developed a custom 'loose search and replace' format to avoid expensive full-file generation and LLM laziness. This approach allowed one customer to complete a multi-year OpenTelemetry migration in a week with under 100 developer hours. Morgante envisions future UIs that let engineers manage entire codebases like SimCity.

What's new from Anthropic and what's next: Alex Albert

Aug 5, 2024 · 13:38

Alex Albert, Head of Developer Relations at Anthropic, argues the industry is in a 'magic star icon phase'—tacking AI onto existing products—and urges rebuilding from the ground up. He announces Claude 3.5 Sonnet, which scores 64% on pull request evals (vs 38% for 3 Opus), with 200k context, vision improvements, and pricing at $3/M input and $15/M output tokens. New features include Artifacts for collaborative creation of code and React components from screenshots, Projects for team knowledge grounding, and an enhanced ToolUse API supporting hundreds of tools and structured JSON output. Future models (3.5 Haiku/Opus) will be smarter, cheaper, and faster; a steering API for interpretability allows clamping feature values to control outputs.

The Making of Devin by Cognition AI: Scott Wu

Jul 11, 2024 · 20:04

Scott Wu, co-founder and CEO of Cognition AI, demonstrates Devin, a fully autonomous AI software engineer that builds and deploys working applications from plain English instructions, sharing the early lessons and vision behind the product. Devin built a name game website for the AI Engineer World's Fair in minutes, iterating on feedback to hide names, add a streak counter, and deploy the final version. Cognition uses Devin internally for features like a search bar and dashboards; Wu notes that engineers typically spend 80–90% of time on implementation, but Devin frees them to focus on architecture and problem-solving, making them 5–10x more productive while increasing overall demand for software. He also highlights the UX challenges of agents, which require new interactions beyond text completion, and notes that access to Devin is expanding via a waitlist.

The Code AI Maturity Model and What It Means For You: Ado Kukic

Feb 13, 2024 · 7:58

Ado Kukic, Director of DevRel at Sourcegraph, presents the Code AI Maturity Model, a framework comparing AI coding assistant autonomy to SAE vehicle levels. He argues that 92% of developers now use Code AI tools, up from 1% a year ago, and predicts 99% of code will be written by AI in 5 years. The model defines six levels: Level 0 (manual coding), Level 1 (AI-generated snippets from developer intent), Level 2 (codebase-aware completions, e.g., suggesting Axios in a Node.js project), Level 3 (AI builds full features from high-level requirements, like adding authentication), Level 4 (AI proactively handles tasks, such as auto-fixing bugs via PRs), and Level 5 (AI handles the entire software lifecycle with minimal human oversight). The talk contextualizes each level with autonomous driving parallels, emphasizing that the industry is currently transitioning between Levels 1–3, with Level 5 representing full AI-led code generation.

Move Fast Break Nothing: Dedy Kredo

Nov 8, 2023 · 13:01

Dedy Kredo, co-founder and CPO of CodiumAI, argues that code generation needs a GAN-like architecture with a separate code integrity critic, and that behavior coverage is a more useful metric than code coverage. He demonstrates CodiumAI's IDE extensions (200,000 installs) on the open-source AutoScraper project (5,000 GitHub stars with no tests), automatically mapping behaviors, generating tests for happy paths and edge cases, and using reflection to auto-fix failures. The tool then enhances code with deep improvements (performance, security) and, via a PR assistant, catches a forgotten API key vulnerability. Kredo closes with a personal note about the Hamas attack on Israel, showing his co-founder on reserve duty while CodiumAI usage continues to rise.

The AI Evolution: Mario Rodriguez, GitHub

Nov 7, 2023 · 19:32

Mario Rodriguez, VP of Product at GitHub, recounts the history and future of GitHub Copilot, the first at-scale AI programmer. Copilot now serves over 20,000 organizations and 1 million-plus developers, generating over $100M in ARR, with 46% of code written via completions. He shares insider lessons: ghost text, low latency under 100 milliseconds, and prompt engineering were key to success. He warns that 'syntax is not software' and that global presence and offline/online scorecards are essential at scale. Looking ahead, Rodriguez envisions moving from procedures to goals and constraints, enabling AI to reason on code, and designing immersive UIs for human-AI collaboration. He concludes that GitHub has evolved from a version control system into an end-to-end platform infused with AI.