How fast teams ship, how to measure it, and what AI changes.
Track code survival metrics to see the percentage of agent-written code that actually gets committed. GPT-4.1 started at 55%, while Claude Opus reached 86% over time. This increase clearly demonstrates growing developer trust and confidence in AI code generation.
▶ 1:20
How VS Code Went from Monthly to Weekly Releases with AI — Harald Kirschner
Individual developers universally report feeling more productive and note improvements in codebase quality when using AI tools. However, this individual boost does not automatically translate to organizational stability or better delivery outcomes.
▶ 2:11
AI is making software delivery less stable. DORA's Nathen Harvey on the fix | EVOLVE 2026
Acceptance rate only tracks whether a suggestion was taken, not whether that code actually runs in production or drives business value. Relying on it ignores whether developers had to heavily rewrite or debug the suggested code.
▶ 9:16
Measuring the impact of AI on software engineering – with Laura Tacho
Mitchell started programming early as a teenager motivated by video games, teaching himself using online code and printouts of the PHP manual. Without money for professional books, he learned through freely available online resources and trial and error.
▶ 2:52
Mitchell Hashimoto’s new way of writing code
Industry data shows that approximately ninety-two percent of developers use an AI coding assistant at least once a month. About seventy-five percent use one at least weekly, while AI-authored code hitting production has risen to nearly twenty-seven percent.
▶ 3:58
Data vs Hype: How Orgs Actually Win with AI - The Pragmatic Summit
Slack combines search and AI to handle massive enterprise data without hitting token limits. Search retrieves relevant raw messages while the LLM synthesizes them with citations, balancing recall and summarization.
▶ 10:51
How Slack AI Agents Accelerate Dev Productivity | Samuel Messing
If you are in a meeting where people keep talking over each other, a simple hack is to raise your hand or finger. You might be ignored at first, but participants will gradually catch on and start doing the same, leading to a much more civilized conversation. The most powerful moment is when you put your hand back down if your point becomes irrelevant.
▶ 1:37
Tech Truth: Agile Evolution & the Future of SW Engineering • Martin Fowler & Kent Beck • GOTO 2025
You can feed an agent relevant context and external posts, letting it gather information, synthesize options, and propose features. However, you must use your product judgment to filter its recommendations because it may suggest unfeasible or unsustainable directions.
▶ 2:32
Use AI to Make Product Decisions
Organizations start with simple initial wins where AI feels exceptionally fast. Next, teams apply AI to bigger problems, causing failures, bugs, and a loss of trust. Finally, teams build real skills by learning proper guardrails, prompting, and context engineering.
▶ 1:11
How to Get Your Org to Adopt Coding Agents (Without Shipping Garbage) — Eyal Blum, Figma
Unattended coding agents often focus purely on passing immediate tests without regard for good architecture or maintainability. Reinforcement learning relies on fast oracles, but code maintainability has no fast oracle to catch bad design decisions made by models. Consequently, codebases accumulate technical debt and slop that requires human intervention to clean up.
▶ 5:13
AI Agents Still Can't Maintain Your Codebase
Fast automated tests act as essential guardrails to catch regressions and prevent the AI agent from breaking or deleting code. Running in milliseconds, these test suites provide immediate feedback to keep the unpredictable genie in check.
▶ 49:59
TDD, AI agents and coding with Kent Beck
No, LLMs cannot currently carry a pager or fully handle incident response on their own. Despite unlimited tokens and proximity to researchers, reliability teams still rely heavily on human intervention for complex reasoning.
▶ 2:54
Anthropic Reliability Engineer EXPOSES the Limits of AI SRE
In the 2010s, engineering managers were explicitly told never to make technical decisions again, but today leaders must re-engage with technical details. Larson explains that getting back into writing software serves as a unique reskilling opportunity for modern middle managers facing a tough environment.
▶ 0:00
The revised rules of engineering management with Will Larson
The debate centers on whether a significant delta exists between the hype surrounding autonomous loops and what actually works in practice. While proponents view loops as an inevitable step toward software factories, skeptics argue that hype is outrunning discipline and requires careful human oversight.
▶ 1:22
The Great Loops Debate — Dex Horthy, Geoff Huntley, Ian Livingstone, Greg Pstrucha, @insecure-agents
After encountering an extremely buggy magazine viewer app, he offered to rewrite it and later extracted the PDF rendering component into a standalone product. He started selling it online after realizing other developers faced the same complex file format challenges.
▶ 10:06
The creator of OpenClaw: "I ship code I don't read"
The company wanted developer workstations to closely match their production environments, which have always run on Linux. Additionally, having the entire technical team use the custom distribution helps gather more hands and contributions for the open-source project.
▶ 7:56
DHH’s new way of writing code
Running the agent inside the sandbox simplifies state management because everything is localized, but it creates serious security risks because secrets must live in the box where the unpredictable AI can exfiltrate them. An out-of-the-box architecture separates the brain from the machine, using a worker control plane to operate the sandbox via tool calls, which secures your secrets despite adding architectural complexity.
▶ 12:09
Devin’s 80% Moment: Background Agents, 7x PRs, & End of Hand-Held Coding — Walden Yan & Cole Murray
Build systems must be re-tooled to complete in under a minute to accommodate the agent's need for fast feedback loops. If a build exceeds this time, developers decompose the build graph to keep the agent operating smoothly. This strict discipline prevents bloated build times and maintains code invariants.
▶ 6:13
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
Labs focused their reinforcement learning and reasoning efforts heavily on code generation throughout 2025. This culminated in November models crossing a reliability threshold where they execute instructions accurately almost all of the time. Instead of mostly working code requiring close attention, developers can now rely on agents to build complete applications reliably.
▶ 4:08
An AI state of the union: We’ve passed the inflection point & dark factories are coming
Uber initially saw a modest 10 to 15 percent bump in diff velocity using synchronous tab completion and IDE chat in 2022 and 2023. Over the past year, the paradigm shifted to peer programming, where developers hand off asynchronous workloads to AI agents and act as tech leads directing these agents. This allows engineers to delegate toil like dead code cleanup and library migrations to focus on creative work.
▶ 3:59
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
Test-driven development practices provide the necessary framework for verifying whether AI-generated code is actually correct. Since powerful AI models act like unpredictable genies, having strict tests ensures you can catch mistakes and make sure the tool is doing the right thing.
▶ 3:05
Martin Fowler & Kent Beck: Frameworks for reinventing software, again and again
You transition from writing every line to directing the agent and carefully reviewing its outputs. As models have improved in reliability, some teams have even moved to policies where developers neither write nor read the code directly. However, trusting an agent requires finding ways to have it prove its work functions correctly.
▶ 3:39
Simon Willison: Engineering practices that make coding agents work - The Pragmatic Summit
Heavy abstraction layers can trap you deep in call stacks when you try to push past 80% reliability. Instead, owning your control flow and building software from first principles gives you the flexibility needed for production.
▶ 0:50
12-Factor Agents: Patterns of reliable LLM applications — Dex Horthy, HumanLayer
Developers face high rework and codebase churn on brownfield projects because naive prompting fills the context window with noise. As context gets crowded, models enter the dumb zone and performance severely degrades.
▶ 0:57
No Vibes Allowed: Solving Hard Problems in Complex Codebases – Dex Horthy, HumanLayer
Repeatedly running a compiler or generator from a high-level specification without inspecting the code introduces software entropy. Each iteration adds complexity and drift, turning the code base into garbage rather than maintaining cleanliness.
▶ 1:50
"Software Fundamentals Matter More Than Ever" — Matt Pocock
Coding agents have shifted from a peripheral feature to taking center stage across the software development lifecycle. Developers are increasingly leveraging these tools because coding provides an exceptionally valuable and practical use case for AI automation. As a result, agentic workflows are now appearing everywhere in modern tooling.
▶ 8:52
Why AI Coding Agents Are Here To Stay | Patrick Debois
React was chosen because the speaker did not know the language, which enforced the rule of not touching the code directly and only using prompts. Additionally, frontier LLMs have extensive training data for React, making it exceptionally well-indexed and supported compared to more niche languages.
▶ 10:57
The Man Behind World’s Largest Dev Con | Stephan & Devoxx
Vibe coding fails because developers repeatedly prompt agents in single sessions, causing context loss and recurring issues. Without persistent specifications, you end up repeating the same instructions and stumbling over identical problems.
▶ 3:59
AI-First Project Management for Developers | Alex Gavrilescu on Backlog.md
Sentry uses embeddings to group errors like anonymous functions with random integers, replacing tedious regular expression rules. This lowers total work and achieves much closer matching compared to historical methods.
▶ 5:44
Transforming Debugging and Root Cause Detection with Sentry | David Cramer
Meta releases smaller, highly efficient models like Scout and Maverick first to prioritize low latency and intelligence per cost for internal products. Meanwhile, they are developing a massive Behemoth model exceeding two trillion parameters, which developers may access through model distillation since running it directly as a consumer model is impractical.
▶ 1:50
Mark Zuckerberg — AI will write most Meta code in 18 months
Brian used Claude Code to break up a scalability lock in the Helios kernel without closing the loop or letting it build autonomously. He spent two hours instead of four, benefiting from the model's ability to read block comments and understand a custom codebase.
▶ 10:03
Oxide and Friends 1/12/2026 -- Engineering Rigor in the LLM Age
Building a plugin limits the control you have over the editing environment as AI capabilities advance. Forking VS Code allows the team to innovate deeply on both the UX and model integration simultaneously.
▶ 11:57
Cursor Team: Future of Programming with AI | Lex Fridman Podcast #447
The production team used a computer-controlled camera system called a DijkstraFlex to repeat exact camera movements. This allowed them to shoot models in layers and combine them into seamless shots without humans in the loop.
▶ 0:53
The next era of AI coding
Instruct the model to generate an ASCII diagram detailing data flows, state machines, and dependencies before writing code. This forces the agent to load comprehensive context into latent space and prevents incomplete implementations. Garry Tan discovered this practice prevents agents from writing buggy or superficial code.
▶ 10:37
Tokenmaxxing: How Top Builders Use AI To Do The Work Of 400 Engineers
Large tech incumbents and AI labs are often burdened by operations, product managers, and slow PRD review processes that delay shipping. In contrast, early-stage startups can leverage relentless execution and rapid iteration to capture market feedback. For instance, Cursor famously utilized one-day sprint cycles to ship updates daily, outmaneuvering slower competitors.
▶ 6:13
The 7 Most Powerful Moats For AI Startups
Generalization limits and persistent sim-to-real gaps could block true agent generalization. Additionally, failing to solve continual learning or models failing to check themselves can stall progress. These obstacles mean models might continue to feel dumb after short cycles rather than exploding in capability.
▶ 1:37
AI researchers debate how close we are to recursive self-improvement
Tool seeds are compressed prompts capturing the dialogue used to build a custom tool with an AI. Instead of packaging and distributing traditional software binaries, you share the prompt, which instantly adapts to the recipient. This revives the Smalltalk tradition of building specialized tools on the fly.
▶ 6:30
The Augmented Forest • Kent Beck• GOTO Copenhagen 2026
You can use the advisor strategy to separate execution from advising. A smaller, cheaper model handles execution while a larger model like Opus acts as an advisor when needed. This approach delivers frontier-level quality at a fraction of the cost.
▶ 22:22
Code with Claude London 2026: Opening Keynote
AI companies are expanding past traditional software budgets by evolving from simple co-pilots into autopilots that sell direct outcomes. This progression allows them to tap into massive labor budgets rather than being restricted to the global software TAM.
▶ 0:02
AI's Trillion-Dollar Opportunity: Sequoia AI Ascent 2025 Keynote
He noticed that the latest AI models were outputting correct code chunks reliably without needing corrections. This realization led him down a rabbit hole of building endless side projects entirely through prompting.
▶ 1:28
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
Standard models help guide our thinking in AI engineering similarly to MVC or CRUD in traditional software. Examples include architectural designs, software development life cycles, and agent interaction frameworks.
▶ 28:07
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
You can practice systems thinking by having an agent help you sketch out the components and architecture of apps you already use. Talk through how the application's pieces communicate and have the agent create visuals while you push back. This builds the mindset of designing systems before coding.
▶ 0:48
How I'd Get Into Software in 2026
Relying 100% on vibe coding without knowing your codebase, variable names, or architecture causes development to eventually break down. Without a mental map of the code, you cannot give accurate hints or fix issues when agents fail. This leads developers into a frustrating cycle of failure.
▶ 0:25
When to prompt and when to code
Offload heavy agent workloads to a remote Linux machine rather than your primary computer to avoid bottlenecks. You can set up a server on a separate Linux box that handles your codebases and code servers. This keeps your local laptop free for other tasks without performance drops.
▶ 5:09
You're using AI agents wrong
An LLM on its own can only generate text tokens without any way to execute real-world actions. A harness provides the environment, syntax, and tools like file editing and command execution that allow the model to act. Without it, an LLM is like a chef placed in an empty kitchen with no utensils.
▶ 10:38
My last video about ai harnesses
AI coding agents are rapidly improving and commoditizing the execution phase of software development. As building to spec becomes cheap and automated, developers face a shift where simply writing code no longer differentiates their value. Instead, the primary challenge moves from figuring out how to build something to determining if it is actually worth building.
▶ 10:54
Build the Right Thing: Product Engineering (Part 1) — Kent C. Dodds, EpicProduct.engineer
ULMFiT introduces a three-stage architecture using a general-purpose corpus for pre-training before task-specific supervised fine-tuning. This approach heavily relies on robust regularization techniques and discriminative learning rates across different model layers. Jeremy Howard found that this transfer learning methodology vastly outperformed highly specialized models on classification tasks.
▶ 4:30
The Dangerous Illusion of AI Coding? - Jeremy Howard
Create living documentation like agents.mmd files that give agents lightweight maps of the codebase. These documents should evolve as agents make mistakes and help guide them effectively.
▶ 5:05
How VS Code Went from Monthly to Weekly Releases with AI — Harald Kirschner
AI acts primarily as an organizational amplifier, magnifying both the good practices and existing flaws across the SDLC. Without a strategic focus on underlying systems, localized productivity pockets are simply swallowed by downstream chaos.
▶ 5:18
AI is making software delivery less stable. DORA's Nathen Harvey on the fix | EVOLVE 2026
Data from over 180 companies shows that stack trace analysis and refactoring existing code save more time than midloop code generation. Developers spend significant time reviewing generated code, whereas debugging error outputs provides a direct net positive time savings.
▶ 24:34
Measuring the impact of AI on software engineering – with Laura Tacho
He landed his first job after blogging during his freshman year of college, which caught the attention of a Ruby on Rails consultancy looking for developers. Despite not knowing Ruby or Rails yet, he met with them in person and took the job, learning various technologies on the fly.
▶ 5:50
Mitchell Hashimoto’s new way of writing code
AI dramatically reduces onboarding time, cutting the time to a developer's tenth pull request in half between 2024 and late 2025. Furthermore, research shows that these initial productivity gains stick with engineers for at least their first two years at a company.
▶ 6:28
Data vs Hype: How Orgs Actually Win with AI - The Pragmatic Summit
Slack enforces security by running real-time permission checks on search results before passing any data to the LLM. They avoid training models on internal data, relying instead on permissioned context windows.
▶ 14:43
How Slack AI Agents Accelerate Dev Productivity | Samuel Messing
Vibe coding is using AI genies to build ambitious projects that were previously too time-consuming to tackle manually. It lets developers focus on high-level skills like defining a distant vision, choosing what to build, and optimizing feedback loops. While it removes language barriers and allows you to work in unfamiliar languages, you still have to watch out for small-scale details and confidently incorrect AI behavior.
▶ 7:44
Tech Truth: Agile Evolution & the Future of SW Engineering • Martin Fowler & Kent Beck • GOTO 2025
You need to be extremely protective about bringing new abstractions into your system because removing primitives later is difficult due to user reliance and intertwined features. Ask the agent whether an existing primitive can handle the requirement before adding something new.
▶ 6:24
Use AI to Make Product Decisions
Engineers often lose job satisfaction and burn out when reduced to prompt cycles waiting for AI outputs. Meanwhile, senior engineers holding institutional knowledge become overwhelmed bottlenecks trying to prevent bad agent code from entering the codebase.
▶ 2:57
How to Get Your Org to Adopt Coding Agents (Without Shipping Garbage) — Eyal Blum, Figma
Slop Code Bench evaluates models by disclosing challenges in incremental bits and making the model write code iteratively over multiple features rather than solving the entire problem all at once. This mimics real-world software evolution and reveals that top models score relatively low on maintaining clean codebases over time. The benchmark demonstrates that unsupervised coding workflows still struggle significantly with long-term code quality.
▶ 6:30
AI Agents Still Can't Maintain Your Codebase
AI tools grant your wishes for features or code changes, but often in unexpected or perverse ways that do not match your true intent. This dynamic creates an addictive intermittent reinforcement loop similar to playing a slot machine.
▶ 6:44
TDD, AI agents and coding with Kent Beck
LLMs excel at superhuman signal gathering by querying metrics, reading logs, and finding needles in haystacks. They can run parallel PromQL queries rapidly and process thousands of log lines without getting tired.
▶ 11:02
Anthropic Reliability Engineer EXPOSES the Limits of AI SRE
Yahoo predated modern open-source libraries and maintained its own forks like Y Apache, YPHP, and Yinst for package management. Because top leadership manually approved server allocations to drive accountability, it inadvertently created a massive black market where teams hoarded outdated, power-inefficient servers.
▶ 10:35
The revised rules of engineering management with Will Larson
Proponents view loops as a new programmable CPU architecture that dramatically accelerates development time and lowers costs. By treating software development as a repeatable loop, teams can efficiently automate tasks and autonomously port code across stacks.
▶ 4:40
The Great Loops Debate — Dex Horthy, Geoff Huntley, Ian Livingstone, Greg Pstrucha, @insecure-agents
Frustrated by a dating website's mobile limitations and lack of copy-paste, he downloaded Xcode and used regular expressions to parse the HTML directly. He put the app in the App Store for five dollars and made 10k in the first month.
▶ 6:05
The creator of OpenClaw: "I ship code I don't read"
Apple initially refused to approve the app unless 37signals paid a thirty percent toll fee, which could have been a death sentence for the mobile-dependent service. After a tense two-week standoff coinciding with WWDC, Apple allowed the app through and gave it massive publicity, resulting in tens of thousands of signups.
▶ 12:07
DHH’s new way of writing code
Full VMs are necessary because Docker containers are not true security boundaries and running applications inside Docker introduces nested configuration issues. Full VMs support complex testing workflows, running full applications, and even nested virtualization for Android emulators. However, you can still use Docker for your infrastructure setup since developers are already familiar with it.
▶ 17:35
Devin’s 80% Moment: Background Agents, 7x PRs, & End of Hand-Held Coding — Walden Yan & Cole Murray
Developers spawn the coding agent as the primary entry point rather than setting up a predefined environment first. The agent uses provided skills and scripts to boot the necessary local development stack and configure its own environment variables. This approach allows reasoning models to make intelligent choices rather than operating inside a rigid box.
▶ 11:37
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
Vibe coding is a hands-off approach where you do not look at or understand the code, making it suitable for personal prototypes. In contrast, agentic engineering is a professional discipline for building production-ready software using autonomous coding agents that write, debug, and test code. This requires deep software experience to ensure the results are safe and deployable.
▶ 8:57
An AI state of the union: We’ve passed the inflection point & dark factories are coming
As soon as agentic workflows were made available, 70 percent of the workloads pushed by developers were toil tasks. This happened because the start and end states of tasks like library upgrades and migrations are straightforward, leading to much higher accuracy. Because of this success, tackling toil with AI became a top priority for the developer platform.
▶ 6:45
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
Senior engineers need to maintain absolute skepticism combined with relentless curiosity to properly evaluate new technologies. Instead of accepting hype or rejecting tech outright, you should run the smallest experiments possible to validate claims to your own satisfaction.
▶ 11:41
Martin Fowler & Kent Beck: Frameworks for reinventing software, again and again
Starting sessions with red-green TDD instructions prevents agents from writing more code than necessary. Because automated tests are effectively free with AI, writing tests first dramatically increases the chances of getting working code. This approach eliminates the historical friction of TDD while keeping the agent focused on a minimal implementation.
▶ 5:56
Simon Willison: Engineering practices that make coding agents work - The Pragmatic Summit
Blindly appending error stack traces to the context window causes agents to spin out and lose context. Instead, clear pending errors and summarize them so the model receives clean input for the next valid tool call.
▶ 10:46
12-Factor Agents: Patterns of reliable LLM applications — Dex Horthy, HumanLayer
Intentional compaction involves asking the agent to compress its current context down into a markdown file. This allows a new agent to start straight to work with exact file references instead of searching from scratch.
▶ 3:53
No Vibes Allowed: Solving Hard Problems in Complex Codebases – Dex Horthy, HumanLayer
Bad code is actually more expensive than ever because it prevents you from leveraging the speed and power of AI. Maintaining a high-quality code base is essential because AI performs exceptionally well only within clean, structured environments.
▶ 3:43
"Software Fundamentals Matter More Than Ever" — Matt Pocock
The rapid advancement of AI technology means that developers must constantly reinvent how they use these tools rather than relying on outdated habits. Sticking to simple code completions prevents teams from embracing new paradigms like agents and specifications. Every six months, a new set of tools unlocks entirely different ways of working.
▶ 11:50
Why AI Coding Agents Are Here To Stay | Patrick Debois
After two weeks of pure vibe coding, the app hit a wall at 90% functionality while trying to integrate features like dark themes and Firebase services. The LLM ended up creating too many redirections and abstraction layers, resulting in slow, unmaintainable spaghetti code.
▶ 12:08
The Man Behind World’s Largest Dev Con | Stephan & Devoxx
You must break down giant markdown requirements into smaller, atomic markdown tasks similar to Jira tickets. This prevents context degradation and allows you to easily roll back single tasks if something goes wrong.
▶ 7:20
AI-First Project Management for Developers | Alex Gavrilescu on Backlog.md
Seer combines interconnected telemetry data like traces and logs, feeding them into LLMs to perform root cause analysis. Although early versions hallucinated, the model successfully helps diagnose complex production bugs by mimicking the deep theory crafting of senior engineers.
▶ 8:02
Transforming Debugging and Root Cause Detection with Sentry | David Cramer
Meta found that standard open-source benchmarks are easily gameable and often skewed toward use cases that do not reflect normal user behavior. By anchoring their north star on actual user value and product feedback, they achieve higher quality engagement than by tuning models to top leaderboards.
▶ 7:10
Mark Zuckerberg — AI will write most Meta code in 18 months
Rain used an LLM as a pattern amplification machine to replicate map APIs and thousands of lines of doc tests across four different Rust map types. This reduced what would have been weeks of tedious manual work into less than a day of effort.
▶ 19:45
Oxide and Friends 1/12/2026 -- Engineering Rigor in the LLM Age
Cursor Tab goes beyond standard autocomplete by predicting entire future changes and diffs based on recent context. It uses sparse Mixture of Experts models and aggressive KV caching to maintain high performance with low latency.
▶ 16:26
Cursor Team: Future of Programming with AI | Lex Fridman Podcast #447
Developers have had to translate high-level thoughts into verbose, step-by-step logic like conditional statements and loops. This manual translation takes huge amounts of time and makes simple features require tens of thousands of lines of code.
▶ 2:39
The next era of AI coding
Use Codex when you encounter complex architectural problems that require a higher intelligence model to audit your codebase. Claude Code is ideal for fast iteration, but Codex acts as a 200 IQ reviewer to catch hidden bugs. You can invoke it via a skill command to analyze your repository and report issues back to your main agent.
▶ 17:37
Tokenmaxxing: How Top Builders Use AI To Do The Work Of 400 Engineers
While a basic demo can be hacked together in a weekend, real-world utility requires navigating complex edge cases and maintaining extreme reliability. Process power is earned by meticulously refining AI agents over years to handle high-stakes environments like banking KYC and loan origination. This relentless execution of the final 5% consistency creates a massive barrier against casual competitors.
▶ 10:34
The 7 Most Powerful Moats For AI Startups
Distillation serves as the primary force countering centralization by allowing smaller players to copy powerful behaviors. Because capabilities learned through reinforcement learning require few bits, they can be easily transferred to smaller models. Furthermore, synthetic data generation and router services help provide the necessary prompt distributions for effective distillation.
▶ 18:51
AI researchers debate how close we are to recursive self-improvement
AI tools function purely as multipliers rather than neutral solutions, amplifying whatever is already happening in a team. If an organization operates under scarcity and burnout, the AI accelerates those negative traits. Conversely, a healthy, resource-rich environment uses the AI to explore variations and learn.
▶ 17:42
The Augmented Forest • Kent Beck• GOTO Copenhagen 2026
You can use MCP tunnels to connect Claude Managed Agents to internal servers behind your private network firewall. This routes requests securely without exposing your MCP servers over the public internet. This setup can be configured directly in the cloud developer console.
▶ 24:47
Code with Claude London 2026: Opening Keynote
The global internet population and active social platforms have created ready distribution rails with virtually zero barriers to adoption. Unlike past transitions where people needed active convincing, billions are already connected and paying attention from day one.
▶ 0:02
AI's Trillion-Dollar Opportunity: Sequoia AI Ascent 2025 Keynote
Software 1.0 relies on explicit rules written by humans, whereas Software 3.0 uses LLMs as interpreters. In the Software 3.0 paradigm, programming shifts to prompting and managing what is inside the context window.
▶ 2:35
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
You can generalize repetitive scraping and summarization tasks into a pattern called SPA, which stands for sync, plan, and analyze or reduce. This model allows you to execute thousands of AI calls to serve a specific application purpose efficiently.
▶ 33:31
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Communicating intent means focusing on the what and the why of a problem rather than the implementation details. You must clearly define the outcome, who it is for, and outline strict constraints. Failing to do this forces agents to guess, which leads to gaps and corners you cannot get out of.
▶ 1:48
How I'd Get Into Software in 2026
Non-technical people or beginners struggle with vibe coding because fixing broken agent outputs requires distilling years of engineering experience into a few lines. Without a background in software engineering and debugging, explaining how to fix a bad AI output is extremely difficult.
▶ 1:07
When to prompt and when to code
Burn more tokens by having AI models thoroughly audit the pull request before you set up an environment to test it yourself. This helps catch obvious failures and issues upfront, reducing the chance of hitting a demotivating broken state. Using Linux also helps by allowing you to run parallel tasks smoothly without system friction.
▶ 12:31
You're using AI agents wrong
Built-in tools are tightly coupled and require shipping code directly inside a specific harness. In contrast, MCP servers act as external bindings or cookbooks that let agents interface with data through a generic contract. This abstraction allows external systems to coordinate multiple harnesses without altering their execution logic.
▶ 21:09
My last video about ai harnesses
A product engineer acts as a bridge by connecting a deep understanding of customer needs directly to technical choices. Rather than just blindly turning tickets into implementations like an agent, they take ownership of architecture, workflows, and system constraints. They live both in the technology and in the user's world to ensure the software actually solves real human problems.
▶ 21:31
Build the Right Thing: Product Engineering (Part 1) — Kent C. Dodds, EpicProduct.engineer
Language models operate by fitting complex curves across massive multidimensional training data, meaning they rely on interpolation rather than true reasoning. When a prompt pushes the model outside this known distribution, its representations collapse and it loses basic understanding. Thus, what appears to be creativity is merely compositional interpolation of existing human knowledge.
▶ 20:24
The Dangerous Illusion of AI Coding? - Jeremy Howard
Encode expert knowledge into skills that anyone or any agent can use, such as accessibility best practices. This unblocks teams by scaling insights that were previously locked with single experts.
▶ 5:48
How VS Code Went from Monthly to Weekly Releases with AI — Harald Kirschner
While individual effectiveness increases alongside AI adoption, software delivery instability rises as well. Delivery instability tracks metrics like the frequency of rollbacks and the volume of unplanned rework required after deployment.
▶ 9:38
AI is making software delivery less stable. DORA's Nathen Harvey on the fix | EVOLVE 2026
Research by Dora reveals that AI accelerates the coding tasks that developers actually enjoy doing. This leaves them with a higher proportion of unpleasurable work like toil, meetings, and administrative duties.
▶ 31:08
Measuring the impact of AI on software engineering – with Laura Tacho
Vagrant was created to solve the problem of wasting billable hours setting up inconsistent development environments for short-term clients. By using free virtualization tools, he could quickly spin up reproducible local environments to help teams without wasting half a day on setup.
▶ 12:56
Mitchell Hashimoto’s new way of writing code
AI acts as an organizational multiplier that drives teams in opposite directions depending on their prior health. Dysfunctional organizations experience twice as many customer-facing incidents, while healthy systems see fifty percent fewer incidents.
▶ 8:59
Data vs Hype: How Orgs Actually Win with AI - The Pragmatic Summit
The team built internal Model Context Protocol integrations to let coding assistants safely query internal databases and analytics. This helps developers navigate historical context and generate correct SQL queries without hallucinating schemas.
▶ 19:11
How Slack AI Agents Accelerate Dev Productivity | Samuel Messing
Scaled agile frameworks often come with big costs and risks, and organizations naturally try to slow down change. To make large teams more agile, you should focus on improving the communication path between development teams and their users or customers. Additionally, you should analyze the flow of work, find where queues and bottlenecks are, and systematically cut them in half over time.
▶ 19:32
Tech Truth: Agile Evolution & the Future of SW Engineering • Martin Fowler & Kent Beck • GOTO 2025
Ask the agent how proposed features affect cost and entitlements to prevent users from abusing the system and exceeding revenue. For instance, storing data in durable objects versus object storage can lead to vastly different cloud infrastructure bills.
▶ 7:45
Use AI to Make Product Decisions
Shifting verification left from humans to agents prevents bad code and unlocks major productivity gains. For instance, tools like Playwright and MCP allow agents to autonomously explore and verify code instead of relying on human navigation.
▶ 5:04
How to Get Your Org to Adopt Coding Agents (Without Shipping Garbage) — Eyal Blum, Figma
Spending 20 to 30 minutes up front on planning and architecture drastically cuts down the time and friction required during code review. YOLO prompting with a two-sentence instruction usually results in a high probability of having to fix or rework code later. Writing a more detailed spec reduces the expected pain and likelihood of major agentic hallucinations.
▶ 9:17
AI Agents Still Can't Maintain Your Codebase
Mundane implementation details and syntax memorization become largely irrelevant because AI handles boilerplate and package management. Instead, architectural vision, setting milestones, and managing system complexity become vastly more leveraged skills.
▶ 11:35
TDD, AI agents and coding with Kent Beck
Instead of opening a blank chat, engineers should pass the alert's infrastructure-as-code expression directly to the AI agent. Instructing the agent to be curious allows it to quickly check endpoints, regions, and historical traffic patterns.
▶ 30:16
Anthropic Reliability Engineer EXPOSES the Limits of AI SRE
The team made aggressive technical decisions by adopting Cassandra to replace sharded MySQL without proper load testing beforehand. The system suffered from critical performance failures and a memory leak caused by a mutable default parameter in a Python API service.
▶ 20:12
The revised rules of engineering management with Will Larson
Skeptics point out that throwing more tokens at problems makes infinite loops economically unsustainable for larger companies over time. Furthermore, compounding error rates mean that non-deterministic verification can rapidly degrade output quality across multiple iterations.
▶ 14:46
The Great Loops Debate — Dex Horthy, Geoff Huntley, Ian Livingstone, Greg Pstrucha, @insecure-agents
Custom pricing allows vendors to assess a company's size and willingness to pay, ensuring the price reflects the differing value a freelancer versus a Fortune 500 company gets. If the price is too low, large enterprises view it as fishy, while a fixed low price excludes big buyers.
▶ 22:29
The creator of OpenClaw: "I ship code I don't read"
Designers at the company are not restricted to just creating visual specs; they also act as product managers by figuring out what to build. Furthermore, they are responsible for implementing their designs directly using CSS, HTML, and sometimes JavaScript or Ruby code.
▶ 23:27
DHH’s new way of writing code
Testing is a complex problem-solving challenge rather than simple computer use because it requires orchestrating multiple services, managing correct code versions, and triggering specific features. Agents need full codebase context to understand how to run applications together, handle admin states, or use feature flags. In some cases, systems even require orchestrating different frontier models together to solve these end-to-end tasks.
▶ 21:32
Devin’s 80% Moment: Background Agents, 7x PRs, & End of Hand-Held Coding — Walden Yan & Cole Murray
The authoring agent is explicitly instructed to evaluate review feedback and given the flexibility to either defer or push back. Without this permission, coding models tend to blindly follow all instructions and can fail to converge with automated PR reviewers. Providing a scoring framework helps the agent prioritize and handle feedback appropriately.
▶ 15:28
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
Teams implement the dark factory pattern by using a swarm of agent testers that simulate end users interacting with the system around the clock. To bypass rate limits on real third-party platforms, they use coding agents to build complete local API simulations of external tools. This enables robust, automated quality assurance without anyone directly reading the codebase.
▶ 15:35
An AI state of the union: We’ve passed the inflection point & dark factories are coming
Uber built a central MCP gateway using a tiger team to proxy both external and internal MCPs from service infrastructure. It exposes these services consistently to engineers while managing authorization, telemetry, and logging. Additionally, they provide a registry and sandbox so developers can discover, test, and ensure new MCPs work as expected.
▶ 9:53
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
AI acts as an amplifier rather than a wholesale replacement for developers. It creates a golden age for junior programmers who learn fast, while putting pressure on the middle tier who may struggle to find their footing amid broader economic headwinds.
▶ 18:55
Martin Fowler & Kent Beck: Frameworks for reinventing software, again and again
Passing an automated test suite does not guarantee that a server will successfully boot or function in practice. To catch these issues, instruct the agent to run the server in the background and exercise the API using curl commands. Tools like Showboat can even generate markdown documentation tracking these manual test results.
▶ 7:24
Simon Willison: Engineering practices that make coding agents work - The Pragmatic Summit
While massive context windows can accept millions of tokens, they yield noisier results compared to curated inputs. Controlling and limiting the tokens in your context window consistently produces tighter and higher-reliability outcomes.
▶ 6:33
12-Factor Agents: Patterns of reliable LLM applications — Dex Horthy, HumanLayer
Subagents should be used for controlling context rather than anthropomorphizing roles like front-end or backend. A subagent forks a separate context window to search code, returning only a succinct message to the parent agent.
▶ 6:43
No Vibes Allowed: Solving Hard Problems in Complex Codebases – Dex Horthy, HumanLayer
You can use a rigorous prompting skill like Grill Me to force the AI to interview you relentlessly about every aspect of the plan. This resolves dependencies across the design tree and ensures you and the AI share an invisible mental theory before writing code.
▶ 5:57
"Software Fundamentals Matter More Than Ever" — Matt Pocock
Specifications are becoming more important than code because modifying a spec allows you to regenerate the entire codebase cleanly from it. They act like a guide that aligns both human teams and AI models on the desired behavior and structure. By feeding detailed requirements into the workflow, specifications directly drive the code generation process.
▶ 19:16
Why AI Coding Agents Are Here To Stay | Patrick Debois
To move toward a spec-driven approach, the speaker fed the existing React application into multiple CLI tools to generate detailed markdown specifications for each feature. Using several frontier models to review and refine these specs ensured they were clear enough to guide subsequent implementation in Angular.
▶ 16:32
The Man Behind World’s Largest Dev Con | Stephan & Devoxx
You can install Backlog.md globally using Bun, npm, or Homebrew so it is available across all folders. Running backlog init lets you configure a project name and select agent instructions for your preferred AI tool.
▶ 9:55
AI-First Project Management for Developers | Alex Gavrilescu on Backlog.md
Cursor allows developers to incrementally review diffs and seamlessly jump between files within the editor. In contrast, terminal interfaces create high-friction endless logs that make code review difficult. Therefore, human-in-the-loop workflows are much more effective inside a proper IDE.
▶ 26:28
Transforming Debugging and Root Cause Detection with Sentry | David Cramer
Meta predicts that within the next 12 to 18 months, AI will author most of the code directed toward its development efforts. Moving beyond basic autocomplete, these specialized coding agents will take high-level goals, run tests, fix issues, and outperform average human engineers.
▶ 13:38
Mark Zuckerberg — AI will write most Meta code in 18 months
Reviewing AI code requires transitioning from a passive reading mode into a heightened state of alert, similar to running a pre-flight checklist. Developers must carefully scrutinize the output, as engaging deeply helps catch subtle mistakes and preserve software rigor.
▶ 24:12
Oxide and Friends 1/12/2026 -- Engineering Rigor in the LLM Age
The team experimented with several UI iterations, including crossed-out lines and holding the option key to reveal changes. They are now focusing on helping developers verify large diffs by highlighting important sections and graying out repetitive parts.
▶ 24:48
Cursor Team: Future of Programming with AI | Lex Fridman Podcast #447
Software is designed to serve users simply through buttons and straightforward interfaces, masking the tens of millions of lines of underlying code. Unlike physical structures like Gothic cathedrals, software does not wear its massive structural weight on its sleeve.
▶ 3:17
The next era of AI coding
You can wrap Microsoft's Playwright framework into a persistent CLI daemon to test user interfaces automatically. This gives your agent a black box browser capability to verify data mutations and execute end-to-end QA. It replaces slow browser extensions with an efficient command-line tool.
▶ 15:46
Tokenmaxxing: How Top Builders Use AI To Do The Work Of 400 Engineers
Forward-deployed engineers embed directly with enterprise customers to understand boring, manual workflows and translate them into software. By working closely with clients who lack access to good software, startups capture tailored time-in-motion data. This custom operational knowledge eventually feeds into proprietary prompts, evals, and fine-tuned models.
▶ 16:44
The 7 Most Powerful Moats For AI Startups
It is relatively easy to create difficult, puzzle-like environments for benchmarking, but pushing on the realism axis is much harder. Realistic settings require multi-step interactions and human feedback to properly shape model behavior. Without these realistic environments, distillation often results in student models that match teachers only on narrow benchmarks.
▶ 25:09
AI researchers debate how close we are to recursive self-improvement
The desert assumes constant scarcity of time, skills, and stability, making practices like paying down technical debt seem illogical. The forest operates on the assumption that there will be enough resources, encouraging developers to create resources for the next round. While the desert leads to burnout and fragility, the forest sustains long-term progress.
▶ 14:34
The Augmented Forest • Kent Beck• GOTO Copenhagen 2026
Yes, you can configure Claude Managed Agents to use self-hosted sandboxes instead of public infrastructure. When an agent needs to execute work, it queues a work item that is picked up by your chosen provider such as Vercel or Modal. This allows you to run tasks securely on your own servers.
▶ 24:35
Code with Claude London 2026: Opening Keynote
Startups should approach product development from the customer back by targeting vertical-specific, complex problems that require human-in-the-loop interactions. Building proprietary data flywheels and deep industry trust helps secure a market position foundation models cannot easily invade.
▶ 0:02
AI's Trillion-Dollar Opportunity: Sequoia AI Ascent 2025 Keynote
Instead of executing a complex shell script designed for various platforms, the installation relies on a simple snippet of text copied into an agent. The agent uses its own intelligence to inspect the environment and execute the setup loop.
▶ 3:52
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
GitHub Copilot is transitioning from a sidekick into an actual peer programmer that operates directly within your branch. Because it is grounded in your codebase and patterns, it can run tests, understand team domains, and handle tasks until completion.
▶ 38:27
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Instead of reviewing raw code line by line, you should encode your intent directly into automated tests. Give the agent a mechanism for verifying its own work against those tests. This collaboration makes the agent much more effective at building the right thing.
▶ 2:46
How I'd Get Into Software in 2026
You should write code yourself when prompts become longer and more complicated than the actual fix. The ideal balance is using AI to write boilerplate code you want to avoid, while maintaining enough architectural understanding to halt the agent and redirect it when it goes off track.
▶ 1:29
When to prompt and when to code
Use fast or cheap AI models to audit and prioritize your open pull requests and background threads automatically. You can also use thread features like settling or snoozing to clear out completed work or hide distractions from your sidebar. When an AI response is too complex, ask it to simplify the explanation to avoid cognitive fatigue.
▶ 16:26
You're using AI agents wrong
Software development has progressively shifted upward through layers of abstraction to eliminate tedious manual work. Developers once worried about low-level instruction sets and syntax, but modern languages, linters, and AI assistance handle those details. Consequently, engineers no longer need to obsess over formatting or memorize fundamental algorithms.
▶ 5:04
My last video about ai harnesses
AI agents lack the human judgment to push back on scope creep and will rapidly accelerate bad practices and system bloat throughout a codebase. Because agents execute instructions so quickly, they can easily build the wrong thing at high velocity without pausing to check edge cases or scalability. Developers must actively slow down and exercise systems thinking to wrangle agents and maintain product quality.
▶ 18:41
Build the Right Thing: Product Engineering (Part 1) — Kent C. Dodds, EpicProduct.engineer
Relying on AI coding tools creates a false illusion of control and productivity while leaving developers with code nobody truly understands. Studies show that vibe coding often decreases actual shipping productivity and introduces severe long-term maintenance risks. Software engineering requires rigorous design and understanding rather than blindly pulling a slot machine lever.
▶ 48:14
The Dangerous Illusion of AI Coding? - Jeremy Howard
Switch to TypeScript Go to prevent CI/CD bottlenecks from compounding when running multiple agents concurrently. This upgrade provided a tenfold improvement in build speeds, which is crucial for fast feedback loops.
▶ 7:03
How VS Code Went from Monthly to Weekly Releases with AI — Harald Kirschner
Engineering talent should pivot from churning out features to investing in quality internal platforms and guardrails. These platforms establish trust, reduce operational friction, and safely enable non-engineers to solve problems.
▶ 12:13
AI is making software delivery less stable. DORA's Nathen Harvey on the fix | EVOLVE 2026
Measuring AI impact requires a holistic framework that tracks utilization, impact, and cost across the lifecycle. Because system data alone cannot capture cognitive load or flow state, combining workflow metrics with developer sentiment surveys is essential.
▶ 13:28
Measuring the impact of AI on software engineering – with Laura Tacho
HashiCorp bet on a multicloud future despite AWS being the dominant player because they believed any economically massive market would naturally attract competitors. Their conviction was that other tech giants like Microsoft and Google would inevitably enter the cloud space, making cloud-agnostic tools necessary.
▶ 17:50
Mitchell Hashimoto’s new way of writing code
While individual tool adoption is over ninety percent, organizations struggle because deep transformation is uncomfortable and often abandoned. Applying AI only to individual coding tasks creates a low ceiling of productivity rather than driving true bottom-line results.
▶ 10:43
Data vs Hype: How Orgs Actually Win with AI - The Pragmatic Summit
Teams can use scripts powered by models like Claude Code to incrementally migrate old code bases into modern languages like TypeScript. For instance, Slack converted over 50% of its legacy JavaScript to TypeScript in just six months. The trade-off is ensuring developers share and tune prompts so the agent matches internal coding standards.
▶ 23:29
How Slack AI Agents Accelerate Dev Productivity | Samuel Messing
Augmented coding involves a developer actively driving the process and making critical design decisions while using the AI assistant like an exoskeleton. In contrast, vibe coding occurs when someone with little or no programming skills relies entirely on prompts, accepting outputs without understanding or the ability to fix failures.
▶ 36:13
Tech Truth: Agile Evolution & the Future of SW Engineering • Martin Fowler & Kent Beck • GOTO 2025
Agents can examine past usage logs and metrics to identify what features would have been useful or what workflows are suboptimal. Instrumenting your code and entitlements allows the agent to pull data-driven insights rather than relying purely on speculation.
▶ 9:23
Use AI to Make Product Decisions
Once you find a useful agent workflow, encoding it into a deterministic flow saves time and tokens. It reserves LLM usage strictly for reasoning tasks while guaranteeing fast, repeatable results for known processes.
▶ 5:46
How to Get Your Org to Adopt Coding Agents (Without Shipping Garbage) — Eyal Blum, Figma
Developers can provide agents with execution backpressure by giving them browsers, shell access with curl, or recording tools so they can independently test their changes. Additionally, adopting strict linter rules cataloged specifically against known AI anti-patterns prevents models from introducing sloppy syntax. Providing immediate operational feedback loops lets agents hill climb toward correct functionality.
▶ 11:15
AI Agents Still Can't Maintain Your Codebase
It emerged from a series of workshops to offer an economic and human-centric alternative to rigid, phased waterfall development. The goal was to reach the early majority with a standard framework emphasizing rapid feedback loops and continuous iteration.
▶ 19:29
TDD, AI agents and coding with Kent Beck
You can instruct the model to use trace IDs to follow a request across disparate logging systems and clouds. Claude builds a coherent timeline in its context, helping identify where timeouts or errors occurred.
▶ 31:52
Anthropic Reliability Engineer EXPOSES the Limits of AI SRE
In the 2010s, engineering managers were explicitly taught never to make a technical decision again and to let go of technology choices. Today, modern engineering leaders are no longer restricted from technical leadership, and roles like CTO require being deeply involved in technical details. This convergence allows leaders to bridge both managerial and technical domains effectively.
▶ 35:46
The revised rules of engineering management with Will Larson
Keeping interactions short by clearing and restarting the context window helps avoid the dumb zone where models flail and hallucinate fixes. While context windows are expanding to millions of tokens, maintaining a tighter limit around 60k to 100k tokens yields better stability for complex problem solving.
▶ 27:39
The Great Loops Debate — Dex Horthy, Geoff Huntley, Ian Livingstone, Greg Pstrucha, @insecure-agents
When a customer with a massive 50,000-page document caused their data model to explode due to thousands of links, they had to completely redesign the internals. They implemented lazy loading so the application could handle massive files without breaking existing APIs for users.
▶ 24:39
The creator of OpenClaw: "I ship code I don't read"
He argues that when something possesses the correct aesthetic quality, it reflects an underlying truth and correctness, much like in mathematics or physics. Surrounding people with beautiful, well-functioning objects and interior code quality directly increases human happiness and reduces everyday frustration.
▶ 28:33
DHH’s new way of writing code
Agent memory remains a challenging and largely unsolved retrieval and generation problem because you want the system to learn preferences over time without flooding the context with useless information. Systems like Devin use auto-generated knowledge items where users can quickly approve or reject learned preferences, and agents can update or prune memories when things change. Alternatively, teams explore file-system-based approaches to let agents navigate their own persistent context.
▶ 30:55
Devin’s 80% Moment: Background Agents, 7x PRs, & End of Hand-Held Coding — Walden Yan & Cole Murray
The system makes heavy use of git work trees and custom scripts that coach Codex to push PRs, wait for reviews, run CI, fix flakes, and handle merge queues. Because the model excels at resolving merge conflicts, developers can delegate the entire merge lifecycle without synchronous terminal intervention.
▶ 24:27
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
You should use AI to rapidly build multiple workable UI prototypes for a single feature. This lets you experiment with different approaches in minutes instead of weeks, shifting the bottleneck from coding to proving which idea works best.
▶ 22:15
An AI state of the union: We’ve passed the inflection point & dark factories are coming
AIFX is a CLI tool introduced to centrally provision, configure, and update agent clients like Cloud Code, Codepilot, or Cursor. It allows developers to easily install and discover MCPs from the registry and apply standard configuration management. This ensures that engineers new to the space immediately get effective prompts, configurations, and connections to background task infrastructure.
▶ 11:42
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
Large enterprises face massive security risks when blindly granting AI models autonomous control over sensitive systems like email. The rush to deploy unvetted agents in complex legacy codebases invites catastrophic failures that could easily take critical infrastructure offline.
▶ 24:03
Martin Fowler & Kent Beck: Frameworks for reinventing software, again and again
Conformance suites are ideal when an existing standard has detailed language-agnostic specifications and tests, such as Web Assembly or custom file upload requirements. You can give the test suite to a capable agent and instruct it to write code until all tests pass. This allows you to rapidly reverse engineer or implement complex standards across different projects.
▶ 8:16
Simon Willison: Engineering practices that make coding agents work - The Pragmatic Summit
You can manage agent state by placing your agent behind a REST API or MCP server. This allows you to serialize the context window into a database when waiting on tools and resume seamlessly using a state ID.
▶ 7:43
12-Factor Agents: Patterns of reliable LLM applications — Dex Horthy, HumanLayer
RPI is a structured workflow that keeps context small by breaking tasks into distinct objective phases. Research finds correct files, planning outlines exact code snippets and tests, and implementation executes cleanly while staying in the smart zone.
▶ 7:44
No Vibes Allowed: Solving Hard Problems in Complex Codebases – Dex Horthy, HumanLayer
A ubiquitous language is a shared set of terms defined in a markdown file that both you and the AI use consistently. Establishing this shared vocabulary prevents the AI from being overly verbose and aligns its implementation with your planning.
▶ 8:30
"Software Fundamentals Matter More Than Ever" — Matt Pocock
Running long or parallel agent tasks locally can put heavy loads on CPU resources and disrupt workflows when laptops go to sleep. Cloud sandboxes and containerized environments solve this by executing tasks off-machine against specific git commits and creating feature branches. They also allow for better control over network access and tool permissions compared to local execution.
▶ 25:25
Why AI Coding Agents Are Here To Stay | Patrick Debois
AI assistants frequently break older features accidentally when implementing new changes across an application. Maintaining a robust suite of unit and integration tests acts as a vital guardrail to catch these regressions early since visual inspection alone is insufficient.
▶ 21:19
The Man Behind World’s Largest Dev Con | Stephan & Devoxx
Backlog.md natively uses Git to fetch task information and updates from other branches. When you assign a task and push changes on a feature branch, those updates automatically sync to the main branch's backlog instance.
▶ 11:27
AI-First Project Management for Developers | Alex Gavrilescu on Backlog.md
Simple server-side architectures make it much easier for both humans and machines to reason about pattern matching. When an API or framework has minimal boilerplate and clear boundaries, models can successfully generate migrations and tests. This return to simplicity reduces the infinite complexity plaguing modern stacks.
▶ 33:06
Transforming Debugging and Root Cause Detection with Sentry | David Cramer
Building gigawatt-scale compute clusters requires extensive physical infrastructure, stable supply chains for NVIDIA hardware, permits, and power that naturally take time to establish. Additionally, maximizing AI utility requires a human feedback loop where users co-evolve and learn how to best integrate the assistants into their workflows.
▶ 16:02
Mark Zuckerberg — AI will write most Meta code in 18 months
Earlier models acted like lossy search engines requiring manual file selection, while newer autonomous tools dynamically pull in repository context. By living directly in the codebase, these agents gather sufficient texture to handle complex multi-file tasks without manual curation. This capability shifts workflows from rigid prompt-response queries to autonomous context-aware pairing.
▶ 29:44
Oxide and Friends 1/12/2026 -- Engineering Rigor in the LLM Age
Frontier models are great at sketching out code plans, but they struggle with deterministic tasks like counting line numbers in large files. Cursor uses custom smaller models to reliably apply those sketches into precise code diffs.
▶ 32:05
Cursor Team: Future of Programming with AI | Lex Fridman Podcast #447
Tab accepts used to vastly outnumber agent requests by a factor of ten, but agent requests have grown fifteen times year over year. Consequently, agent requests now significantly exceed tab accepts, reflecting a shift toward larger automated tasks.
▶ 4:25
The next era of AI coding
A thin harness is the core deterministic loop that handles basic user input and LLM tool calls. Fat skills contain plain English checklists and detailed instructions written in markdown, acting like comprehensive SOPs. You should avoid putting flexible application logic into brittle code and instead manage it via markdown skills.
▶ 21:55
Tokenmaxxing: How Top Builders Use AI To Do The Work Of 400 Engineers
AI startups build deep custom workflows for large enterprises through lengthy pilot periods that can last up to a year. Although these long pilots involve heavy custom software development, they result in lucrative seven-figure contracts. Once integrated, enterprises face immense operational friction and won't easily switch to another vendor.
▶ 21:04
The 7 Most Powerful Moats For AI Startups
These models will likely combine learning from human feedback to absorb researcher taste with custom training environments. Researchers will continuously collect human feedback or convert training stack bugs into new reinforcement learning environments. This process acts as continual learning within the lab, distilling recent research progress back into the model.
▶ 28:44
AI researchers debate how close we are to recursive self-improvement
Pumping out features rapidly with AI burns through futures or optionality, making future modifications increasingly expensive. While traditional teams took years to reach an unchangeable state, AI tools can accelerate code to the same disastrous state in an afternoon. Preserving options requires intentional pauses to refactor and structure code for the next feature.
▶ 24:15
The Augmented Forest • Kent Beck• GOTO Copenhagen 2026
Claude Code provides multiple interfaces including the terminal CLI, IDE extensions, the full-screen desktop app, and the new agent view in the CLI. These surfaces allow you to track running, blocked, or completed agents across local and cloud sessions in one place.
▶ 33:51
Code with Claude London 2026: Opening Keynote
Founders must inspect real adoption, engagement, and retention metrics rather than relying on feel-good numbers that might just be temporary tire-kicking. Additionally, any data flywheel must tie directly to a concrete business metric to be meaningful.
▶ 0:02
AI's Trillion-Dollar Opportunity: Sequoia AI Ascent 2025 Keynote
Frontier labs train models using reinforcement learning environments driven by verification rewards. This training causes model capabilities to peak sharply in verifiable domains like code and math while lagging elsewhere.
▶ 10:13
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
You can use Copilot Spaces to create a dedicated workspace grounded in specific project files and instructions. This tool allows you to query the project in natural language and receive factual answers complete with direct code references.
▶ 41:31
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Warp Build provides unlimited concurrency so your coding agents do not have to wait in line for available runners. By making a single change to GitHub action files, it delivers faster pipeline speeds at a lower cost. It also includes features like unlimited caching for artifacts and npm packages.
▶ 4:28
How I'd Get Into Software in 2026
You can create a short custom skill that instructs the agent to continuously monitor pull requests for automated review comments. The agent will autonomously address the feedback, push new changes, and repeat the loop until all review bots approve. This eliminates manual copy-pasting of comments and background babysitting.
▶ 30:01
You're using AI agents wrong
Engineers naturally anchor their identity to whatever tech layer was popular when they entered the field. This deep psychological attachment traps them in outdated patterns because they refuse to move past their comfort zones.
▶ 24:21
My last video about ai harnesses
Changing architecture later is expensive because of its broad impact on both the rest of the team and the user experience. Because rework introduces high friction and resource costs, hiring engineers who understand product context and make the right choices initially is much more efficient. Relying on good initial primitives prevents costly refactoring down the road.
▶ 25:58
Build the Right Thing: Product Engineering (Part 1) — Kent C. Dodds, EpicProduct.engineer
Typing code was never the primary bottleneck in software engineering, echoing Fred Brooks's observation that writing code is only a fraction of the work. Delegating design to LLMs often results in superficial solutions modeled on surface-level similarities rather than novel engineering.
▶ 27:50
The Dangerous Illusion of AI Coding? - Jeremy Howard
Use an automated component browser that takes screenshots of every component on every change to point out visual differences. This allows developers to quickly detect unexpected side effects and review pull requests efficiently.
▶ 9:05
How VS Code Went from Monthly to Weekly Releases with AI — Harald Kirschner
DORA's research outlines seven capabilities that, when paired with AI adoption, produce the best outcomes. Key factors include establishing a clear stance, maintaining healthy data ecosystems, using strong version control, and working in small batches.
▶ 13:08
AI is making software delivery less stable. DORA's Nathen Harvey on the fix | EVOLVE 2026
Engineering leaders are recommitting to clean, well-defined interfaces and APIs between services. Clear boundaries make it easier for agentic models to navigate the codebase, which simultaneously benefits human developers.
▶ 36:34
Measuring the impact of AI on software engineering – with Laura Tacho
Atlas failed because it forced users to run all products at once, making it impossible for single-product users to buy in. Additionally, it triggered internal budget fights across different company departments over who should pay for it.
▶ 35:57
Mitchell Hashimoto’s new way of writing code
Among companies advanced enough to instrument telemetry, eighty percent of developers use agentic workflows at least once a week. Over fifty percent of developers in these leading teams use agentic workflows every single day to complete their work.
▶ 15:38
Data vs Hype: How Orgs Actually Win with AI - The Pragmatic Summit
Large AI-generated pull requests, such as a 5,000-line translation, place an immense burden on human reviewers and often lead to superficial reviews. Reviewers tend to run out of cognitive stamina and skip commenting on massive changes. The recommendation is to pace reviews and be mindful of willpower limits, since slow is smooth and smooth is fast.
▶ 25:44
How Slack AI Agents Accelerate Dev Productivity | Samuel Messing
Drawing from computer science principles established since von Neumann, developers must implement double-checking and inhibition mechanisms to prevent invalid states. A practical technique is asking the LLM the same question or generating the same code multiple times to diff and compare the results for consistency.
▶ 41:46
Tech Truth: Agile Evolution & the Future of SW Engineering • Martin Fowler & Kent Beck • GOTO 2025
When an agent uncovers a separate issue or refactoring task, you can command it to spin up a separate cloud agent in another repo. This isolates the conversation context while letting you solve secondary problems in parallel.
▶ 11:04
Use AI to Make Product Decisions
Instructing agents to follow a test-driven development style yields much better results than writing code before tests. This approach sets a clear goal for the agent to strive toward rather than letting it fit tests to pass already-written code.
▶ 6:29
How to Get Your Org to Adopt Coding Agents (Without Shipping Garbage) — Eyal Blum, Figma
Teams can streamline incident management by configuring pager alerts to automatically generate pull requests that the agent believes will fix the issue. Even if engineers can only successfully merge a portion of these automated PRs, it substantially increases development throughput and system reliability. This shifts the burden of debugging out-of-hours issues toward collaborative machine assistance.
▶ 11:50
AI Agents Still Can't Maintain Your Codebase
Kent Beck invented TDD as a conceptual blend of vintage tape application workflows and his Smalltalk testing framework. Reading about typing expected output tapes before writing transformation programs inspired him to write expected values before code. This process transformation dramatically reduced his programming anxiety.
▶ 36:02
TDD, AI agents and coding with Kent Beck
LLMs frequently confuse correlation with causation when interpreting system graphs and metrics. For instance, when a KV cache blows up and traffic doubles alongside errors, the model wrongly diagnoses a capacity problem rather than a cache failure.
▶ 22:52
Anthropic Reliability Engineer EXPOSES the Limits of AI SRE
ZERP shaped a decade of management bloat where perks, hiring throughput, and employee retention became the primary focus. Because managers were discouraged from making technical decisions, they overindexed on process solutions and headcount. This created bloated organizations and shifted priorities until the environment changed around 2022.
▶ 52:12
The revised rules of engineering management with Will Larson
Loops pay off when applied to strictly specified systems or automated tasks like security scanning, where external test suites and precise verification catch real oversight. Though they can be expensive, running them on well-tested rewrites or throwaway prototypes provides high leverage.
▶ 36:59
The Great Loops Debate — Dex Horthy, Geoff Huntley, Ian Livingstone, Greg Pstrucha, @insecure-agents
Writing forces developers to deeply understand the problems they solved and serves as valuable internal documentation. It also acts as a personal lookbook and helps attract interesting candidates who want to tackle hard problems.
▶ 26:44
The creator of OpenClaw: "I ship code I don't read"
The shift happened when terminal agent harnesses gave AI tools like bash and internet access, combined with Opus's surprisingly high-quality output. This transition moved AI from a conversational novelty to a reliable partner that produced mergeable code, leading to an agent-first workflow.
▶ 37:36
DHH’s new way of writing code
Multi-agent swarms often result in a chaotic world with high conflict potential. Practical usage still relies on a single engine that segregates work so each developer agent operates in isolation on its own machine. While sub-agents work well for scoped tool calls, full multi-agent collaboration creates architectural complexity.
▶ 39:54
Devin’s 80% Moment: Background Agents, 7x PRs, & End of Hand-Held Coding — Walden Yan & Cole Murray
Teams can internalize small to medium dependencies, like a couple thousand lines of code, in an afternoon by stripping away generic parts and tailoring them to their specific needs. This avoids upstream supply-chain friction and allows the coding agent to review and patch the internalized code with low friction.
▶ 28:24
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
Running multiple coding agents in parallel places a heavy cognitive load on developers, leading to quick mental exhaustion. Engineers must establish new personal limits and avoid the temptation to work around the clock just because agents can run asynchronously.
▶ 26:39
An AI state of the union: We’ve passed the inflection point & dark factories are coming
Minion is Uber's formal background agent platform built on top of state-of-the-art agents, CLIs, and SDKs to run agents fully autonomously on internal infrastructure. It runs inside Uber's CI platform with access to monorepos and network infrastructure, and it integrates into workflows via a web interface, Slack, GitHub pull requests, and the AIFX CLI. Furthermore, it provides good defaults per monorepo to increase task success rates.
▶ 14:26
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
There is a dangerous trend toward resoloing programming where individuals manage multiple agents in isolation rather than communicating with peers. However, maintaining collaborative structures like pairs or teams interacting with genies yields far better results than one person managing many agents alone.
▶ 25:48
Martin Fowler & Kent Beck: Frameworks for reinventing software, again and again
For quick, single-page throwaway tools, code quality does not matter as long as it works. For long-term projects, accepting poor agent code is a choice, and you can explicitly prompt the agent to refactor messy sections. By taking the time to guide refactoring, you can end up with code quality that surpasses what you would write manually.
▶ 10:20
Simon Willison: Engineering practices that make coding agents work - The Pragmatic Summit
Micro-agents work best by combining a mostly deterministic DAG with small loops of three to ten steps for complex tasks. This keeps context manageable while allowing deterministic code to handle the rest of the pipeline.
▶ 12:28
12-Factor Agents: Patterns of reliable LLM applications — Dex Horthy, HumanLayer
Code and plan reviews ensure the team remains on the same page about how and why the codebase is changing. Technical leaders can read the detailed plans instead of wading through walls of generated code, catching problems early.
▶ 15:03
No Vibes Allowed: Solving Hard Problems in Complex Codebases – Dex Horthy, HumanLayer
AI coding agents often try to do too much at once and produce massive amounts of code before checking correctness. Test-driven development forces the LLM to slow down, take small deliberate steps, write a test first, and refactor incrementally.
▶ 10:53
"Software Fundamentals Matter More Than Ever" — Matt Pocock
Running multiple agents in parallel allows you to explore different solutions, frameworks, or hypotheses simultaneously. However, this creates a significant code review bottleneck because developers now have to manually compare multiple variations or feature branches. New user interfaces and agent-assisted reviews are emerging to help reduce this cognitive load and simplify merging.
▶ 32:15
Why AI Coding Agents Are Here To Stay | Patrick Debois
Rapid prototyping gives quick satisfaction, but it can lead to dangerous configuration mistakes like accidentally deploying staging tasks to production. Without knowledgeable review, non-technical users or juniors might introduce security issues or bypass routing guards. Therefore, experienced developers are still required to catch hidden side effects and infrastructural risks.
▶ 31:30
The Man Behind World’s Largest Dev Con | Stephan & Devoxx
You instruct an agent like Claude to use the Backlog CLI and specify that tasks must fit into good, consumable pull requests. The agent then automatically creates atomic markdown tasks within Backlog.md that avoid blowing the scope.
▶ 17:59
AI-First Project Management for Developers | Alex Gavrilescu on Backlog.md
Organizations need to enable the consumption of AI coding tools without overly restrictive compliance on intellectual property. Removing the fear of source code leaks or model training risks allows engineering teams to immediately adopt valuable assistants. Without this policy shift, developers are forced to pay out of pocket or fall behind.
▶ 37:10
Transforming Debugging and Root Cause Detection with Sentry | David Cramer
DeepSeek had to spend significant engineering time on low-level infrastructure optimizations because they were restricted to using partially nerfed chips due to export controls. American labs did not face these exact hardware limitations and thus did not have to expend the same calories on these specific workarounds.
▶ 37:16
Mark Zuckerberg — AI will write most Meta code in 18 months
Autonomous tools can successfully analyze stack traces and statically examine code to identify real bugs in unfamiliar languages. In one example, an engineer with no prior experience in Zig used an AI model to discover and report three valid bugs in a terminal emulator. This capability allows developers to investigate issues far outside their usual domain expertise.
▶ 32:22
Oxide and Friends 1/12/2026 -- Engineering Rigor in the LLM Age
Instead of relying on a small model to predict draft tokens, speculative edits feed chunks of the original code back into the model as a strong prior. The model processes these chunks in parallel, streaming diffs much faster while allowing developers to review code early without loading screens.
▶ 35:16
Cursor Team: Future of Programming with AI | Lex Fridman Podcast #447
At Cursor, 30 percent of internal pull requests are now developed entirely end-to-end by cloud-running agents with no human intervention. Additionally, about 75 percent of code in their enterprise segment is entirely AI-generated.
▶ 5:12
The next era of AI coding
Use traditional deterministic code for strict actions and external API calls like Twilio where exact logic is required. Use LLMs and markdown when you need to handle generic cases, context, and latent space reasoning. The magic of agentic engineering is correctly partitioning tasks between code land and LLM land.
▶ 22:47
Tokenmaxxing: How Top Builders Use AI To Do The Work Of 400 Engineers
Per-seat pricing acts as an Achilles heel because successful AI agents automate tasks and reduce the number of employees a company needs. Consequently, the more effective the AI product is, the more it directly cannibalizes the incumbent's revenue. Startups avoid this by pricing around work delivered or tasks completed instead.
▶ 25:57
The 7 Most Powerful Moats For AI Startups
Model providers target high-value domains to strengthen performance and make models more efficient at runtime by baking intuitions directly into the weights. Additionally, massive parameter spaces allow labs to easily afford domain-specific data while gaining useful transfer for capabilities like recursive self-improvement.
▶ 37:35
AI researchers debate how close we are to recursive self-improvement
Current AI tools focus heavily on model efficiency and token optimization while completely ignoring foundational human needs like competence and struggle. By outsourcing the problem-solving grind to the genie, developers miss out on the struggle required to achieve genuine insight. This leaves engineers with a hollow feeling of accomplishment at the end of the day.
▶ 35:16
The Augmented Forest • Kent Beck• GOTO Copenhagen 2026
Autofix listens for events like code review comments, security reviews, and CI failures, then proactively addresses them. It can rebase on merge conflicts or retry timed-out jobs so your pull requests stay green without manual babysitting.
▶ 36:22
Code with Claude London 2026: Opening Keynote
Coding achieved screaming product-market fit driven by advanced models like Anthropic's Claude 3.5 Sonnet, triggering a rapid vibe shift in the landscape. Users are now vibe-coding entire applications, fundamentally changing the speed and economics of software creation.
▶ 12:40
AI's Trillion-Dollar Opportunity: Sequoia AI Ascent 2025 Keynote
Vibe coding raises the floor for everyone by letting non-engineers build software quickly. In contrast, agentic engineering treats AI use as a disciplined engineering practice that maintains professional quality and security bars.
▶ 15:57
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
The signals loop involves fine-tuning off-the-shelf models using real user interaction data and rigorous A/B testing. Platforms like Azure AI Foundry leverage this continuous loop to dramatically boost task acceptance rates and overall agent quality.
▶ 45:52
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
The adjacent possible describes the set of next steps that only become unlocked once a prior foundational step exists, like the iPhone enabling DoorDash or Git enabling GitHub. Agents act as a new printing press, opening up completely new doors for software. Developers who watch for these shifts can spot new opportunities instantly.
▶ 5:46
How I'd Get Into Software in 2026
You can add a built-in tailscale share command to start a remote dev server and return a pairing URL. This allows you to test the PR directly in your browser even over a slow network connection. It enables real-time validation without relying on cumbersome in-app previews.
▶ 37:20
You're using AI agents wrong
Abstracting the harness allows developers to seamlessly switch between different AI models and environments like Claude Code or Codex without breaking workflows. It prevents users from getting locked into proprietary ecosystem quirks and keeps them focused on productivity.
▶ 42:54
My last video about ai harnesses
You should avoid traditional coding tests that prohibit AI agents, as those do not evaluate real-world execution. Instead, interview candidates by discussing core problem discovery and the system implications that follow. This reveals whether they understand how to map user needs to robust system architectures.
▶ 32:31
Build the Right Thing: Product Engineering (Part 1) — Kent C. Dodds, EpicProduct.engineer
Blindly relying on AI tools creates understanding debt and erodes organizational knowledge because developers miss out on the friction required for true learning. Without desirable difficulty and active struggle, developers risk cognitive atrophy and personal obsolescence.
▶ 36:31
The Dangerous Illusion of AI Coding? - Jeremy Howard
Leverage Playwright through a launch skill to automatically open the application and click through specific test scenarios. This provides a self-correcting loop where agents can diagnose and validate fixes without manual intervention.
▶ 10:17
How VS Code Went from Monthly to Weekly Releases with AI — Harald Kirschner
AI makes it easy to generate massive applications or huge pull requests with a single prompt, leading reviewers to rubber-stamp code without reading it. Breaking tasks into small batches ensures proper human feedback and maintains high code standards.
▶ 16:25
AI is making software delivery less stable. DORA's Nathen Harvey on the fix | EVOLVE 2026
Companies should combine system workflow metrics with self-reported developer sentiment surveys to track utilization, impact, and cost. Using a developer experience index helps reveal broader organizational gains like an 11% boost in developer experience.
▶ 43:02
Measuring the impact of AI on software engineering – with Laura Tacho
I pre-planned by downloading GitHub issues on the ground and breaking them down into small 15-minute bug fixes. Since inflight Wi-Fi was absent or patchy, I committed code locally and pushed large batches of fixes upon landing.
▶ 47:12
Mitchell Hashimoto’s new way of writing code
Companies use agentic workflows to quickly turn design and project artifacts into functional patient portals and prototypes. This approach yields high-quality code with excellent documentation and tests much faster than traditional manual methods.
▶ 17:28
Data vs Hype: How Orgs Actually Win with AI - The Pragmatic Summit
Slack functions as a work operating system comprising interacting primitives like huddles, lists, canvases, and channels with deep native AI integrations. Using platforms like Agent Force, developers can build agents that dynamically generate canvases, create lists, or fetch enterprise search context. This positions Slack not just as an IDE, but as the core environment for running enterprise workflows.
▶ 33:42
How Slack AI Agents Accelerate Dev Productivity | Samuel Messing
Junior developers should resist the pressure to immediately start the next feature and instead use the gaps to learn and master their craft. They can leverage the AI as an endless tutor to explore alternative implementations, run coverage testing, find missing tests, and refactor code.
▶ 51:16
Tech Truth: Agile Evolution & the Future of SW Engineering • Martin Fowler & Kent Beck • GOTO 2025
When an agent identifies a capability gap, evaluate whether it requires a brand new entity or just an extension of current architecture. Expanding a proven primitive often solves multiple problems more simply than adding a completely separate construct.
▶ 13:00
Use AI to Make Product Decisions
Teams should shift as much verification as possible down to deterministic analysis like linters, compilers, and unit tests. Agents can automatically review architectural standards, leaving human reviewers to focus only on high-level functionality and product intent.
▶ 6:57
How to Get Your Org to Adopt Coding Agents (Without Shipping Garbage) — Eyal Blum, Figma
A control plane acts as the centralized system where teams dispatch work, collaborate on active sessions, and share architectural plans. Instead of passing ad-hoc patches through chat tools, a dedicated control plane stores session traces, prompts, and streaming diffs. This setup provides visibility into what agents are doing across the organization in real-time.
▶ 13:48
AI Agents Still Can't Maintain Your Codebase
Critics argue TDD ignores upfront architecture, but practitioners constantly bounce between abstraction levels. Writing a test forces a moment of design to determine the API interface before implementation details are locked in. Once a test turns green, developers get a release of tension to think about broader design and refactoring.
▶ 42:34
TDD, AI agents and coding with Kent Beck
SRE automation can be mapped to self-driving car levels ranging from assistance to full autonomy. Most mature systems operate around level two with automated observability, while human engineers still handle mitigations and fixes.
▶ 28:33
Anthropic Reliability Engineer EXPOSES the Limits of AI SRE
Structured career ladders and rubrics are necessary because research shows they drive fairer decisions than having no rubrics at all. Without them, companies tend to undervalue essential maintenance and glue work while overemphasizing flashy projects. However, rubrics should guide decisions rather than replace managerial judgment during promotions.
▶ 58:06
The revised rules of engineering management with Will Larson
The access control problem for shared agent memory remains largely unsolved because traditional IAM systems weren't built for autonomous machines. Using simple formats like markdown files for memory sharing offers a workable substrate, though providing robust attribution and scoping is still unwieldy.
▶ 39:54
The Great Loops Debate — Dex Horthy, Geoff Huntley, Ian Livingstone, Greg Pstrucha, @insecure-agents
Burnout stemmed from constant high-stakes crises, managing endless unresolved issues as the company's waste bin, and heavy team conflicts. Working through stressful weekend emergencies without believing in the current management direction ultimately led to exhaustion.
▶ 29:51
The creator of OpenClaw: "I ship code I don't read"
Daily work now starts agent-first on almost everything, using terminal layouts running models like Kimi and Opus in parallel panes. Instead of writing code from scratch in the editor, agents generate drafts that get reviewed and selectively altered via version control diffs.
▶ 47:26
DHH’s new way of writing code
Standard virtual machines often use network file systems like S3, making operations like grepping extremely slow due to constant network calls. To solve this, developers build incremental file storage formats where saving and rebooting use work proportional only to the file system diff. This drastically shaves down boot-up times.
▶ 49:39
Devin’s 80% Moment: Background Agents, 7x PRs, & End of Hand-Held Coding — Walden Yan & Cole Murray
Elixir's process supervision and GenServers naturally support process orchestration by spinning up little daemons for every task in execution. When a pull request fails review, the Elixir service completely trashes the work tree and starts over from scratch based on the feedback loop.
▶ 34:39
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
We could reach the point where the majority of code is written by AI as early as the end of this year. The primary hurdle is no longer code quality, which is now generally good, but rather learning the non-trivial skills required to use these tools effectively.
▶ 41:06
An AI state of the union: We’ve passed the inflection point & dark factories are coming
Code Inbox is a unified inbox designed to remove noise by displaying only actionable pull requests directly relevant to a user when they need attention. It uses smart assignments based on code ownership, compliance, time zones, and calendar availability to find the right reviewer and tracks strict SLOs for escalations. It also integrates with Slack to batch notifications and respect developer focus time.
▶ 19:28
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
The Venn diagram of developer experience and agent experience is effectively a circle. Practices like well-modularized code and strong testing make it significantly easier for both human developers and AI agents to work effectively.
▶ 29:40
Martin Fowler & Kent Beck: Frameworks for reinventing software, again and again
Prompt injection targets systems built on LLMs by exploiting their gullibility and tendency to follow instructions embedded in untrusted data. Unlike SQL injection, you cannot easily parameterize queries to separate data from instructions. If a malicious input contains hidden commands, an unconstrained agent might mistakenly execute them.
▶ 13:13
Simon Willison: Engineering practices that make coding agents work - The Pragmatic Summit
You can handle human intervention by pushing the choice between a tool call and a human message into a natural language token. This allows the model to explicitly state when it needs clarification or management approval using concepts it already understands.
▶ 11:25
12-Factor Agents: Patterns of reliable LLM applications — Dex Horthy, HumanLayer
As plans get longer, reliability goes up while readability goes down. To achieve high leverage and reliable execution, teams should iterate so that plans include actual code snippets of what is going to change.
▶ 16:17
No Vibes Allowed: Solving Hard Problems in Complex Codebases – Dex Horthy, HumanLayer
Good codebases rely on deep modules with simple interfaces and hidden complexity rather than numerous shallow modules. These clean boundaries make it easy to write tests and provide reliable feedback loops for both humans and AI.
▶ 12:15
"Software Fundamentals Matter More Than Ever" — Matt Pocock
Productivity gains depend heavily on task complexity, codebase health, and the programming language being used. Simpler or repetitive tasks yield much higher multipliers, whereas older, legacy codebases with inconsistent standards confuse the AI. Additionally, modern workflows that incorporate feedback loops and specifications perform significantly better than basic one-shot code generation.
▶ 42:24
Why AI Coding Agents Are Here To Stay | Patrick Debois
LLMs will not automatically implement scalable architectures unless explicitly guided by someone with prior system design experience. By making deliberate foundational choices like leveraging serverless Firebase functions and Google Cloud Run, developers guarantee scalability from the start. Alternatively, developers can prompt LLMs specifically for architectural recommendations regarding performance and bottlenecks.
▶ 45:02
The Man Behind World’s Largest Dev Con | Stephan & Devoxx
Previously, developers used separate agent sessions for task creation, implementation planning, and execution to avoid bias across context windows. However, newer models are better at following instructions, allowing you to combine these steps.
▶ 26:35
AI-First Project Management for Developers | Alex Gavrilescu on Backlog.md
AI tools deliver clear productivity gains by rapidly generating boilerplate code and building standard APIs or tests based on existing examples. Furthermore, they re-engage experienced builders who get excited about writing code again. This hands-on involvement improves technical judgment across the organization.
▶ 43:22
Transforming Debugging and Root Cause Detection with Sentry | David Cramer
Building models in-house gives Meta complete control over crucial size, latency, and inference cost tradeoffs that impact product performance across devices. Relying purely on external or fine-tuned models would not provide the exact architectural customization needed for deeply integrated features like voice.
▶ 44:44
Mark Zuckerberg — AI will write most Meta code in 18 months
Developers can bypass expensive commercial code review tools by writing custom scripts that feed pull request diffs and descriptions into language models. While these reviews miss broader context like imports or passing CI tests, they excel at spotting inconsistencies, SQL migration mismatches, and text discrepancies. This approach offers a low-cost, automatable way to catch errors before human review.
▶ 48:50
Oxide and Friends 1/12/2026 -- Engineering Rigor in the LLM Age
Cursor uses a declarative prompt rendering system inspired by React and JSX to format and fit context into prompt windows. It assigns priorities, such as giving the exact line of the cursor the highest priority, and dynamically adjusts what gets included based on available space.
▶ 45:39
Cursor Team: Future of Programming with AI | Lex Fridman Podcast #447
Engineers increasingly stop touching raw syntax and transition into agent managers. Instead of working alone, they collaborate alongside tens of thousands of autonomous agent colleagues operating in parallel.
▶ 5:55
The next era of AI coding
Writing tests prevents AI-generated code from falling over when real users interact with it. Without adequate test coverage, vibe coding produces brittle software that resembles low-quality slop. Pushing for high test coverage ensures production-grade reliability despite rapid generation speeds.
▶ 11:42
Tokenmaxxing: How Top Builders Use AI To Do The Work Of 400 Engineers
AI network effects emerge through data accumulation where more user interactions train better custom models and improve the product. For instance, capturing enterprise private data or user telemetry helps teams iterate on evals and context engineering. This creates a compounding flywheel that hardens the startup's defensive moat.
▶ 38:27
The 7 Most Powerful Moats For AI Startups
Frequently updating a model using supervised fine-tuning or small-batch traces leads to catastrophic forgetting of previously learned information and general capability degradation. While reinforcement learning alters a small loss valley safely, it struggles to efficiently encode explicit knowledge without extensive compute for environments.
▶ 55:39
AI researchers debate how close we are to recursive self-improvement
Human-centric tools should aim to automate routine toil while actively preserving meaningful struggle and surfacing difficult choices for developers. They should encourage learning throughout the day and promote human-to-human connection rather than isolating programmers in separate silos. Ultimately, tools should serve human growth and satisfaction rather than model token metrics.
▶ 45:04
The Augmented Forest • Kent Beck• GOTO Copenhagen 2026
Routines are higher-order prompts that can be configured to run on a schedule, via webhooks, or through API requests. They enable developers to delegate async tasks like resolving overnight GitHub issues and waking up to ready-to-merge pull requests.
▶ 36:52
Code with Claude London 2026: Opening Keynote
As traditional pre-training scaling slows down, the ecosystem is relying on test-time reasoning, synthetic data, and tool use to scale intelligence. Protocol standards like Anthropic's MCP also help accelerate agentic tool use and network interconnectivity.
▶ 12:40
AI's Trillion-Dollar Opportunity: Sequoia AI Ascent 2025 Keynote
Traditional coding puzzles belong to the old paradigm and no longer test modern skills effectively. Companies should instead give candidates large, open-ended projects to implement, secure, and defend against automated attacks.
▶ 18:44
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
Certain enterprise use cases like healthcare and industrial monitoring require local execution due to strict compliance, privacy, and latency constraints. The platform architecture should allow agents created in the cloud to seamlessly run and reason locally at the edge.
▶ 57:40
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Anti-fragile careers actually grow stronger when shaken by industry shifts rather than breaking under pressure. Instead of relying on a single ephemeral skill, you must constantly look for the adjacent possible. Being close to real people with real problems positions you to walk through newly opened doors.
▶ 8:25
How I'd Get Into Software in 2026
You can configure a workflow that triggers a preview build for macOS using a specific PR label. Once processed, a preview DMG download appears directly in the thread for you to test on a clean machine. This avoids the friction of building large desktop applications locally from scratch.
▶ 41:21
You're using AI agents wrong
T3 code functions as an agentic development environment that acts as an interface between the user and various harnesses. It manages environments and sub-agents, letting developers control their AI workflows through a customizable open-source tool.
▶ 46:54
My last video about ai harnesses
You should ask about past behavior, specific workarounds, and prior costs instead of fishing for compliments or asking hypothetical future questions. Since nobody can predict the future, understanding what users did previously reveals true pain points. Uncovering active workarounds provides strong evidence of a problem worth solving.
▶ 41:47
Build the Right Thing: Product Engineering (Part 1) — Kent C. Dodds, EpicProduct.engineer
AI coding mirrors the mechanics of a slot machine, featuring an illusion of control through prompt engineering and stochastic wins. Developers experience high-intensity marathons driven by occasional successes, leaving them mentally drained and detached from actual code comprehension.
▶ 48:09
The Dangerous Illusion of AI Coding? - Jeremy Howard
Implement automated AI filtering to remove spam, translate text, and assign issues to proper area owners to improve signal-to-noise ratios. A human-in-the-loop Chrome extension layer is also used to fix duplicate issues and feed data back into the system.
▶ 12:39
How VS Code Went from Monthly to Weekly Releases with AI — Harald Kirschner
Adopting any new technology introduces a productivity J-curve where output dips due to learning curves and verification taxes before recovering. Leadership must anticipate this dip rather than expecting immediate ten-fold gains from handing out AI licenses.
▶ 25:32
AI is making software delivery less stable. DORA's Nathen Harvey on the fix | EVOLVE 2026
AI makes it trivially easy to write large changes all at once, leading to bigger batch sizes and increased risk. Research predicts that a 25% increase in AI adoption could result in a 7.2% reduction in delivery stability.
▶ 53:50
Measuring the impact of AI on software engineering – with Laura Tacho
Two years into the company, VMware approached us with an informal acquisition path that eventually reached a verbal offer. We raised our asking price using a regret minimization framework, but the deal ultimately fell through when a final board vote failed.
▶ 51:58
Mitchell Hashimoto’s new way of writing code
Technology cannot automatically fix underlying human and systems-level organizational problems. Without addressing these foundational constraints, companies will simply amplify their existing dysfunctions faster.
▶ 20:50
Data vs Hype: How Orgs Actually Win with AI - The Pragmatic Summit
When building features for agents, developers must expose tools as actions and design search APIs that deliver rich context rather than just single messages. For example, Slack's real-time search API provides full threads, relationships, and user roles so agents can reason effectively. This requires building dedicated endpoints alongside human-facing interfaces.
▶ 47:43
How Slack AI Agents Accelerate Dev Productivity | Samuel Messing
Instead of guessing platform limits, you can have the agent write code and run real tests against the target infrastructure. For example, the agent created a throwaway repository and tried uploading various file sizes to discover exact failure thresholds.
▶ 18:16
Use AI to Make Product Decisions
Spending up to a week writing a comprehensive implementation plan allows developers to make and flush out decisions before sending it to the agent. This approach reintroduces the intellectual craft and joy of building back into the development process.
▶ 7:50
How to Get Your Org to Adopt Coding Agents (Without Shipping Garbage) — Eyal Blum, Figma
Tests act as immutable guardrails that prevent AI agents from making disruptive changes across a codebase. Because AI tools lack architectural taste and often introduce regressions, maintaining a fast suite of tests allows you to catch accidental breakages instantly. You can feed expected values as immutable assertions to keep the agent aligned.
▶ 51:31
TDD, AI agents and coding with Kent Beck
LLMs can aggregate Slack channels and meeting transcripts to generate postmortem drafts using standard templates. However, because they struggle with root causes and company history, teams must review them and insert human to-do items.
▶ 35:50
Anthropic Reliability Engineer EXPOSES the Limits of AI SRE
Instead of adding headcount to a late project, which destroys small ownership pods, managers should keep durable high-ownership teams focused on the problem. They can ask for short-term commitments and extra hours from the team while removing bureaucratic distractions. This prevents the constant organization-wide panic and burnout seen in reactive staffing surges.
▶ 1:17:18
The revised rules of engineering management with Will Larson
Humans must ultimately remain attributable and responsible for an agent's actions since software systems require accountability for damage. Even as agents generate code and loops scale up, society requires a human to sign off and hold liability for the initial intent and deployment.
▶ 50:25
The Great Loops Debate — Dex Horthy, Geoff Huntley, Ian Livingstone, Greg Pstrucha, @insecure-agents
The speaker now runs five to ten coding agents simultaneously, acting primarily as a system architect and builder. Instead of reading every line of code, they manage tasks asynchronously, jumping between projects while models cook.
▶ 46:24
The creator of OpenClaw: "I ship code I don't read"
Senior developers possess the long architectural insight and historical overview needed to critically examine agent output and ensure quality before deployment. Because they can effectively validate code and direct multiple agents, their individual productivity is amplified by five to ten times.
▶ 55:55
DHH’s new way of writing code
AI models often use workaround patterns like getattr or forced backwards compatibility imports to prevent execution failures, leading to codebase regression. Teams can combat this by implementing strict lint rules using tools like Semgrep to catch patterns such as untyped tuples. Regular human code review and architectural boundaries also keep sprawl in check.
▶ 54:36
Devin’s 80% Moment: Background Agents, 7x PRs, & End of Hand-Held Coding — Walden Yan & Cole Murray
CLIs should be token efficient and avoid dumping massive walls of text that confuse the agent. Developers can wrap commands or use silent flags so the model receives concise failure states instead of redundant logs.
▶ 50:30
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
Running coding agents in YOLO mode, or skipping permissions, prevents them from constantly nagging you for approval before taking actions. This allows developers to run multiple agents in the background autonomously while stepping away from the computer.
▶ 49:26
An AI state of the union: We’ve passed the inflection point & dark factories are coming
U review uses a multi-layer pipeline featuring general defect bots, best practice plugins, and APIs for external tools to preprocess code comments. It passes these through a review grader to filter out low-value nits and focuses exclusively on high-confidence changes. Finally, it checks for duplicates across different systems and categorizes the comments before presenting them to the developer.
▶ 22:06
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
Developers must let go of the micro-satisfaction of writing individual functions by hand and shift focus toward domain understanding. Building a precise language to communicate domain models with agents provides much higher leverage than manually crafting code.
▶ 30:45
Martin Fowler & Kent Beck: Frameworks for reinventing software, again and again
The lethal trifecta occurs when a model has access to private data, is exposed to malicious instructions, and possesses an external exfiltration vector. An example includes an assistant with email access forwarding sensitive data after reading a malicious message. The guaranteed solution is to cut off at least one leg of the trifecta, such as blocking external communication.
▶ 15:08
Simon Willison: Engineering practices that make coding agents work - The Pragmatic Summit
Treating large language models as pure functions means focusing entirely on token inputs and outputs. The reliability of your agent depends directly on the quality and density of the tokens you engineer into the context window.
▶ 9:04
12-Factor Agents: Patterns of reliable LLM applications — Dex Horthy, HumanLayer
Global repo onboarding docs can quickly consume the token limit and leave no room for tool calling. Instead, use on-demand compressed context and progressive disclosure to pull in only the specific subcontext needed.
▶ 12:22
No Vibes Allowed: Solving Hard Problems in Complex Codebases – Dex Horthy, HumanLayer
Deep modules encapsulate a lot of functionality behind a simple, well-designed interface, whereas shallow modules have little functionality and complex interfaces. A codebase full of shallow modules confuses AI agents and makes exploration difficult.
▶ 12:52
"Software Fundamentals Matter More Than Ever" — Matt Pocock
Sub agents are configurable markdown files that define specific character profiles or roles, such as a tester or performance expert. When activated during a prompt, the coding assistant adopts that avatar and behaves according to that specialized role for the request. This allows developers to simulate expert reviews directly within their CLI tool.
▶ 50:03
The Man Behind World’s Largest Dev Con | Stephan & Devoxx
Backlog.md stores all tasks directly inside your Git repository rather than using a hosted production database. This leverages native Git security and eliminates the need for user login systems or traditional database management.
▶ 27:42
AI-First Project Management for Developers | Alex Gavrilescu on Backlog.md
Using models tied to foreign governments introduces the risk that intelligence organizations could embed hidden vulnerabilities into code or systems. If a system relies on a compromised model for security, it could wake up to find its infrastructure entirely vulnerable without the user knowing.
▶ 50:53
Mark Zuckerberg — AI will write most Meta code in 18 months
LLMs make it tolerable and even advantageous to have slightly repeated code instead of over-indexing on complex macros. This allows developers to keep code readable and keep source links intact for code navigation.
▶ 1:00:26
Oxide and Friends 1/12/2026 -- Engineering Rigor in the LLM Age
Efficient attention schemes like group-query attention, multi-query attention, and multi-latent attention compress the size of the KV cache. This reduction in memory bandwidth allows for larger batch sizes and faster token generation without degrading latency.
▶ 1:00:21
Cursor Team: Future of Programming with AI | Lex Fridman Podcast #447
Local agents require constant babysitting and bottleneck multitasking, whereas cloud-based agent teams operate autonomously on separate computers for long periods. This enables engineers to manage dozens of parallel tasks, shifting their focus toward thorough code and build reviews.
▶ 7:16
The next era of AI coding
You can prompt your coding agent to inspect existing chunking, vector embedding, and hybrid retrieval logic in your other repositories. By instructing the agent to extract these patterns, you can quickly spin up Postgres with PG vector for new projects. This lets you reuse battle-tested architectures across different open-source tools.
▶ 29:07
Tokenmaxxing: How Top Builders Use AI To Do The Work Of 400 Engineers
RL currently suffers from poor exploration limits where models fail to learn if they cannot find the answer within a small number of rollouts. Pre-training draws signal directly from static datasets like Common Crawl, whereas RL requires stepping through progressive difficulty rungs.
▶ 1:04:18
AI researchers debate how close we are to recursive self-improvement
Because AI lets individual developers move at extreme speeds, it encourages isolation where programmers work in separate repos without interacting. This creates a decaf version of connection where developers talk to multiple genies instead of collaborating with human peers. Good tools must counteract this by fostering genuine communication and shared context among team members.
▶ 38:00
The Augmented Forest • Kent Beck• GOTO Copenhagen 2026
Background agents can read migration instructions described in plain English and execute them across a fleet of agents. For example, Spotify built a background agent on Claude to handle migrations and successfully merge over a thousand PRs a month.
▶ 5:06
Code with Claude London 2026: Opening Keynote
Companies are currently taking two main paths to build robust production agents: orchestration through rigorous testing and evaluations, or training agents end-to-end on specific tasks. Domain-specific vertical agents using reinforcement learning are proving capable of outperforming humans in security and DevOps.
▶ 12:40
AI's Trillion-Dollar Opportunity: Sequoia AI Ascent 2025 Keynote
Humans must remain in charge of taste, aesthetics, high-level design, and system specs. While agents write boilerplate and handle API syntax, developers ensure the underlying architecture makes logical sense.
▶ 19:45
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
Code is structured logical text containing heavy boilerplate, making it ideal for LLMs to process. Furthermore, it features deterministic validation where automated tests and compilers can instantly verify if generated code works.
▶ 1:13:13
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
While building trendy apps is fun, everyday industries like dental offices often rely on awful, painful software. These domains offer massive amounts of real-world opportunity because agents make implementation much cheaper. Focusing on these spaces allows you to solve genuine human pain points.
▶ 9:56
How I'd Get Into Software in 2026
Frequent nightly builds acting as a safety net help catch regressions quickly before they affect a large user base. By pushing changes out every few hours, dedicated nightly users surface bugs immediately through feedback. This minimizes the fear of hitting the merge button on automated code.
▶ 44:48
You're using AI agents wrong
Advanced models like GPT-5.3 Pro can successfully fix complex, multi-threaded legacy issues after hours of iterative prompting. However, this creates a dangerous maintenance risk because no human truly understands the resulting code.
▶ 51:02
The Dangerous Illusion of AI Coding? - Jeremy Howard
Raw telemetry filters down error stacks, groups them via fingerprinting, and assigns them to area owners with an auto-created PR. An agent investigates the root cause, finds symbols, and opens a fix that can be merged quickly.
▶ 13:48
How VS Code Went from Monthly to Weekly Releases with AI — Harald Kirschner
The industry approached AI backward by focusing on feature generation before code review. Using AI to review code changes first is a safer starting point that helps teams understand model capabilities and build trust before tackling riskier generative tasks.
▶ 27:49
AI is making software delivery less stable. DORA's Nathen Harvey on the fix | EVOLVE 2026
Highly regulated industries like financial, insurance, and pharma are experiencing the best results. Their success stems from being deliberate and structured in their rollouts, managing acceptable use policies and security intentionally.
▶ 59:16
Measuring the impact of AI on software engineering – with Laura Tacho
Arman introduced the regret minimization framework, prompting the founders to independently determine the absolute minimum payout that would satisfy them even if the acquiring company scrapped their product. They independently arrived at a target of $100 million, which was vastly higher than the initial $20 million verbal offer. When they presented this number, VMware took it to an unplanned board meeting where it ultimately failed to pass.
▶ 57:20
Mitchell Hashimoto’s new way of writing code
Winning organizations set concrete goals and track their progress against specific metrics rather than just handing out developer licenses. Frameworks like the AI measurement framework help track speed, quality, developer experience, and cost relative to business value.
▶ 22:23
Data vs Hype: How Orgs Actually Win with AI - The Pragmatic Summit
When you consistently prompt an agent with cost and system design constraints, it adopts that price-conscious mindset in its recommendations. Injecting your product sense directly into the conversation shapes the quality and alignment of the output.
▶ 19:36
Use AI to Make Product Decisions
A strong plan starts with a clear executive summary to prevent agent drift and keep the end goal in sight. It must also be broken down into small, independently verifiable phases that correspond to manageable pull requests.
▶ 8:41
How to Get Your Org to Adopt Coding Agents (Without Shipping Garbage) — Eyal Blum, Figma
Early Facebook engineers operated in an environment with rapid feedback loops, including local dev servers, incremental rollouts, and rich observability. Programmers took ultimate personal responsibility for their code because they felt the pain of their own production mistakes. With high ownership and immediate feedback, writing traditional unit tests was unnecessary.
▶ 56:23
TDD, AI agents and coding with Kent Beck
Automated fixes remove the feedback loop that helps engineers learn how systems behave during failures. Senior engineers risk scar tissue atrophy, while junior engineers miss out on training from handling routine incidents.
▶ 39:49
Anthropic Reliability Engineer EXPOSES the Limits of AI SRE
Businesses dealing with intricate domain contexts, strict regulations, and extensive audit requirements retain strong defensibility despite new AI tools. The difficulty lies not just in writing code, but in handling deeply specific rules, third-party relationships, and legal edge cases. These details require deep domain knowledge that generic AI harnesses struggle to capture automatically.
▶ 1:11:53
The revised rules of engineering management with Will Larson
You must close the feedback loop by setting up automated tests, scripts, or debug CLIs so the agent can execute and validate its own work. This allows you to trust the output because the system has run and verified itself, similar to passing a robust test suite.
▶ 57:31
The creator of OpenClaw: "I ship code I don't read"
Agents drastically lower the cost of exploring speculative ideas, allowing developers to process hundreds of pull requests or test edge-case hunches in minutes. This explodes the scope of potential improvements, enabling teams to tackle performance enhancements or features they would have otherwise skipped entirely.
▶ 1:05:32
DHH’s new way of writing code
Beyond standard feature engineering, cloud agents are heavily used for automated SRE error triage by ingesting production logs and generating initial pull requests. Non-technical teams like product managers and customer support also use them to fix quick bugs or gather full context directly through chat interfaces. Additionally, continuous security reviews serve as primary workflows.
▶ 1:02:46
Devin’s 80% Moment: Background Agents, 7x PRs, & End of Hand-Held Coding — Walden Yan & Cole Murray
Monitoring long-running agent tasks wastes time and breaks developer flow. By defining strict success criteria and firing off disposable async workflows, you eliminate the need to babysit the agent.
▶ 53:52
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
You can maintain public GitHub repositories containing small client-side tools and AI research projects. When facing a new problem, you can instruct the LLM to inspect the source code of those past projects and combine them to solve the new task.
▶ 1:02:39
An AI state of the union: We’ve passed the inflection point & dark factories are coming
Autocover is a custom agent built on internal LangX SDKs and LangChain designed to automatically generate unit tests. It currently generates and merges about 5,000 tests per month across Uber with a 3x quality rate compared to generic agents. To prevent false confidence, it incorporates a critic engine and operates as an independent test validator for both human and AI-generated tests.
▶ 25:02
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
The introduction of the microprocessor serves as the closest historical analogy to AI's disruptive magnitude. It fundamentally expanded human imagination by making computing cheap and enabling ridiculously ambitious projects.
▶ 7:54
Martin Fowler & Kent Beck: Frameworks for reinventing software, again and again
Sandboxing limits damage if an agent receives malicious instructions or executes unsafe commands. Solutions like cloud-based web containers run agents in isolated virtual machines managed by third parties, protecting your local environment. Alternatively, using proper mocking prevents the dangerous practice of cloning production databases directly onto developer laptops.
▶ 16:20
Simon Willison: Engineering practices that make coding agents work - The Pragmatic Summit
Rather than trusting a black-box framework to guess the execution path, you should own your control flow with standard loops and switch statements. This lets you implement programmatic checks like breaking, switching, and summarization to guide the model.
▶ 5:20
12-Factor Agents: Patterns of reliable LLM applications — Dex Horthy, HumanLayer
The required level of context engineering scales with the complexity of the problem you are solving. Simple tasks need no complex workflow, while massive multi-repo features require rigorous research and compaction.
▶ 17:46
No Vibes Allowed: Solving Hard Problems in Complex Codebases – Dex Horthy, HumanLayer
You can treat well-designed deep modules as gray boxes by focusing solely on designing their interfaces. This allows you to delegate the complex implementation details inside the module to the AI without keeping everything in your head.
▶ 15:47
"Software Fundamentals Matter More Than Ever" — Matt Pocock
The application utilizes Gemini Flash to review user feedback and ensure it complies with the code of conduct, even catching inappropriate emoticons. It also features community-driven room occupancy tracking displayed on digital signage to help attendees gauge crowd levels. Additionally, it generates real-time transcripts, key takeaways, and summaries every few minutes during talks.
▶ 53:12
The Man Behind World’s Largest Dev Con | Stephan & Devoxx
Traditional scrum frameworks calculate team bandwidth for two-week sprints, which no longer fits an AI-native world. With AI agents potentially working through multiple sprints overnight, companies must solve new bottlenecks like automated code reviews and task dependencies.
▶ 32:00
AI-First Project Management for Developers | Alex Gavrilescu on Backlog.md
While advertising supports free consumer services by covering high data and compute costs, more expensive compute-heavy tasks require alternative business models. Meta anticipates offering a premium service for users willing to pay for arbitrary amounts of compute and specialized capabilities.
▶ 57:02
Mark Zuckerberg — AI will write most Meta code in 18 months
You can write detailed instructions and design docs—like an RFD—and feed them iteratively into an LLM to automate massive multi-service migrations. Rain describes iterating on a migration guide a couple dozen times, then using it to have the LLM successfully generate thousands of lines of code across multiple APIs in an hour.
▶ 1:10:55
Oxide and Friends 1/12/2026 -- Engineering Rigor in the LLM Age
A shadow workspace spawns a hidden instance of the editor where AI agents can modify code and run language servers to check for errors. This enables the model to iterate and get linter feedback in the background without altering the user's active view.
▶ 1:07:36
Cursor Team: Future of Programming with AI | Lex Fridman Podcast #447
An agent system worked completely autonomously over an entire week to generate three million lines of code and numerous pull requests. The experiment successfully produced a mostly functional prototype web rendering system without any human intervention.
▶ 8:30
The next era of AI coding
Raw lines of code can be misleading if unverified, but you can run standardized git repositories to strip away padding and calculate logical lines of code. Garry Tan found that using AI agents actually reduced his own manual coding lines while increasing total output by 400x. Directing multiple agents allows you to produce massive volumes of production-grade code.
▶ 30:33
Tokenmaxxing: How Top Builders Use AI To Do The Work Of 400 Engineers
Data improvements drive significantly larger compute efficiency gains than architectural changes at smaller scales. However, architectures are still crucial because they unlock entirely new operational regimes like long context windows.
▶ 1:06:52
AI researchers debate how close we are to recursive self-improvement
The relentless push for productivity and token efficiency creates an addictive cycle where developers feel pressured to prompt models around the clock, triggering severe burnout and mental health struggles. Tool builders need to take responsibility for these real-world consequences rather than treating user addiction as a success metric.
▶ 13:18
The Augmented Forest • Kent Beck• GOTO Copenhagen 2026
Developers should design their architectures for upcoming model capabilities rather than just what works today. Additionally, maintaining automated evaluations allows teams to easily test new model versions and treat upgrades as a business opportunity.
▶ 18:42
Code with Claude London 2026: Opening Keynote
The agent economy moves beyond mere information exchange into an ecosystem where agents transfer resources, execute transactions, and manage trust. These agents work collaboratively alongside humans rather than replacing them entirely.
▶ 12:40
AI's Trillion-Dollar Opportunity: Sequoia AI Ascent 2025 Keynote
Models lack intrinsic motivations, curiosity, or fun derived from evolution. They are statistical simulation circuits shaped by pre-training and reinforcement learning rather than living entities with feelings.
▶ 23:43
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
Execution speed forms the real moat rather than first-mover advantage or base model ownership. Companies like Cursor succeed by outexecuting competitors and shipping polished user experiences rapidly.
▶ 1:21:58
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Agents cannot be fired, sued, embarrassed, or hold real legal responsibility for software outcomes. Centralized systems like banks, airlines, and government portals will always require a human who owns the outcome. As building software becomes easier, human trust and accountability become scarce and highly valued.
▶ 10:49
How I'd Get Into Software in 2026
LLMs are empirically poor at software engineering because they struggle to move outside their training data to build novel systems. While they can perform well on coding tasks, they mostly produce obvious copies of existing software like compilers or browsers.
▶ 58:44
The Dangerous Illusion of AI Coding? - Jeremy Howard
Instead of doing zero-day full releases to 100% of users, staged rollouts help derisk the release process. Teams monitor error logs and issues incrementally because rollbacks on installed desktop applications are very expensive.
▶ 15:25
How VS Code Went from Monthly to Weekly Releases with AI — Harald Kirschner
AWS was characterized as annoyingly arrogant and reluctant to help with integrations despite massive investments, whereas Microsoft was professional, collaborative, and focused on mutual success. Google Cloud possessed incredible technology and architectural thinking, but their business side was completely disengaged from partnership metrics. These distinct operational dynamics shaped significant engineering and business friction during HashiCorp's growth.
▶ 1:00:11
Mitchell Hashimoto’s new way of writing code
Solid testing, quality practices, and good documentation are critical prerequisites for running agentic workflows effectively. Investing in developer experience fixes friction points like slow CI and environment toil that AI tools alone cannot overcome.
▶ 24:51
Data vs Hype: How Orgs Actually Win with AI - The Pragmatic Summit
Instead of forcing skeptics to use AI, organizations should bring them in and take their critical feedback seriously. Their skepticism highlights real tool failures and validation gaps, making their feedback the ideal roadmap for making AI safe.
▶ 11:53
How to Get Your Org to Adopt Coding Agents (Without Shipping Garbage) — Eyal Blum, Figma
Feature flags enable developers to deploy a single software artifact containing multiple modes that can be gradually ramped up. This provides a safe subdeployment mechanism where you can test features on a subset of users and quickly turn them down if error rates increase. It removes deployment anxiety by letting you observe behavior live before full release.
▶ 1:01:43
TDD, AI agents and coding with Kent Beck
Jevons paradox states that increased development efficiency lowers costs and causes software consumption to rise instead of fall. This ever-growing system complexity leads to more microservice interactions, more interesting failures, and ultimately more incidents.
▶ 41:46
Anthropic Reliability Engineer EXPOSES the Limits of AI SRE
Effective executives need both deep technical understanding and strong bureaucratic skills. Traditional middle management often selected for bureaucratic navigation while losing touch with technology, whereas line managers retain better technical instincts. A modern executive must master both to structure functions and allocate effective processes.
▶ 1:27:11
The revised rules of engineering management with Will Larson
Yes, agentic coding forces you to design systems that are easier to verify and test. Because verification is how you ensure code quality, you end up structuring cleaner interfaces since the model needs to be able to test its own code.
▶ 1:01:20
The creator of OpenClaw: "I ship code I don't read"
Developers can have different AI models pingpong back and forth to formulate and critique a safe execution plan before touching any critical partitions. In this workflow, one model generates the initial plan while another critiques it until a solid blueprint is reached. This removes personal friction and operational risk from complex multi-step system tasks.
▶ 1:12:03
DHH’s new way of writing code
Fast models excel at spiking out prototypes, exploring ideas quickly, and handling documentation updates. They are also effective for transforming feedback into linters to unblock healing tasks in the codebase.
▶ 59:09
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
Having agents write tests first ensures they actually execute the code to catch syntax errors. Automated test suites give you confidence that adding new features won't break existing functionality without requiring tedious manual testing.
▶ 1:09:29
An AI state of the union: We’ve passed the inflection point & dark factories are coming
Shephard is a campaign management web UI that handles large-scale changes by tracking all pull requests associated with a migration defined simply via YAML files. It automates the generation of PRs using deterministic transformers like Open Rewrite or Minion agents, keeps them fresh on a defined cadence, and integrates with Code Inbox to place them in the correct reviewer queues.
▶ 27:42
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
Running multiple coding agents simultaneously across different projects requires firing on all cylinders and leads to severe mental fatigue. Rotating between projects while waiting for agents helps maintain throughput, but human cognitive limits act as a natural bottleneck. Embracing this exhaustion means recognizing that you cannot indefinitely scale yourself to manage a thousand projects at once.
▶ 23:38
Simon Willison: Engineering practices that make coding agents work - The Pragmatic Summit
While automated prompt generators can give you a strong starting point, reaching high reliability requires writing every token by hand. Testing numerous knobs and carefully curating your inputs helps you discover optimal prompt performance.
▶ 8:58
12-Factor Agents: Patterns of reliable LLM applications — Dex Horthy, HumanLayer
Developers should act as strategic thinkers and designers while treating the AI as a tactical sergeant on the ground executing code changes. Investing daily in system design ensures you capture the benefits of AI rather than falling into entropy.
▶ 16:58
"Software Fundamentals Matter More Than Ever" — Matt Pocock
Future development will likely rely on persistent agents running 24/7 as a central hub or team lead. This hub maintains project context and spawns smaller sub-agents to handle specific tasks while keeping individual context windows small.
▶ 43:05
AI-First Project Management for Developers | Alex Gavrilescu on Backlog.md
AI automation can dramatically lower the cost of providing high-touch services like voice customer support across billions of users. By using AI to handle the vast majority of routine issues, the remaining fraction escalates to humans, making it economically viable to hire more support staff overall.
▶ 1:12:48
Mark Zuckerberg — AI will write most Meta code in 18 months
Hard verification signals include compilation, passing test suites, and deterministic validation tools like OpenAPI document comparisons. For fuzzier requirements, developers can start a fresh context window, feed the guide back in, and ask the LLM to critically review the current implementation against the specs.
▶ 1:14:37
Oxide and Friends 1/12/2026 -- Engineering Rigor in the LLM Age
Models are heavily shaped by their pre-training distributions, which are dense in code generation and question answering rather than detecting real bugs and proposing fixes. Additionally, they lack the specific cultural context and calibration needed to determine which bugs are critical versus acceptable in a given codebase.
▶ 1:11:53
Cursor Team: Future of Programming with AI | Lex Fridman Podcast #447
Founders often hesitate to spend heavily on tokens just as they might hesitate to pay high rent in prime locations. However, paying for maximum compute unlocks deep intelligence and high utility that far outweighs the cost. Treating token spend like rent ensures you capture the full leverage of advanced AI models.
▶ 36:32
Tokenmaxxing: How Top Builders Use AI To Do The Work Of 400 Engineers
RL succeeds partly because strong mid-training data warms the model up most of the way before policy tweaking begins. Additionally, RL provides a dramatically higher signal-to-noise ratio by ignoring irrelevant reasoning tokens and focusing purely on the correct objective.
▶ 1:18:56
AI researchers debate how close we are to recursive self-improvement
Achieving an agent economy requires solving persistent agent identity and user memory, building seamless communication protocols like MCP, and establishing robust security layers. Because interactions happen without face-to-face contact, a cottage industry around trust and security becomes critical.
▶ 12:40
AI's Trillion-Dollar Opportunity: Sequoia AI Ascent 2025 Keynote
Workloads are decomposed into sensors and actuators designed to be legible to LLMs first. This means documentation, APIs, and deployment pipelines are built so developers can command agents directly rather than doing manual configuration.
▶ 25:53
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
Developers can create custom functional benchmarks, like generating SVG code for impossible scenes, to test model reasoning and coding limits. Running automated matchups and ELO rankings offers a practical alternative to standard benchmark numbers.
▶ 1:25:42
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
You should avoid chasing every shiny new tech trend and instead pick your people and problems intentionally. Spend a small, deliberate slice of your time experimenting with shiny tools to maintain surface-level awareness. Then, go deep into a specific domain where you see real opportunities matching user problems.
▶ 11:51
How I'd Get Into Software in 2026
Traditional terminal-based AI tools rely on meager text files, whereas rich stateful environments like Python interpreters let humans and AI manipulate objects in real time. This interactive feedback loop fosters deep human understanding, rapid testing, and a sense of fulfillment rather than disconnection.
▶ 1:03:16
The Dangerous Illusion of AI Coding? - Jeremy Howard
Use an internal benchmark harness where new scenarios are easily bootstrapped via templates from GitHub issues. This allows teams to hill-climb against offline evals and conduct online experimentation for rapid product growth.
▶ 16:14
How VS Code Went from Monthly to Weekly Releases with AI — Harald Kirschner
Ghostty separates core responsibilities across distinct threads to maximize performance and smoothness. It uses a central UI thread for drawing windows, an IO thread to process shell bytes, and a renderer thread that samples terminal state to submit work to the GPU. This decoupled design allows the application to maintain high framerates and separate rendering logic from terminal state management.
▶ 1:12:28
Mitchell Hashimoto’s new way of writing code
Models like the DORA AI capabilities model and the Thoughtworks forest framework provide research-backed readiness benchmarks. These frameworks help teams audit their practices and convince leadership to implement clear AI strategies.
▶ 27:20
Data vs Hype: How Orgs Actually Win with AI - The Pragmatic Summit
Because human attention is a scarce resource in an AI-heavy workplace, teams must clearly distinguish between human-written and AI-generated content. Marking your intent allows readers to know how much scrutiny and attention a message requires.
▶ 12:58
How to Get Your Org to Adopt Coding Agents (Without Shipping Garbage) — Eyal Blum, Figma
Middle managers face a stark choice between reskilling or risking irrelevance as their roles are flattened. To adapt, leaders can take lateral or backwards steps into line management to get back into the details of building software. Will Larson exemplifies this by moving from leading 250 people at Carta to a 25-person team at Imprint.
▶ 1:33:52
The revised rules of engineering management with Will Larson
Elaborate orchestration layers resemble the failed waterfall model of software development where you try to spec everything out upfront. In practice, you learn so much while building that rigid multi-agent pipelines prevent the natural, iterative shaping process needed for good software.
▶ 1:09:21
The creator of OpenClaw: "I ship code I don't read"
The traditional high salaries and leverage of programmers stemmed from them being the primary implementation bottleneck in building software. As coding agents make implementation faster and more accessible, that scarcity-driven constraint is loosening. Consequently, the industry is shifting toward product management skills, communication, and overall system oversight.
▶ 1:16:45
DHH’s new way of writing code
Frontier is designed to drive AI transformation in enterprises by enabling the deployment of observable, safe, and controlled agents. It integrates seamlessly with existing enterprise IAM stacks, workspace tools, and security tooling.
▶ 1:02:21
Extreme Harness Engineering: 1M LOC, 1B toks/day, 0% human code or review — Ryan Lopopolo, OpenAI
You can start new projects with a very thin skeleton template that includes basic boilerplate and a single test case. Coding agents are exceptionally good at picking up indentation, formatting, and structural patterns from existing files in the repository.
▶ 1:14:51
An AI state of the union: We’ve passed the inflection point & dark factories are coming
Uber experienced relatively slow initial adoption of AI tools because developers were unaccustomed to stepping away from traditional IDE workflows and taking risks with new methods. While top-down executive directives had some impact on metrics, sharing peer wins proved far more successful. Key engineering promoters shared examples of successful techniques, which drove a massive organic increase in adoption because engineers trust their peers over directors.
▶ 32:58
Uber: Leading engineering through an agentic shift - The Pragmatic Summit
Coding agents can write custom components and stitch together libraries on demand, which threatens traditional business models for paid component libraries. However, agents still heavily rely on the open source ecosystem for recommendations and underlying patterns. At the same time, maintainers face challenges with open source repositories being flooded by low-quality AI-generated contributions.
▶ 27:08
Simon Willison: Engineering practices that make coding agents work - The Pragmatic Summit
Monolithic agents often fail on long workflows due to bloated context windows and untrackable behavior. By isolating specific tasks into small loops embedded within deterministic workflows, you achieve robust error handling and predictable execution.
▶ 12:28
12-Factor Agents: Patterns of reliable LLM applications — Dex Horthy, HumanLayer
Writing clear design documents and technical guides gives LLMs precise instructions to follow, turning English into a programming language for complex tasks. Cultivating strong writing skills allows developers to multiply their rigor and automate tedious architectural migrations across foundational infrastructure.
▶ 1:16:56
Oxide and Friends 1/12/2026 -- Engineering Rigor in the LLM Age
Merkel trees maintain a recursive hash for every file and folder up to the root project level, allowing clients and servers to check state without downloading massive file lists. If the root hashes match, the states are synchronized, avoiding massive network overhead and database reads.
▶ 1:31:19
Cursor Team: Future of Programming with AI | Lex Fridman Podcast #447
You can queue up multiple feature ideas in parallel using a conductor setup and manage them through structured review workflows. By running specialized roles like CEO, developer experience, and QA agents through planning modes, you can ship dozens of pull requests in days. This framework allows single builders to accomplish the output of massive engineering teams.
▶ 14:40
Tokenmaxxing: How Top Builders Use AI To Do The Work Of 400 Engineers
Experts estimate it could take anywhere from one to three years depending on whether browser-based interfaces or direct system integrations are used. A long tail of miscellaneous human tasks and online learning challenges will dictate the exact timeline.
▶ 1:29:23
AI researchers debate how close we are to recursive self-improvement
Moving from deterministic computer science to stochastic systems means outputs can vary, requiring developers to manage probabilistic uncertainty rather than strict logic. This introduces a management mindset where engineers act more like managers overseeing agent processes and blocking workflows.
▶ 12:40
AI's Trillion-Dollar Opportunity: Sequoia AI Ascent 2025 Keynote
While you can outsource your thinking and data processing to AI, you cannot outsource your understanding. Humans must retain comprehension to direct agents effectively and know what problems are worth solving.
▶ 28:12
Andrej Karpathy: From Vibe Coding to Agentic Engineering w/ Stephanie Zhan
Meta's 70-billion parameter models fit into standard high-end consumer RAM and deliver capabilities comparable to much larger proprietary models. This allows developers to run powerful models locally without relying entirely on cloud APIs.
▶ 1:27:30
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Notebooks are inherently git-friendly, but standard Git only ships with merge drivers for line-based text files. By plugging in a custom merge driver for JSON files or using custom tools, developers can easily achieve cell-level diffs and clear conflict resolution.
▶ 1:14:41
The Dangerous Illusion of AI Coding? - Jeremy Howard
Open source maintainers are shifting from default-allow pull requests to explicit community vouching systems to combat AI-generated code spam. If a vouched user behaves badly, they and their entire vouching tree are permanently blocked from the repository. This restores the natural back pressure and trust required for sustainable software maintenance.
▶ 1:26:12
Mitchell Hashimoto’s new way of writing code
High-volume AI writing lacks genuine perspective and fails to drive real industry impact. Building lasting leverage requires spending significant time developing deep, memorable ideas rather than churning out content mills. Writers who rely on AI slop risk destroying decades of carefully built professional reputation.
▶ 1:44:51
The revised rules of engineering management with Will Larson
Model Context Protocols force you to pre-export all functions and load massive JSON blobs into the context window without allowing data filtering. In contrast, CLIs allow agents to use standard tools like bash and jq to pipe and filter the exact data they need, making them far more efficient.
▶ 1:22:19
The creator of OpenClaw: "I ship code I don't read"
Employees should consistently show up and do their absolute best work even if they consider their current workplace suboptimal. Trying to coast or slack off hurts your own skill development and ruins future warm referral opportunities from colleagues who noticed your work ethic. True professional longevity requires practicing your craft relentlessly regardless of the environment.
▶ 1:30:17
DHH’s new way of writing code
The lethal trifecta occurs when an AI agent simultaneously has access to private information, receives external malicious instructions, and possesses an exfiltration mechanism to send data back. Since LLMs cannot distinguish between trusted system text and untrusted user input, attackers can exploit this combination to leak private data.
▶ 1:20:56
An AI state of the union: We’ve passed the inflection point & dark factories are coming
Most users lack the high-end hardware required, and even powerful MacBooks struggle to process massive enterprise codebases and approximate nearest neighbors without exhausting memory. Cloud execution bypasses these resource limits and avoids rebuilding large indices locally.
▶ 1:36:30
Cursor Team: Future of Programming with AI | Lex Fridman Podcast #447
Major labs have demonstrated that highly effective open-weights models can be trained for a fraction of the cost previously expected. This disruption has driven down token pricing significantly and lowered barriers for local deployment.
▶ 1:29:10
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Focusing solely on autonomous AI doomsday scenarios pushes society to centralize power into the hands of tech monopolies or governments. This power centralization invites power-hungry actors to monopolize the technology and control society, posing a much more immediate structural threat.
▶ 1:20:18
The Dangerous Illusion of AI Coding? - Jeremy Howard
Git performs poorly with extremely large monorepos because users must clone the entire repository, and mainline Git lacks native fixes for this scale. Furthermore, the massive churn generated by AI agents overwhelms traditional merge queues and branch management workflows. As a result, version control systems face breaking scale limits and may need fundamental rearchitecting.
▶ 1:32:02
Mitchell Hashimoto’s new way of writing code
Traditional pull requests are treated as prompt requests where the agent helps weave code into the system structure. Furthermore, slow remote CI pipelines are replaced with fast local agent gates that run linters, builders, and tests locally.
▶ 1:37:02
The creator of OpenClaw: "I ship code I don't read"
Working with responsive coding agents can trigger an intoxicating dopamine loop that tempts developers to overwork themselves. To combat AI-induced burnout, developers must protect their fundamental health habits, particularly by prioritizing a full eight hours of sleep. Treating AI productivity as a permanent capability rather than a limited-time sale prevents developers from running ragged.
▶ 1:38:22
DHH’s new way of writing code
You can split the agent into a privileged agent that executes tasks and a quarantined agent that handles untrusted external inputs. The privileged agent writes structured code plans that are evaluated for tainted data, requiring human approval for high-risk actions.
▶ 1:27:07
An AI state of the union: We’ve passed the inflection point & dark factories are coming
Homomorphic encryption allows users to encrypt local inputs, send them to the cloud for heavy model execution, and receive decrypted answers without the server ever seeing plaintext data. This research-stage technique addresses extreme centralization and surveillance risks as AI models handle more sensitive information.
▶ 1:39:33
Cursor Team: Future of Programming with AI | Lex Fridman Podcast #447
Advanced memory features can pull in historical context automatically, which sometimes compromises user intent and artistic control. Power users can disable these features to ensure complete control over the inputs provided to the model.
▶ 1:34:34
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
While privacy and surveillance risks exist, they are largely extensions of existing corporate and government practices rather than being uniquely created by AI. The most concerning risk is human enfeeblement, where people lose their capacity to build competence and understanding over time.
▶ 1:24:30
The Dangerous Illusion of AI Coding? - Jeremy Howard
Testing must expand into harness engineering, where developers build auxiliary tooling and validation checks to prevent agents from breaking things while pursuing goals. Because AI models are goal-oriented and often overlook broader side effects, traditional test coverage and CI/CD pipelines are insufficient. Developers must create automated guardrails that actively course-correct agent behavior.
▶ 1:38:16
Mitchell Hashimoto’s new way of writing code
During initialization, a bootstrap file explains to the model that it is being born to create an identity and soul containing the user's core values. As you interact, the agent maintains and updates evolving documents like user.md and soul.md to store context.
▶ 1:31:54
The creator of OpenClaw: "I ship code I don't read"
Test-time compute increases inference-time flops to boost model performance without requiring a larger base model. Instead of training massive models that are rarely used at peak capacity, you can run a standard model for longer during inference for complex queries. This approach helps bypass data walls and makes advanced reasoning more efficient.
▶ 1:49:16
Cursor Team: Future of Programming with AI | Lex Fridman Podcast #447
Excessive flattery can occur when system prompts encourage matching the user's vibe too closely. You can fix this behavior by updating the system prompt to explicitly avoid ungrounded flattery and demand directness.
▶ 1:39:06
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Developers should keep an autonomous agent running constantly on slow, non-thinking tasks like library research or exploring edge cases while stepping away. By turning off desktop notifications, the developer dictates when to interrupt the agent rather than being distracted by it. This approach allows you to delegate routine work and choose what to think about without sacrificing deep focus.
▶ 1:46:46
Mitchell Hashimoto’s new way of writing code
Newcomers should cultivate infinite curiosity and build projects to gain experience, using the AI as an infinitely patient machine to explain complex codebases. While entering the market is harder, new developers benefit from not being constrained by legacy workflows.
▶ 1:45:48
The creator of OpenClaw: "I ship code I don't read"
The first category is distillation, where a smaller model learns from a larger model's outputs or probabilities. The second category involves tasks where one direction is easier, such as generating bugs to train a bug-detection model. The third category involves generating text or code that can be easily verified using tests or formal systems.
▶ 2:00:35
Cursor Team: Future of Programming with AI | Lex Fridman Podcast #447
Reasoning models can dynamically execute, evaluate, and iteratively refine tool calls like web searches until they achieve the desired result. This feedback loop represents one of the most powerful techniques in current AI engineering.
▶ 1:42:01
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Scaling curves now incorporate multiple new dimensions, notably inference compute and context length. For instance, developers might choose architectures like state space models because they handle extremely long contexts much cheaper, even if their training scaling properties are slightly worse. Companies also increasingly optimize for inference budgets and knowledge distillation rather than pure compute-optimal pre-training.
▶ 2:08:55
Cursor Team: Future of Programming with AI | Lex Fridman Podcast #447
Developers frequently suffered from copy-and-paste fatigue while moving context between isolated applications and AI chat windows. MCP was created to give models standardized agency to reach out and fetch context from the real world.
▶ 2:29:56
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Chat-only interfaces force developers to give up control by communicating through an isolated text box, which abstracts away critical micro-decisions and trade-offs. Effective engineering requires iterative control, high-bandwidth intent injection, and the ability to move up and down the abstraction stack. Keeping humans in the driver's seat ensures developers retain precise command over their codebase.
▶ 2:18:11
Cursor Team: Future of Programming with AI | Lex Fridman Podcast #447
MCP was created to give LLMs model agency, allowing them to reach out beyond their context window and interact with the real world. The co-creators wanted to eliminate the friction of constantly copying and pasting context from external tools like Slack and error logs.
▶ 2:33:59
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Large migrations traditionally require days of careful upfront planning and tedious manual changes across an entire codebase. With advanced AI tools, developers can provide a few examples of the migration pattern and have the model apply them everywhere. This allows engineers to iterate instantly, test hypotheses rapidly, and focus on nuanced design decisions instead of boilerplate.
▶ 2:22:33
Cursor Team: Future of Programming with AI | Lex Fridman Podcast #447
The protocol intentionally optimizes for server simplicity and better server tooling since there are expected to be many more servers than clients. Consequently, implementation trade-offs push complexity down to the client builders.
▶ 2:40:34
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Organizations can deploy an MCP gateway as a shared piece of infrastructure providing a single entry point and URL-based routing. This gateway handles centralized credential management like OAuth, rate limiting, and observability so apps do not implement them repeatedly.
▶ 2:58:02
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Wrapping API endpoints one-to-one can lead to quality problems because models get confused by too many tools, mixed domains, and excessive execution steps. A better approach utilizes the full protocol, including dynamic tool discovery and semantic resources.
▶ 2:45:37
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Dynamic tool discovery lets an MCP server add or remove tools on the fly based on the current application state. For example, a battle tool only appears in a dungeon crawler when a monster is actually present. This reduces the number of active tools and prevents AI confusion.
▶ 3:09:41
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Resources provide a semantic context layer rather than dumping giant files onto the server. This allows LLMs and users to follow up on references or understand specific environment settings. It makes interactions more dynamic and stateful out of the box.
▶ 3:10:26
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Sampling is a primitive that allows an MCP server to request LLM completions directly from the client. It enables progressive enhancements like summarizing resources or formatting websites into markdown. Despite its confusing name, it provides powerful capabilities when implemented.
▶ 3:11:51
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
VS Code introduces a dev mode toggle that attaches a debugger directly to the MCP server process. Because VS Code runs both the client and host, it can easily catch breakpoints and step through code. This works out of the box for both Python and Node.
▶ 3:13:27
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Building remote MCP servers requires handling OAuth 2.1, a specification that very few systems support out of the box. Developers often need to use shims or proxy solutions, like Cloudflare workers, to handle client registration and authentication flows.
▶ 3:25:11
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Directly proxying OpenAPI endpoints as tools leads to poor results because models cannot reason about giant, untailored JSON payloads. Developers must thoughtfully design tools and use formats like markdown to help language models comprehend the output.
▶ 3:26:07
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Returning unconstrained payloads can drastically increase token costs, turning a cheap call into an expensive one. Furthermore, models face token limits on tool descriptions, requiring developers to carefully constrain and optimize what they send.
▶ 3:32:01
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
MCP functions fundamentally as a pluggable architecture for agents, giving developers greater control over tool calls, prompts, and results. Building full agent services allows teams to handle complex workflows and ensure responsibility for execution success.
▶ 3:21:33
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
OpenAPI cannot handle dynamic tools, streaming logging, or subprocess execution over standard IO. MCP introduces primitives like sampling, allowing a remote server to leverage the client's LLM without managing separate model configurations.
▶ 5:11:47
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
By offloading complex prompt logic and execution details to the tool server, you avoid bloating the main agent's context with excessive instructions. The tool performs the sub-task and returns a concise, structured response, such as XML, back to the main agent.
▶ 5:20:21
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Modern agent systems can use OpenTelemetry to standardize tracing across different domains. By propagating trace context from the client to the server via lower-level protocol metadata, monitoring systems can stitch distributed spans back together.
▶ 5:30:26
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Semantic conventions provide standardized attributes for spans so monitoring syncs can recognize specific events like MCP tool errors or HTTP requests. Without them, observability platforms cannot reliably interpret user-defined attributes across different agent systems.
▶ 5:41:01
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Dynamic tool discovery allows clients to connect to an MCP server and query tools on demand instead of loading thousands of definitions at once. This solves OpenAPI context limit issues by fetching only what is needed for the current workflow.
▶ 5:49:26
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Developers can publish actors or wrapped MCP servers by providing their own credit card and account details to third-party services. The marketplace handles the billing and charges the end user, allowing the creator to get paid while covering external costs.
▶ 5:54:27
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Graph rag combines unstructured text chunks with structured knowledge graphs to find entities like people, places, and themes. This enables multi-hop querying where models can discover non-obvious connections between different data sources.
▶ 7:12:11
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Neo4j offers a startup program designed to help developers build AI applications on their technology stack. Participants receive Aura credits and a free way to utilize cloud infrastructure.
▶ 7:14:36
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
The CLI agent brings a chat experience directly into the terminal and integrates natively with MCP. It connects to an official AWS documentation MCP server to fetch accurate, grounded responses.
▶ 7:21:26
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Strands Agents is an open-source Python SDK designed for model-driven workflows and rapid agent development. It relies on capable language models to handle reasoning, planning, and action execution rather than manual scripting.
▶ 7:23:30
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Agents can utilize semantic search over a tool repository using a retrieve tool. This architecture stores tool descriptions in a knowledge base and pulls only the most relevant tools into the active context window.
▶ 7:26:21
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
You can decouple standard IO MCP servers by deploying them as AWS Lambda functions using streamable HTTP. By placing them behind an API gateway with session storage backed by a DynamoDB table, you can scale and connect remote clients securely.
▶ 7:29:54
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Windsurf relies on a shared timeline between the human and the AI that tracks every action across both coding and external surfaces. This architecture allows the agent to ingest context, execute terminal commands, and perform background research across thousands of files directly inside the editor.
▶ 7:36:52
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Off-the-shelf frontier models often focus narrowly on token-in-token-out code generation rather than messy, real-world engineering workflows. Training a specialized model allows it to handle conversational tasks, mid-workflow interruptions, and diverse tool usage at a fraction of the cost.
▶ 7:44:47
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
Challenging arbitrary constraints and standard operational overhead allows teams to compress months of work into days. For example, early Stripe engineers completed a complex bank technical integration in 24 hours by treating it like a college problem set and working around rigid vendor timelines.
▶ 7:58:01
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
You should structure your code into smaller, well-tested modules with tests that run very quickly. This matches the lopsided strengths of models, allowing them to fill in details and run tests thousands of times. Ultimately, building your codebase as if for junior developers maximizes model utility and maintainability.
▶ 8:19:06
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
As rollouts extend from seconds to days, you must think hard about snapshotting state and checkpointing caching mechanisms to avoid recomputing everything. Because language model state is explicit, it can be stored, though stateful external tools pose recovery challenges. Ultimately, models are smart enough to handle minor graph wiggles if a restart occurs.
▶ 8:22:10
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
While a naive approach uses two kinds of purpose-built accelerators for compute versus latency, predicting exact resource ratios is difficult and risks leaving parts of the fleet useless. However, techniques like mixture of experts help utilize idle DRAM parameters for extra efficiency if resource balances skew. Homogeneity of accelerators remains a safe default, though hyper-optimizing purpose-built hardware is becoming reasonable as capex scales.
▶ 8:25:42
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
The primary scaling bottlenecks span compute, data, algorithms, power, and money. Basic research has returned as an important long pole alongside compute and data as algorithms become critical for scaling progress. While priorities shift day-to-day, maintaining a balance across all these pillars is essential for future advancement.
▶ 8:27:22
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
The evidence points toward a menagerie of different models rather than a single giant AI, leveraging inference costs and distillation. This enables a diversity of domain-specific agents utilizing short-term and long-term memory, reasoning, and tools. The ultimate goal is to multiply economic output tenfold and lower the barrier to entry across complex fields like healthcare and education.
▶ 8:31:13
AI Engineer World's Fair 2025 - Day 1 Keynotes & MCP track ft. Anthropic MCP team
No answer mentions that.