Git

When Agents Meet Physical Data: The Other Physics of Agent Harnesses - Dmitry Petrov, DataChain

Jul 20, 2026 · 27:33

Dmitry Petrov of DataChain argues that AI agents fail on unstructured physical data because their intuitions assume cheap recompute, while large-scale video, sensor, and robot data requires a different harness. He cites Anthropic's finding that agents achieve only 21% accuracy on data projects without specific data harnesses, and OpenAI's need for six layers of context even on structured data. Petrov demonstrates DataChain, an open-source Python framework that uses Pydantic schemas to turn messy binary files into queryable databases, an execution engine for distributed processing, incremental checkpoints to avoid recomputing on failure, and a knowledge base of datasets and source code so agents can answer follow-up questions in seconds instead of reprocessing terabytes. In a live demo with Claude Code analyzing 90 dashcam videos, the harness took 24 minutes to extract 100,000 object records, then instantly answered 'how many clips have people?' without rerunning inference. Petrov emphasizes that the key is organizing metadata into star schemas and sharing data lineage across teammates so no one pays the compute cost twice.

The UX of AI: Making AI-Powered Apps Your Users Don't Hate - Kathryn Grayson Nanz, Progress Software

Jul 18, 2026 · 35:59

Kathryn Grayson Nanz, Senior Design and Developer Advocate at Progress Software, argues that the success of AI-powered applications now depends on user experience rather than model performance. She identifies five pillars—trust, clarity, control, transparency, and meaningful benefit—and provides concrete patterns: citing sources to build trust, streaming text for clarity, allowing undo and version history for control, requesting granular permissions for transparency, and offering templates and next-step actions to ensure meaningful benefit. She emphasizes that developers must design these patterns themselves because AI can only remix existing interfaces, and that users need gradual introduction to AI features to avoid disengagement. The talk stresses that without addressing these UX challenges, users will abandon AI tools after a few failed attempts.

Recursive Model Improvement — Lee Robinson, Cursor, SpaceXAI

Jul 15, 2026 · 20:32

Lee Robinson, head of ML at Cursor, explains how recursive model improvement accelerates AI training through inner and outer loops. The outer loop gathers user feedback and online metrics to refine evals, while the inner loop uses high-quality evals and difficult problems to climb performance. Composer 2.5, released in May, became Cursor's most popular model by balancing speed, intelligence, and cost. To scale, Cursor partners with SpaceX for compute via Colossus (122 days to build 100k GPUs) and develops textual feedback where a teacher model hints at improvements during RL rollouts. Robinson details reward hacking on public benchmarks and the creation of CursorBench, a private eval set. He envisions agent-based automation where researchers launch experiments from Slack and models train derivative models, creating a self-improving intelligence loop.

"The engineer of the future is the person who is able to choose what is worth doing." — Addy Osmani

Jul 14, 2026 · 18:26

Addy Osmani argues that the engineer of the future must shift from code production to accountability, judgment, and ownership as AI agents automate more work. He introduces Alpha (the gap between human and model capabilities) and Decay (the clock on that gap), warning that skills like speed and recall erode quickly, while taste—the ability to judge without objective metrics—decays more slowly but still fades. Osmani warns against cognitive debt (losing understanding of your codebase) and cognitive surrender (blindly accepting AI outputs, noting 73% of people felt more sure when AI was wrong). He advocates for an agency ladder where engineers move from flagging problems to discerning which paths deserve ownership, and proposes an operational rule: "explain it or don't ship it." Ultimately, he predicts that lower costs of building will unlock latent demand, moving the bottleneck from "can we build this" to "should this exist" and "can we answer for it."

Everything we knew about software has changed — Theo Browne, @t3dotgg ​

Jul 8, 2026 · 16:02

Theo Browne argues that AI model evolution—from Sonnet 3.5’s tool-calling to Opus 4.5's long-running tasks and Mythos's orchestration—requires engineers to think bigger and wider. He compares current developer habits to skeuomorphism in iOS 7, urging rejection of legacy constraints like Git's inability to commit environment files and terminal-centric workflows. Browne introduces a shifted tier system: what was a startup is now a side project; a Markdown file running on a cron job can replace a company's product. His own PR triage service became a Markdown file updated daily via cron. He advocates building breadth over depth—architecting products so users can extend features, enabling small teams to compete with AWS or Salesforce. 'If your idea doesn't feel stupid, it's because your idea is not big enough,' he concludes.

I Run a Fleet of AI Agents Across Three Machines. Here's What Broke. - Kyle Jaejun Lee, KRAFTON

Jul 8, 2026 · 9:11

Kyle Jaejun Lee runs a fleet of AI coding agents across three machines daily and reveals the scaling failures that emerged from a hierarchy of CEO, VP, manager, and worker agents. To overcome his own attention bottleneck, he separated context into entity-specific workspaces on disk and replaced context compaction with full resets that read handoff files. When moving beyond one machine, five things broke: agents doing work instead of delegating, TMUX panes too crowded to read, out-of-memory crashes from stacked Claude Code processes, colliding Git credentials across workspaces, and the MacBook dying mid-task. He offloaded long-running work to always-on Linux boxes, used Git commits and SSH to move context between machines, and consolidated review gateways onto a single always-on machine with Discord as a unified router. Unsolved challenges include consistent credentials, local-only tools, and resource scheduling—he plans to layer his orchestration on top of Kubernetes to handle compute, secrets, and tools.

Replacing 12K LoC with a 200 LoC Skill — David Gomes, Cursor

Apr 30, 2026 · 19:22

David Gomes shows how Cursor replaced 12,000 lines of code for Git WorkTrees and best-of-en features with roughly 200 lines of Markdown using agent skills and subagents. He explains the original implementation's complexity (15,000 lines deleted) and the new slash commands: /worktree, /best-of-en, /apply, /delete. Pros include less maintenance, ability to switch mid-chat, multi-repo support, and better judging with the parent agent stitching results. Cons: models sometimes forget to stay in the WorkTree over long sessions, perceived slowness, and reduced discoverability. He details future improvements through evals and RL training, plus a native WorkTrees implementation in Cursor 3.0 and exploration of non-Git parallelization primitives.

AgentCraft: Putting the Orc in Orchestration — Ido Salomon

Apr 25, 2026 · 11:18

Ido Salomon, creator of AgentCraft, argues that the bottleneck in multi-agent orchestration is not the agents but the humans managing them, and that the skills needed—borrowed from real-time strategy games—are already familiar to gamers. AgentCraft visualizes agents as physical units on a map that projects the file system, allowing users to see which files agents modify and detect collisions via a heat map. To reduce babysitting, Salomon implemented a campaign feature where agents autonomously decompose tasks and plan within containers, shifting the human role to review. Review bundles present changes with screenshots and videos for efficient inspection. Workspaces enable real-time collaboration between humans and agents across teams, with shared visibility and soft coordination. The goal is to raise the ceiling of collaboration through visibility, autonomy, and human-agent interaction.

Agentic Engineering: Working With AI, Not Just Using It — Brendan O'Leary

Apr 7, 2026 · 27:03

Brendan O'Leary, a Developer Relations Engineer at Kilo Code, argues that agentic engineering means shifting from using AI as a tool to working with it as a collaborator—like an energetic but inexperienced junior developer. He explains that context engineering—managing what goes into the model's context window—is critical, as too much or bad context degrades output quality. O'Leary recommends a research-plan-implement loop: first understand the system without writing code, then create a detailed plan, and finally execute in a fresh session to keep context lean. He advocates for configuring agents with role-based modes (Ask, Architect, Code), along with agents.md and skills files for persistent rules and reusable workflows. O'Leary also cautions against overusing MCP servers, which add token cost and can confuse the agent, and suggests isolating agent work via Git for easy review. The episode emphasizes that AI cannot replace thinking—it only amplifies the human's preparation and judgment.

Hard Won Lessons from Building Effective AI Coding Agents – Nik Pash, Cline

Dec 12, 2025 · 14:18

Nik Pash, head of AI at Cline, argues that frontier models have made clever agent scaffolds obsolete—capability now beats engineering tricks. He insists that real model improvement comes from benchmarks and RL environments, not from RAG or indexing systems. Pash details Cline's RL environment factory, which converts real-world coding tasks into training data by qualifying tasks, reconstructing environments, and defining pure outcome verifiers. He announces Clinebench, an open-source benchmark built from actual software development captured via Cline's provider, designed to measure and improve models on real tasks rather than synthetic puzzles. Pash urges the community to contribute by using Cline on open-source projects, turning model struggles into benchmark candidates.

Backlog.md: Terminal Kanban Board for Managing Tasks with AI Agents — Alex Gavrilescu, Funstage

Nov 24, 2025 · 14:19

Alex Gavrilescu presents Backlog.md, an open-source CLI tool that stores tasks as Markdown files in Git repos, featuring a terminal Kanban board and MCP server for AI agents. He argues that breaking features into atomic Markdown tasks prevents agents from running out of context or implementing unwanted extras. The demo shows Claude creating a task from requirements, generating an implementation plan, and coding a move-mode feature—all via MCP tools. Gavrilescu emphasizes two review checkpoints (after task creation and after the plan) and notes that Backlog.md itself is 99% AI-written. The tool works cross-platform, requires no external APIs, and syncs across branches via Git.

The Cure for the Vibe Coding Hangover — Corey J. Gallon, Rexmore

Nov 24, 2025 · 57:02

Corey J. Gallon presents a framework to cure the 'vibe coding hangover'—the despair of building unmaintainable demoware with AI coding agents. He argues that treating AI as a pure productivity tool leads to brittle code and dependency, so his framework centers on ten principles: AI engineering as accelerated learning, the architect-implementer boundary, slowing down to go fast, specification over prompt engineering, defining 'done' before implementing, feature atomicity, dependency-driven development, implementing one atomic feature at a time, context engineering, and 'make it work, make it right, make it fast.' The process splits into a planning phase (vision capture, feature identification, iterative specification, dependency analysis, implementation plan) and an implementation loop that uses multisensory feedback (visual, auditory, tactile) to validate each atomic feature. This framework has been used to build real applications such as litigation support for law firms and real-time appliance monitoring.

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.

Does AI Actually Boost Developer Productivity? (100k Devs Study) - Yegor Denisov-Blanch, Stanford

Jul 23, 2025 · 18:12

Yegor Denisov-Blanch from Stanford presents findings from a study of nearly 100,000 developers across 600+ companies, showing AI boosts developer productivity by an average of 15-20%, but the effect varies widely. The study measures functionality delivered, not commits, and reveals that AI introduces significant rework—bug fixes from AI-generated code. Productivity gains depend on task complexity, codebase maturity (Greenfield vs. Brownfield), language popularity, and codebase size: low-complexity Greenfield tasks see 30-40% gains, while high-complexity Brownfield tasks see only 0-10%. AI can even decrease productivity for low-popularity languages like COBOL or Haskell, and context window limitations reduce performance on larger codebases. The study provides data-driven guidance for when AI helps or hinders, with a matrix showing 20% gains for low-complexity common languages and minimal gains for complex niche ones.

Containing Agent Chaos — Solomon Hykes, Dagger

Jun 28, 2025 · 23:48

Solomon Hykes, creator of Docker and founder of Dagger, argues that containing agent chaos requires engineering reproducible execution workflows built on containerization applied to each step of an agent's workflow. He introduces 'container use'—agents developing inside fully isolated, customizable environments rather than just sandboxing outputs—and demonstrates a prototype using MCP to integrate with Claude Code and Goose. The system provides background work, rails, seamless human stepping in, and optionality by leveraging Dagger, Git-based state management, and ephemeral containers snapshotted per action. Hykes shows how agents can run parallel experiments, merge snapshots, and discard failed environments without pollution. The episode concludes with him open-sourcing the project as github.com/dagger/containeruse.

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.