The AI Native Dev - from Copilot today to AI Native Software Development tomorrow

AI coding agents now write almost all of Legora's code, with engineers running up to ten in parallel. Yet the CTO behind that shift thinks measuring adoption by tokens burned is a mistake. Jacob Lauritzen, CTO of Legora, joins Simon Maple to unpack what actually scales when agents do the typing, and where human judgment still has to stay in charge.

What we cover:
– How Legora's engineers orchestrate many AI coding agents at once, from shared local dev resources to cloud agent setups
– An agentic loop that reproduces, fixes and tests bugs straight from Slack
– Why token maxing is a bad way to drive AI adoption, and what to measure instead
– Agent evaluation: regression testing the harness as models and prompts change every week
– Decision models, the verifier's rule, and where autonomy ends and human judgment begins
– Why AI agents need more than a chat interface

Chapters:
00:00:00 - Introduction
00:01:47 - Legora's growth from $100M to $200M ARR
00:03:44 - Parallel coding agents and bug-fix loops
00:07:15 - Senior engineers vs AI-first engineers
00:10:10 - Why token maxing is the new lines of code
00:14:13 - What AI can and can't verify in legal work
00:17:30 - Decision models vs autoregressive LLMs
00:24:22 - Weekly model benchmarks and harness evals
00:26:58 - Why AI agents need more than a chat interface
00:35:03 - The verifier's rule and litigation strategy

Build your software factory, one workflow at a time, with Tessl:
https://tessl.co/lpg

🔔 Subscribe for weekly episodes on AI-native development

Is token count telling you anything real about how your team uses AI coding agents? Tell us in the comments.

Honeycomb went from 30 to 70 merged pull requests a day in three months. The catch: automated code review, not code generation, became the real bottleneck of software automation. Liz Fong-Jones, Technical Fellow at Honeycomb, explains why incidents still rose 1.5x, how their internal bot Autobot now reviews every PR, and why AI amplifies whatever org you already have.

What we cover:
– How automated code review lets humans focus on design, not trivial bugs
– Using a decision model like Jev to decide which PRs are safe to auto-merge
– What makes a codebase ready for AI coding agents
– When to trust AI agents with production incidents, and when they're just throwing darts
– Why "Claude did it" isn't an excuse, and what ownership means with AI
– How open source maintainers can handle a flood of AI slop pull requests

Chapters:
00:00:00 - Introduction
00:06:41 - Why AI amplifies dysfunctional engineering orgs
00:10:45 - What makes a codebase AI ready
00:14:01 - Honeycomb's Autobot and automated code review
00:19:06 - Using Jev to decide which PRs are safe to merge
00:26:51 - Trusting AI agents during production incidents
00:30:40 - Least privilege and guardrails for coding agents
00:33:25 - If your name's on it, you own it
00:38:55 - AI slop pull requests and open source
00:45:56 - Will observability engineering survive as a role?

Build your software factory, one workflow at a time, with Tessl:
https://tessl.co/nlr

🔔 Subscribe for weekly episodes on AI-native development

Is your team's review capacity keeping up with your AI coding agents? Tell us in the comments.

HumanLayer CEO Dexter Horthy on why his team's bet on spec driven development nearly wrecked their own codebase, and what changed his mind about reviewing AI-written code. Dexter walks through the "YOLO pull request" experiment that ran for months before the codebase became unusable, the "dumb zone" that limits how much context you can hand a model, and why he now believes there will always be alpha in reviewing something.

What we cover:
– How HumanLayer's "read the plan, skip the code" experiment quietly broke their own codebase
– Why context windows have a "dumb zone," and what that means for context engineering
– Sean Grove's idea that specs, not code, are becoming the durable artifact
– Building overnight agents that review and fix code before a human ever sees it
– Why treating software development like a factory changes how bugs compound
– What Dexter thinks his advice on reviewing AI-written code will look like in 12 months

Chapters:
00:00:00 - Introduction
00:02:15 - Meet Dexter Horthy, CEO of HumanLayer
00:06:03 - The "dumb zone": why more context makes models dumber
00:06:40 - Sean Grove's "the spec is the new code"
00:09:22 - The YOLO pull-request experiment that broke their codebase
00:11:09 - Letting the model own the architecture
00:17:03 - Planning as expected-pain management
00:28:15 - Slop Code Bench and the maintainability oracle problem
00:37:59 - Why software factories aren't like car factories
00:42:49 - "There will always be alpha in reviewing something"

Build your software factory, one workflow at a time, with Tessl:
https://tessl.co/4ep

🔔 Subscribe for weekly episodes on AI-native development

Where do you land on the determinism-to-adaptability slider — plan tightly, or let the agent run? Tell us in the comments.

Spec-driven development is reshaping what software engineers actually do all day, and Marc Brooker, VP and Distinguished Engineer at AWS, has read 3,000 to 4,000 postmortems that convinced him the code was never the hard part. In this episode of The AI Native Dev, Marc explains why testing and specification are now the real engineering work, why metastable failures keep taking down systems that look perfectly healthy, and why he still won't let AI write a single word of his blog.

What we cover:
– Why spec-driven development is turning testing into the hardest part of software
– What metastable failures are, and why they keep taking healthy-looking systems down
– How agentic coding tools can learn from postmortems and build their own memory
– Why classic authorization breaks down once you're writing agentic policy
– Why Marc won't let AI write his blog, but is fully comfortable with AI-generated code
– What it takes to bring junior engineers up to speed in an AI-native industry

Chapters:
00:00:00 - Introduction
00:02:17 - Marc Brooker: 18 years at AWS building agentic dev tools
00:04:36 - Inside Strands, AWS's open source agent SDK
00:06:44 - Fifteen years on call, and what agents still can't debug
00:11:23 - Metastable failures and the humility of 4,000 postmortems
00:14:32 - Teaching agents to learn from postmortems and build their own memory
00:20:14 - Why agentic policy needs more than classic authorization
00:32:14 - The agentic software development hypothesis: spec-driven development, oracles, and testing
00:39:56 - Why Marc won't let AI write his blog (but will let it write code)
00:46:37 - Advice for leveling up junior engineers in the AI era

Build your software factory, one workflow at a time, with Tessl:
https://tessl.co/[SLUG]

🔔 Subscribe for weekly episodes on AI-native development

Do you trust an agent to run its own on-call rotation yet? Tell us in the comments.

Coding agent reliability isn't a model problem, it's a gates problem. Ran Aroussi, creator of yfinance and founder of Automaze, argues that an "agentic workflow" is a contradiction in terms, and that the only thing standing between you and full autonomy is deciding where a human still signs off. He also thinks you stopped needing junior developers for their coding skills about a year ago, and that hiring them anyway is the only way the industry gets its next generation of architects.

What we cover:
– Why "agentic workflow" is a contradiction, and when agentic coding is the wrong tool for the job
– Where a human still has to sign off, and what coding agent reliability actually depends on
– What a software factory changed about delivery times, pricing and the client backlog
– Why you no longer need juniors for their coding skills, and why you should hire them anyway
– Teachable knowledge vs earned knowledge, and the experience agents cannot compress
– The law firm model: why dev agencies may end up looking more like Kirkland & Ellis than a SaaS startup

Chapters:
00:00:00 - Introduction
00:03:05 - yfinance, open source and 30 million downloads a month
00:06:03 - Automaze and the MUXI agent application server
00:10:42 - Where to draw the line on agent autonomy
00:15:12 - Software factories and fully autonomous merges
00:22:25 - The architect archetype and the four-phase ladder
00:28:11 - Teachable knowledge vs earned knowledge
00:30:14 - What agents did to delivery times and pricing
00:37:03 - Why "agentic workflow" is an oxymoron
00:41:08 - Anthropic, OpenClaw and the end of flat subscriptions

Build your software factory, one workflow at a time, with Tessl:
https://tessl.co/vut

🔔 Subscribe for weekly episodes on AI-native development

Where's your gate? Tell us in the comments where you still refuse to let a coding agent merge without a human looking.