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

Your coding agent should never hold a credential, and in a software factory that rule is only the start. Recorded live at the AI Security Summit in San Francisco, Simon Maple sits down with Eli Aleyner (Docker), Marcelo Sousa (Snyk) and Ian Livingstone (Keycard), co-authors of Agent Baseline, a security reference architecture for the AI software factory.

The panel unpacks why agents have to be treated as fundamentally unpredictable actors, why sandboxing alone is not enough when skills and MCP servers make the supply chain dynamic, and why approval prompts collapse into fatigue. Marcelo's verdict: sometimes these are kids with chainsaws.

What we cover:
– The three levels of autonomy, from coding agents to fully agent-directed workflows
– Sandboxing coding agents and injecting secrets at the egress point
– Why the agent supply chain is dynamic: skills, MCP servers and cloned repos
– Prompt injection, least privilege and agents monitoring other agents in the harness
– Approval fatigue: YOLO mode vs CYA mode
– Where to start securing your software factory on Monday morning

Chapters:
00:00:00 - Introduction
00:03:14 - What Agent Baseline is and who it's for
00:04:17 - The three levels of software factory autonomy
00:06:53 - Sandbox boundaries and manufacturing trust in agents
00:09:22 - Why coding agents should never hold credentials
00:11:44 - The dynamic agent supply chain: skills and MCP servers
00:14:57 - Untrusted input, least privilege and agents watching agents
00:18:02 - Approval fatigue: YOLO mode vs CYA mode
00:20:22 - Are poisoned agent skills a supply chain problem?
00:22:45 - Where the panel disagreed, and where to start Monday

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

🔔 Subscribe for weekly episodes on AI-native development

Which level of the software factory are you at today, and what are you locking down first? Tell us in the comments.

Skills and MCP servers are the new npm, and AI coding agents are pulling them into enterprise codebases faster than security can keep up. Manoj Nair, Chief Innovation Officer at Snyk, joins Guy Podjarny at the Snyk AI Security Summit to map where enterprise agentic coding really stands.

They get into why a 50,000-agent Claude Code rollout was pulled forward by weeks, why the autonomous attacker has some CISOs ready to accept an outage to patch faster, and how security is moving into the agent loop of the software factory.

What we cover:
– Why leadership and culture, not tooling, decide how fast enterprises adopt AI coding agents
– The three risks of agentic coding: insecure output, the skills and MCP server supply chain, and agent behavior
– Running coding agents locked down: sandboxes, agent identities and no open internet
– Who owns the code an agent writes, and why AI-native organizations treat it as shared risk
– Securing the software factory: security context in the agent loop and agentic remediation of the backlog
– What still has to be solved before enterprises trust agents: identity, intent and behavior

Chapters:
00:00:00 - Introduction
00:01:50 - The state of enterprise AI and agent adoption
00:09:45 - Leadership, culture and a 50,000-agent rollout
00:11:18 - Agentic coding risks: output, supply chain, behavior
00:14:29 - Locked-down coding agents and the security trade-off
00:18:01 - Who owns agent output? Compliance and accountability
00:22:54 - The autonomous attacker and security technical debt
00:27:56 - Securing the product vs securing the software factory
00:33:00 - Agentic remediation and the security backlog
00:40:18 - What enterprises need to trust AI coding agents

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

🔔 Subscribe for weekly episodes on AI-native development

Where is your organization on the path from copilot to AI coding agents? Tell us in the comments.

Agent feedback loops are how a software factory maintains itself: agents mining their own session logs, PR comments and production signals, then fixing what they find. Maria Gorinova, member of technical staff at Tessl, explains how to build them, and why vague intent turns a loop into a mess.

What we cover:
– What a software factory is: repeatable workflows, a shared execution environment and agent feedback loops
– Why agent context alone isn't enough, and where harness engineering comes in
– The three stages of a feedback loop: analyze a data stream, find the problem, request the fix
– Inner, middle and outer loops, from verifiers on every PR to self-healing in production
– How Tessl's "comment diet" loop catches drift that no single PR causes
– Operators and stewards: the human roles in a software factory

Chapters:
00:00:00 - Introduction
00:02:36 - What is a software factory?
00:05:38 - From agents to context to harness engineering
00:09:15 - The three stages of an agent feedback loop
00:13:16 - Inner, middle and outer feedback loops
00:18:35 - Why vague intent breaks agent feedback loops
00:21:50 - Comment bloat, drift and the rule of three
00:25:48 - The software factory mindset
00:27:45 - Loops, feedback loops and meta feedback loops
00:32:45 - Operators, stewards and building your first loop

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

🔔 Subscribe for weekly episodes on AI-native development

Which agent feedback loop would you build first in your own software factory? Tell us in the comments.

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.