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

Tessl

Welcome to The AI Native Developer, hosted by Guy Podjarny and Simon Maple. Join us as we explore and help shape the future of software development through the lens of AI. In this new paradigm of AI Native Software Development, we delve into how AI is transforming the way we build software, from tools and practices to the very structure of development teams.

Our target audience includes developers and development leaders eager to stay ahead of the curve. If you're passionate about the future of software development and curious about how to leverage AI to build effective teams and groundbreaking software, this podcast is for you.

Each week, we bring you insights into the latest AI tools and best practices, keeping you up-to-date with the cutting-edge advancements in the industry. Additionally, every two weeks, we present deep dives with experts and leaders in the AI and software development space, offering a glimpse into the future of AI development.

Tune in to discover how AI will revolutionize your workflows, roles, and organizations. Get inspired by the latest tools and best practices, and prepare to be part of the next generation of software development.

Play

Open in

26 episodes
weekly
Avg 51 min
English

Episodes 26

Newest Oldest Longest

All20 Unplayed20 In progress0 Played0

Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.

S1 · E123
Yesterday · 56 min
AWS's Marc Brooker: Specs, Not Code, Are the Hard Part
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.
- Transcript
- Chapters
S1 · E122
September 8 · 52 min
You Don't Need Juniors to Code. Hire Them Anyway.
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.
- Transcript
- Chapters
S1 · E121
September 2 · 51 min
850 PRs a Week: How Tessl Runs a Software Factory
The software factory that put up 850 pull requests in a week, with 85 to 90% of them handled by agents end to end. Tessl's Head of Product Dru Knox on how it actually got built, why it started with skills rather than automation, and the two things nobody expects a factory to change. Guy Podjarny digs into the skills-to-loops-to-factory path, and what breaks when you skip a step. What we cover: – What a software factory actually is, and how it differs from a pile of disconnected automations – Loop engineering: turning a skill into something that gets better every time it runs – Why context engineering has to come before automation, and what stalls when it doesn't – The two gains nobody forecasts from extra agent capacity: quality and fungibility – Verifiers and evals, or how you enforce a standard that agents are free to ignore – Context-driven code review, and why a general-purpose reviewer plateaus Chapters: 00:00:00 - Introduction 00:03:23 - Kikimora: Tessl's own dark factory 00:04:45 - Skills, loops and factories, defined 00:09:09 - 850 PRs a week, and the road to it 00:11:27 - The surprises: quality and fungibility 00:13:16 - Why a factory has to be context centric 00:16:40 - Context-driven code review and the wall teams hit 00:22:51 - Skills inventory across your whole code estate 00:28:38 - Verifiers, evals and enforcing what you wrote down 00:37:30 - Loops, automations and owning your software factory Build your software factory, one workflow at a time, with Tessl: https://tessl.co/coi 🔔 Subscribe for weekly episodes on AI-native development If you've hit the plateau Dru describes, tell us where it stopped compounding for you.
- Transcript
- Chapters
S1 · E120
August 25 · 45 min
Lada Kesseler: I Trust AI Tests Less Than AI Code
Lada Kesseler's approach to loop engineering is brutally simple: give the agent one step, make it write the result to a file, then read it back and go again. She calls it a centrifuge. Spin fast enough and the stupid comes out. The Logic20/20 principal engineer has spent the last year and a half building the ground rules, skills and refinement loops that fight the defaults coding agents ship with, starting with an instruction to stop trying to please her. Along the way she explains why she trusts AI-written tests less than AI-written code, why the description field in an agent skill was never meant for humans, and why most teams chasing a software factory are about to drown in garbage. What we cover: – Why agent ground rules have to give the model a mission to disagree with you – The refinement loop that gets to quality when the first attempt never does – Why an agent harness only works if it does one thing at a time – Sketch prototypes: replacing your code with a markdown file and an agent – Why AI-generated tests are more dangerous than AI-generated code – Software factories, and what happens when you try to switch into one overnight *AI DevCon is coming back to New York this November* Get 15% off your ticket with code POD15 https://tessl.io/devcon#tickets Chapters: 00:00:00 - Introduction 00:03:38 - Using AI for everything, not just code 00:06:15 - Ground rules: fixing the defaults agents ship with 00:10:02 - Agent skills and why the description isn't for humans 00:13:09 - Loop engineering: how you actually get to quality 00:16:03 - The biggest misconception about coding agents 00:20:43 - Sketch prototypes and the limits of AI architecture 00:27:48 - Reverse direction: you are the decider 00:31:58 - Why she trusts AI tests less than AI code 00:35:00 - Software factories, or drowning in garbage Build your software factory, one workflow at a time, with Tessl: https://tessl.co/k2t 🔔 Subscribe for weekly episodes on AI-native development Where are you on the loop engineering curve, still hoping for a good first try or already spinning? Tell us in the comments.
- Transcript
- Chapters
S1 · E119
August 18 · 1 hr 4 min
Every Repo Is a Software Factory Now | Don Syme, GitHub
Turning every repo into a software factory sounds like marketing until you see the machinery underneath. Don Syme, Principal Researcher at GitHub, breaks down continuous AI and GitHub Agentic Workflows, now in public preview. The short version: the agents are the easy part, the quality gates and guardrails are the work. Watch Don's AI DevCon Talk here: https://youtu.be/kbvqRWY-bUs What we cover: – What continuous AI is, and why it sits beside CI/CD rather than inside it – Why bounding the context is what stops automated agents going off the rails – Whether the repo is really the right unit for a software factory, and where monorepos break it – One workflow or an agent zoo? Cost control, scheduling and model exams – Quality gates, human review, and equipping the reviewer instead of drowning them Chapters: 00:00:00 - Introduction 00:03:52 - What is continuous AI? 00:07:33 - From single player to multiplayer automation 00:09:42 - Bounding the context so agents don't go off the rails 00:12:57 - Software factories, loops and harnesses 00:18:44 - Inside GitHub Agentic Workflows 00:25:19 - Why the repo became the unit of production 00:37:11 - What belongs in the repo, and what doesn't 00:45:07 - One workflow or an agent zoo? Cost control in the factory 00:52:01 - Quality gates, human review and equipping the reviewer 🌐 Tessl: https://tessl.io 🔔 Subscribe for weekly episodes on AI-native development If you're building a software factory of your own, tell us in the comments where your bottleneck actually sits.
- Transcript
- Chapters
S1 · E118
August 11 · 47 min
The Background Check You Can't Run on an AI Agent
The thing that makes an agent useful is the exact thing that makes it dangerous. Keycard co-founder Ian Livingstone breaks down why non-determinism is both the feature and the bug, and why identity, not model quality, is what really gates how much autonomy you can hand an agent. If you have ever clicked "always allow" without reading it, this one is about you. What we cover: – Why authentication was enough in the cloud era and stops being enough with agents – The background check you can't run on an agent, and what has to replace it – Mission identity: who is acting, on whose behalf, and for what purpose – Cross App Access, Agent Auth and the protocols trying to fix OAuth – Consent fatigue, LLM as a judge, and where hard boundaries still belong – Why MCP ships with an auth story and CLI tools don't Chapters: 00:00:00 - Introduction 00:03:43 - Why every wave of computing rewrites identity 00:04:50 - The feature and the bug are the same thing 00:10:23 - Why shared secrets break for agents 00:13:36 - The background check you can't run on an agent 00:19:42 - Chargebacks, delegation and proving intent 00:22:16 - Mission identity: a new layer 00:28:07 - Cross App Access, Agent Auth and emerging protocols 00:33:02 - MCP vs CLI, and how Keycard works 00:43:22 - Identity three years from now 🌐 Tessl: https://tessl.io 🔔 Subscribe for weekly episodes on AI-native development Where do you draw the hard line for your own agents? Tell us in the comments.
- Transcript
- Chapters
S1 · E117
August 4 · 1 hr 1 min
Datadog Deleted All Its AI Context. It Worked.
Datadog's Language Foundations team deleted an entire folder of AI context files that had been carefully written and maintained for over a year, expecting a performance hit. Instead, their evals got better. Simon Boudrias, who runs Language Foundations at Datadog, walks Guy through what that taught his team about context rot, and the full journey of scaling AI coding agents to 4,000 engineers. What we cover: – How Datadog scaled Cursor and Claude Code to 4,000 engineers in under a year – Why Datadog deleted all of its AI context files, and what happened to eval scores – Building an eval-driven code review system that replays old PRs to catch real incidents – Where open-weight models like GLM 5.2 stand against the frontier – Rethinking hiring and career ladders now that AI can run a real codebase interview Chapters: 00:00:00 - Introduction 00:03:19 - Simon's role and Datadog's 4,000-engineer org 00:04:31 - The Cursor rollout that took off overnight 00:07:53 - How Claude Code entered the picture 00:10:51 - Building dedicated Signals and Flows teams 00:11:58 - Why Datadog bet early on evals 00:33:44 - Deleting all their AI context and getting better evals 00:47:51 - Where open-weight models stand today 00:51:45 - Rethinking hiring and career ladders for AI 00:59:24 - The real prize: better decisions, not just productivity 🌐 Tessl: https://tessl.io 🔔 Subscribe for weekly episodes on AI-native development What's the oldest file in your AGENTS.md or CLAUDE.md that you're afraid to delete? Tell us in the comments.
- Transcript
- Chapters
S1 · E116
July 28 · 58 min
Inside the Dark Factory: AI That Ships Code Solo
At Tessl, 95% of the code shipped by their internal "Dark Factory" has never been looked at by a human, and the team still ships hundreds of pull requests a week, including through entire weekends. Rob Willoughby, who leads AI engineering at Tessl, joins Simon to open up the hood on how it actually works: the orchestrator, the verification layers, and the failures that forced the team to rebuild trust from scratch. What we cover: – How Tessl routes 65-70% of its own pull requests through an autonomous "Dark Factory" – Why context in the repo matters more to output quality than which model you use – How natural language "verifiers" turn code review taste into fast, cheap checks agents can pass or fail – The queue bug that took dozens of pull requests to fix, and the from-scratch Elixir rewrite that stress-tested the whole system – How to start building your own software factory, one verification layer at a time Chapters: 00:00:00 - Introduction 00:01:44 - Rob Willoughby joins: Tessl's PR numbers 00:04:01 - Live demo: kicking off two pull requests 00:14:03 - Building the Dark Factory: orchestrator vs. context 00:19:01 - Code review layers: Code Rabbit, Tessl Change Verify, and verifiers 00:29:58 - Earning trust: accountability in an autonomous system 00:33:20 - What broke: the queue bug and the Elixir rewrite experiment 00:39:56 - Onboarding new engineers into the factory 00:42:58 - Advice for teams starting their own software factory 00:52:03 - Back to the demo, and the road to 100% adoption 🌐 Tessl: https://tessl.io 🔔 Subscribe for weekly episodes on AI-native development What would your own verification layer catch, and where would it break? Let us know in the comments.
- Transcript
- Chapters
July 23 · 32 min
BONUS: Snyk Found Malware Inside AI Agent Skills
One Snyk developer's AI skill quietly handed their coding agent production credentials, and the security team found out the hard way. Krzysztof Huszcza, who leads AI security incubation at Snyk, joins this special Tessl and Snyk live stream to unpack the ToxicSkills research that uncovered 76 malicious agent skills in the wild, and what it actually takes to run coding agents safely at scale. What we cover: – How Snyk's security team found 76 malicious skills hiding inside a popular open agent skill repository – Why skills have become the go-to way developers hand context to their coding agents – The internal incident at Snyk where a developer's skill exposed production credentials to an agent – How the Tessl and Snyk integration scans every skill and MCP server for risk before you install it – What's coming next with Snyk's new Evo product for governing coding agents at scale Chapters: 00:00:00 - Introduction 00:01:33 - Chris's role: AI security incubation at Snyk 00:02:16 - Snyk's roots as a developer-first security company 00:03:58 - New security challenges from AI coding agents 00:06:26 - Skills: the new way to give agents context 00:07:35 - Inside Snyk's ToxicSkills research: malware and prompt injection 00:11:35 - How developers can vet skills before installing them 00:14:38 - A real incident: exposed production credentials at Snyk 00:17:45 - Building a secure-by-default agent stack 00:23:35 - What's next: Snyk's new coding agent security product 🌐 Tessl: https://tessl.io 🔔 Subscribe for weekly episodes on AI-native development What's the riskiest skill you've installed without checking it first? Let us know in the comments.
- Transcript
S1 · E115
July 21 · 1 hr 6 min
From Living Room Hack to 30 AI Agents at Cyera
An engineer builds an AI agent to manage his own life, decides an unrestricted "does everything" agent is too dangerous to trust, and ends up creating the internal agent platform that now runs 30 agents across his entire company. Ori Shoshan, tech lead at Cyera, walks through the guardrails, citation system, and knowledge graph that turned "let the agent do anything" into "let the agent do exactly what it's supposed to, and nothing else." What we cover: – Why one engineer built his own AI agent in his living room, and how it grew into Cyera's internal agent platform – Whitelisting tools instead of blacklisting them, plus the "escape hatch" that keeps agents honest – Backing every claim with a citation and using a second model to catch hallucinations before they reach a human – Trading RAG for a knowledge graph the agent can walk like a wiki – Turning "use this platform" into "build your own agent" to drive adoption across an entire engineering org – Running agents on confidential data that can investigate everything but can only ever say what's been cleared Chapters: 00:00:00 - Introduction 00:02:04 - Meet Ori Shoshan and what Cyera does 00:06:50 - The living-room spark: why Ori built his own agent 00:11:09 - Whitelisting tools instead of blacklisting them 00:12:55 - Why every claim needs a citation 00:15:35 - Reducing hallucinations with clean-context verification 00:21:04 - Taking Borg to Slack: the first agents at work 00:25:33 - Why naming your agent drives adoption 00:39:53 - Knowledge graphs over RAG 00:52:00 - The AI Captains: scaling adoption with carrots, not sticks 🌐 Tessl: https://tessl.io 🔔 Subscribe for weekly episodes on AI-native development Have you built guardrails like this into your own agents? Let us know what's worked (or blown up) for you in the comments.
- Transcript
- Chapters
S1 · E114
July 14 · 47 min
Patrick Debois Maps the Patterns of AI-Native Dev
After DevOps, Patrick Debois has a new map. The godfather of DevOps returns to walk through his AI patterns research: how he tracks where AI-native development is heading by mining social signals instead of surveys, why the stack is settling into patterns worth learning, and why your AI budget problem is really an optimization problem. What we cover: – Inside the AI patterns site at Tessl.io/patterns and how it's auto-generated – The four layers of AI enablement: agent, team, platform, and organization – Solo, shared, and multiplayer modes: the compounding effect of shared context – Managing agent costs: budgets as a forcing function for optimization – Scaling adoption: find the success story, don't fight the skeptics – Hiring system thinkers instead of elegant coders Chapters: 00:00:00 - Introduction 00:02:28 - Why AI grips Patrick Debois 00:04:33 - Agent, team, platform and org enablement 00:06:36 - Is AI-native development maturing? 00:11:19 - Inside the AI patterns site 00:18:14 - Quality, security and the IDE as review interface 00:22:45 - Changing roles and harness engineering 00:26:32 - Hiring in the AI era 00:30:31 - Scaling adoption across the org 00:42:03 - Cost management and ROI 🌐 Tessl: https://tessl.io 🔔 Subscribe for weekly episodes on AI-native development Where is your organization on the maturity curve? Drop your take in the comments.
- Transcript
- Chapters
S1 · E113
July 7 · 57 min
Inside Anthropic: How Claude Tag Is Changing Agentic Work
Six people reacted to Boris's side-project Slack post. A year later, Claude Code is ubiquitous, and the company just launched its next evolution: Claude Tag, an AI teammate that lives in Slack. Lamis Mukta, Member of Technical Staff at Anthropic, joins Simon Maple to unpack how Claude Tag works, why Anthropic built it, and what it took internally to go from a scrappy side project to a company-wide habit. What we cover: – What Claude Tag actually is, and how it differs from Claude Code and Cowork – Why trust in AI agents is really a function of model capability, not just comfort – The internal "dogfooding" culture that shaped Claude Code and Claude Tag – How Anthropic secures multiplayer AI with agent identities and channel-level permissioning – Where Claude and Claude Tag show up outside of engineering at Anthropic – Dreaming: how Anthropic's managed agents continually improve their own memory Watch Lamis' talk from AI Native DevCon London 2026 here: https://youtu.be/tTcxVv8HHNw Chapters: 00:00:00 - Introduction 00:01:46 - Meet Lamis Mukta from Anthropic 00:02:56 - What is Claude Tag? 00:10:07 - From single-player to multiplayer agentic coding 00:15:50 - Trust, capability, and the METR chart 00:21:02 - How the industry is really using Claude Code 00:26:33 - The Claude Code origin story 00:33:47 - Agent identities and permissioning at scale 00:40:23 - Claude beyond engineering at Anthropic 00:48:16 - Dreaming and practical tips for rolling out Claude Tag 🌐 Tessl: https://tessl.io 🔔 Subscribe for weekly episodes on AI-native development What's the one thing your team would delegate to an AI teammate first? Let us know in the comments.
- Transcript
- Chapters
S1 · E112
June 30 · 52 min
The Tessl Agent: Build Your Software Factory on Autopilot
What if the whole point of your AI agent was to eventually make itself redundant? Dru Knox, Head of Product at Tessl, introduces the Tessl agent — a new interface built not just for AI-assisted coding, but for building the software factory that keeps improving without constant human input. This is a conversation about loop engineering: how to set up automated feedback cycles so your agents get smarter, your code review gets tighter, and your team ships more without adding more toil. What we cover: – What the Tessl agent is and how it fits into the broader Tessl platform – Loop engineering: why building automated feedback loops is the right place to start – How the agent sets up and continuously improves agentic code review – Why optimising your AI agent costs is usually the wrong lever to pull – The case for open, modular software factories — and the risk of vendor lock-in – UX expectations in the AI era: why outcome-oriented interfaces are now the baseline 🌐 Tessl: https://tessl.io 🔔 Subscribe for weekly episodes on AI-native development What's your approach to building feedback loops into your agent workflows? Drop a comment — we'd love to hear how teams are thinking about this.
- Transcript
- Chapters
S1 · E111
June 25 · 1 hr
Why Agents Are Forcing Enterprises to Finally Fix Their Dev Process
Enterprises are finally being forced to care about their software development lifecycle — not because anyone suddenly got disciplined, but because agents cost money and the waste is now visible. When it was humans, it was "Timmy's just lazy." Now it's a line item. Simon Maple sat down with Patrick Debois (the godfather of DevOps, now DevRel at Tessl), Tammuz Dubnov (co-founder and CEO of Autonomy AI), and Daniel Jones (Head of Product at re:cinq) at AI Native DevCon London for a wide-ranging panel on AI enablement — who owns it, what's breaking, and what the organisations getting it right are actually doing differently. What we cover: – Who should own agentic coding adoption inside an enterprise, and why platform teams are already filling the vacuum – The "Timmy's lazy" problem: why agent cost visibility is forcing process discipline that humans never got – Why PR-based workflows are an anti-pattern inside enterprises once you're moving at agent speed – The PUMP framework (Plan, merge, polish): how one team is shipping features with developers, PMs, and designers all opening PRs – Rethinking what a "test" is in an agentic world — and why feedback loops matter more than first-pass correctness – The biggest mistake enterprises are making right now: piecemeal adoption with no mandate and no shared tooling 🌐 Tessl: https://tessl.io 🔔 Subscribe for weekly episodes on AI-native development What's your team's approach to AI enablement — central mandate or letting individuals find their own way? Drop it in the comments.
- Transcript
June 23 · 23 min
BONUS: DevCon London: Real Talk on AI ROI, Harnesses & Evals
From the expo floor of AI Native DevCon London, Simon Maple went straight to the developers — speakers, attendees, and sponsors — to ask what's actually working with AI in 2026. The verdict? Outcomes beat outputs every time, 4,000-hour workloads are collapsing to 20 minutes, and the real bottleneck isn't code. This is a conference floor walkthrough: honest, unscripted takes on harness engineering, evals, AI adoption mindsets, and the change management challenge that nobody talks about enough. What we cover: – Why measuring token usage, code commits, and outputs will lead your team astray – How NearForm cut a 4,000-hour AML backlog to 20 minutes using agents – Harness engineering and evals as the developer skills that matter most in 2026 – Why change management — not tooling — is the missing ingredient for real AI ROI – How AutonomyAI is letting PMs and designers ship directly to production Chapters: 00:00:00 - Welcome to AI Native DevCon London 00:01:03 - Chris Baty: Outcomes Over Outputs 00:05:15 - Martin: How Tooling Changed Everything 00:07:21 - Ryan: Harnesses, Evals and Skills 00:08:50 - Manny Saka: Plan Before You Prompt 00:11:58 - Cian O Maidin, NearForm: Real AI ROI 00:15:21 - Snyk: Building Trust at Scale 00:17:01 - AutonomyAI: Shipping Without Engineering 00:21:35 - Tessl Agent: Harness Engineering 00:22:41 - Closing Thoughts 🌐 Tessl: https://tessl.io 🔔 Subscribe for weekly episodes on AI-native development Whether you're cautious or YOLOing it with AI — drop where you land in the comments.
- Transcript
- Chapters
S1 · E110
June 16 · 1 hr 2 min
AI Security & the Agent-Ready Web: Experts Weigh In
What does it mean to build securely when agents can negotiate their own guardrails? And what happens to the web — CLIs, frameworks, even the browser itself — when the primary user is no longer human? At AI Native DevCon London, Simon Maple sat down with two panels of experts to find out. First: a security roundtable with Joseph Katsioloudes from GitHub, Liran Tal from Snyk, and John Groetzinger from Cisco. Then: a web AI conversation with Dana Lawson from Netlify, Maximiliano Firtman from codemia, and James Moss from Tessl. What we cover: – Why 83% of enterprises plan to deploy AI but only 29% feel ready to do so securely – Prompt injection as a risk you have to accept — and how least privilege and sandboxing are your real defences – The "agent experience" concept: why systems built for human eyes fail at machine scale – Whether fundamentals like HTTP, semantic HTML, and accessibility still matter when agents do the heavy lifting – How WebMCP lets websites expose tools directly to agents — and why blocking them is like trying to turn off the sun
- Transcript
- Chapters
S1 · E109
June 9 · 55 min
Ryan Lopopolo: OpenAI's Framework for Shipping Code at 70 PRs/Week
Most engineering teams are still arguing about whether to use AI coding agents. Ryan Lopopolo's team at OpenAI shipped an entire product with no human-written code — and onboarding a new engineer made the team faster within two weeks. That outcome didn't come from better prompts. It came from what Ryan calls Harness Engineering: the systems, constraints, and feedback loops that sit around the agent — the context it sees, the tools it can call, the tests and linters that close the loop, and the asynchronous CI jobs that catch slop before it compounds. We sat down with Ryan at AI Native DevCon London 2026, and he got into the specifics: how his team went from 3.5 PRs per engineer per week to 70, why he inverts spec-driven development (build the code first, distill the spec second), and what he means when he says it's "borderline negligent" not to use a billion tokens a day. It's one of the most grounded, production-focused conversations we've had on The AI Native Dev. The trailer is live now — and the full episode drops this week. #HarnessEngineering #AINativeDev #SoftwareEngineering
- Transcript
- Chapters
S1 · E108
June 2 · 47 min
Why Developers Hit a Wall at 4 AI Agents
Engineering teams are shipping twice as many pull requests with AI — but merge rates on AI-generated PRs have dropped from 80% to 60%. Nick Arcolano, Head of AI & Research at Jellyfish, sits on one of the most comprehensive datasets in the industry: 250,000 developers, 40 million data points, monthly benchmarks on real agentic coding adoption across enterprise companies. What he's seeing in that data is both more promising and more complicated than the headlines suggest. What we cover: Why experienced engineers hit a hard ceiling at 4 concurrent agents, and what it would take to break through it The 80/20 vs 60/40 merge rate gap between human and AI-generated pull requests — and what's actually causing it How AI adoption reached 71% weekly active usage across 250K developers, and what "depth of use" really means Why 2026 is the year the CFO gets involved — and how engineering leaders should prepare to show their receipts The biggest misconception engineering leads have about what it takes to get to true AI-native development Why companies have jet engines but are still building cars, and what the real architectural changes look like Links: 🌐 Tessl: https://tessl.io 🔔 Subscribe for weekly episodes on AI-native development If you're an engineering leader trying to make sense of the gap between the AI hype and what's actually showing up in production, drop your take in the comments.
- Transcript
- Chapters
S1 · E107
May 26 · 40 min
Don't Secure the Code. Secure the Coder.
AI agents don't just write insecure code — they can escape their sandboxes, delete files, and do whatever it takes to complete a task. The security mental model that served us through the cloud era isn't enough anymore. Guy Podjarny, founder of Snyk and CEO of Tessl, made the case at London's AI Security Summit: it's time to stop securing the code and start securing the coder. Recorded live at the AI Security Summit in London, this episode features conversations with Brian Vermeer (Snyk), Sam Stepanyan (OWASP London), and a full recording of Guy's keynote on why agentic development demands a fundamentally different approach to security. What we cover: Why shadow AI is the new shadow IT — and why CISOs can't secure what they can't see Skills as a new supply chain attack surface (malicious, vulnerable, and negligent skills) Why more context is not always better — and what the data says about focused skill design The OWASP Top Ten for Agentic AI and what it means for teams building today Why security must become agentic to keep up with the attackers who already are The Context Development Lifecycle (CDLC) and how leading orgs are using it Links: 🌐 Tessl: https://tessl.io Subscribe for weekly episodes on AI-native development What's the biggest security risk your team isn't talking about when it comes to agentic development? Drop it in the comments.
- Transcript
- Chapters
S1 · E106
May 19 · 41 min
The Hidden Security Risks of AI Coding Agents
Your AI coding agent has access to your secrets, pulls in content from the outside world, and can run shell commands. According to Joe Holdcroft, that combination makes you one prompt injection away from a very bad time. The tools haven't changed the fundamentals of security — they've just made every existing risk move faster, and introduced a few genuinely new ones. What we cover: Why the "lethal trifecta" of agent capabilities creates a novel threat surface How text and markdown files have become a new class of vulnerability Slop squatting: the attack vector created by agents hallucinating package names The context supply chain — and why it mirrors the early days of npm security What a "CBOM" (context bill of materials) might look like and why we may need one How to think about agent trust using the contractor mental model Chapters: 00:00 Introduction 01:40 The Lethal Trifecta: why agents are inherently risky 03:23 Same hygiene, higher stakes 04:08 Text as a vulnerability: markdown as a security risk 06:08 Do AI tools make you more or less secure? 08:09 Snyk + Tessl: scanning skills in the registry 10:10 The context supply chain problem 14:28 The CBOM: do we need a context bill of materials? 17:35 Secrets, credentials, and principle of least privilege 22:25 Balancing security with developer velocity 36:54 One piece of advice for CTOs going all-in on AI Links: 🌐 Tessl: https://tessl.io Subscribe for weekly episodes on AI-native development If you're thinking about AI governance in your team, drop a comment — how are you handling context supply chain today?
- Transcript
- Chapters

Showing 1–20 of 26 episodes