Transcript — Built for Humans. Now Agents Are Here.

Speaker: Dana Lawson, CTO of Netlify Date: 2026-06-01

⚠️ No per-speaker labels in source. This is a single continuous block from a verbatim transcription. The speakers present are:

• MC (unnamed) — intro and Q&A handling
• Dana Lawson — the main speaker
• Audience member #1 — Q&A about 500M apps / environmental impact
• Audience member #2 — Q&A about accountability under abstractions

Speech-to-text artifacts have been preserved verbatim (e.g. "Dan Austin" ≈ "Dana", "Jeremiah leafed Spotify" — likely a garbled name, "mid structure" ≈ "machine-structured", "AI navy" ≈ "AI native", "past fall" ≈ "pass/fail"). Do not silently correct these in quotes — preserve the source. When in doubt about attribution, prefer "Lawson" for body content and "an audience member" for Q&A questions.

---

§1 — MC intro

Okay, we're gonna get started just a minute. One thing I wanted just to let you know on the app we have the schedule and for sessions that have already been and already happened there is that you can click on those sessions under a rate this session now button so feel free to go there you can break guys very average presentation and you can say how great my intro was so feel free just to add in I think it's like out of five stars and there's a little bit of notes there as well so feel free to do that. Okay kicking off our talks we have the wonderful Dana Lawson who is the CTO of Netlify of course Netlify for many many years have been building wonderful software for a world that is ageless and now we have agents so Dana is going to talk tell us how we adapt for that so please welcome on stage our. Selves.

§2 — Opening + premise: builder persona has expanded

Jet lagged a little caffeinated so hopefully I don't talk too darn fast but I'll tell you what coming into the city yesterday I was I became an arsenal fan y'all crazy I was like what the hell is going on here somebody should have warned me but y'all sure do I want to party so I was down but I didn't clown last night I had to be serious with it so as you heard on Dan Austin CTO of Netlify Netlify is as we all are agentic web application platform we help anybody build deploy and create experiences and now in an agentic world guess what anybody can do it and so our world is changing so rapidly that this talk might be incidents out of date but maybe not depends on how far you are in your journey so let's get going. So. Before we get into the architecture I need to say something that might feel uncomfortable how many of you here identify as a developer.

Oh man we ain't precious no more y'all the builder persona has changed the person our platforms were built for are no longer just developers we're still builders don't get me wrong but we're not the only ones now with agents anybody can participate in fact the IDC predicts that more than 500 million your applications will be built by 2028 in fact I create one a day so I'm a I'm a part of that damn problem more than the previous 40 years combined think about it for a minute now 40 years have been compressed into three just like this right now that's not because the number of engineers is expanding it's because agents have turned intent into a programming language in fact the strongest programming language that will happen now and into the futures guess what? English so I hope you go and study that school kids if you're watching you better you better learn how to talk to somebody. Cursor Codeium level Netlify these tools let anyone with an idea create working software through conversations no longer is it just developers it's therapists teachers small business owners students people in line at the store building experiences on their phone thank you Lovable and becoming software creators and Netlify we build for all of these builders and here's the thing when we designed our platform to work better for agents serving these new builders it got better for developers too. And that's the 8x paradox.

§3 — The Toria story (part 1)

So let me tell you a little story let me introduce you to my best friend my homegirl Toria this is her she is a licensed massage therapist she's a vibrant drummer a delightful aesthetic woo woo birding man hippie so I can't even believe she hangs out with an AI overlord but she does and she just radiates incredible energy she has a dream she came to me and she said girl I want to build an all-inclusive experience not just a website and even going on a Wix I want to build an app for my Barbados massage routine where I can build community and I can take payments and I can can deliver content these aren't just static website dreams these are full blown application dreams.

She doesn't write the code she really just writes intentions and she decided she won't build this website so she went on to her favorite chat application ChatGPT and described her vision and she started building. She prompted an agent to build a website but every assumption we have baked in to link turned out to be a human assumption as we originally had built Netlify it was for front end developers and now we realize with agents we're lowering that gatekeeping and that barrier.

First it was about it she had no idea what git was I worked at GitHub some other get help people are here I was like man you don't need to know what git is trust me on this but she was stuck this is the reality for millions of new builders right now.

Agents still speak fluent developer but the humans they're serving don't they don't know get they don't outpost they don't know anything first this was she had no idea what she was doing. The tools assumed a level of technical literacy that most of the world just does not have.

§4 — The AX paradox introduced

And this is the thing that really surprises is Netlify as we were redesigning for agents fixing this Toria also fixed it for our experienced developers that have to write respect intent context all the things that guy said with the new software delivery life cycle. Those are the things that we have to just make work out of the box because the new builder has no idea.

When we made the agents error message clearers structured to build output for machining and remove unnecessary friction our developers also benefited from this. Every human assumption we remove made the platform better for everyone this is the gap of what we call agent experience.

So as I said she called me I was like earl you don't even worry about giddy you don't got to worry about deploy you just go you just need to go prompt your vision into the world and I got you. But this got me thinking about what this means after years I've been a software developer builder QA I've done it all man I've been doing this since the 90s maybe decades of building guardrails to prevent humans from breaking production we're now removing those guardrails and saying hey come play with us come come create go build the next experiences for the world why. Because the interfaces have change the agent now handles get it handles deployment it handles PNS the builder focuses on the vision and at number five this is really what agent experience in practice looks like agents have full access to our platform primitives they deploy configure iterate so the human never touches anything it's pretty scary right so under the hood you're going to have all the things that you need to make it frictionless so that builders and this new breed of developers can get those ideas out.

Ax captures the humanity in the story it removes that technical friction. So again people like Toria or anybody else with a good idea that wants to change humanity for the better they can outdo it.

But here's the key insight again we didn't just make this as a separate thumb down platform if you go into Netlify it is still as powerful as it was 10 years ago as it is today but we had to think about how that intersection of developers and builders are coming together. So what do we do we just built a better platform for everyone the same structure signals that help that agent to exploratory site also helped our engineers debug and build faster build systems understand where we have errors under the hood really help us create that magical experience and so what we learned was design for agents. Actually was designing for humans all along.

§5 — Coining AX (UX → DX → AX)

And so this again brings me to my core thesis you've all heard user experience we heard in 2012 Jeremiah leafed Spotify coin developer experience and my boss Matt Biemann last year said you know what the new paradigm is agent experience. UX and the experts are flapping into a single discipline and here's why again that builder persona is no longer you the agents are doing the heavy lifting so when you're thinking about how that end user interacts it's also an agent when you're thinking about how that developer goes and programs on your platform and sign developers and agent but on the other end is a human that just speaks plain English and expects it to just work.

And again agent experience isn't about making machines happy it's about removing that friction every step of the way so that you can get from I give into reality in a few simple terms. Now I know that's again scary for all of us as software developers but how do we always just built so that we can explore, collaborate and share our ideas and some of us actually change humanity. I hope for the better.

Deploy so structured errors in agents can parse engineers can scan them faster too and then deploy previews that give agents clear past fall signals. These all give us human clarity and a lot of this stuff is obfuscated we don't need the end user to think about it anymore and now the end user is anybody because we are building a development platform we have to just make it work.

So as you heard in guys talk really aging experience is thinking about all that new system content and intent in the SDLC. It is the practice of designing where humans and agents collaborate seamlessly. And it isn't just about making API API calls agent friendly. You really do have to rethink the entire stack along the way from how we express the intent to how systems communicate and so that we can trust.

§6 — The current AI-coding landscape

So let's look at the landscape. You already heard a little bit from guy of what changing and like I said some of this is probably out of the data. In just two years that's right and only two years we've seen an explosion of these AI powered development tools or harnesses. I mean call them what you will. I'm sure the name is going to change many many times. I was sitting here thinking man Nelly is a harness on a harness on harness. That's so good. I'm meta. How many harnesses do you need? So I hope somebody comes out with the second hard human problem which is name and shit.

Code from Anthropic is an agent at CLI that writes test commits code Cursor wins serve for an AI and IDE Setprint program with you v0 Netlify Bolt from Sack Glyphs Lovable all turn natural language into applications. GitHub Copilot now has agent roles that anonymously works on issues and submits PRs. The idea of a software factory it's been instilled for years. This is not a new concept that we're determining here. But now with agents we can actually go and implement those software factories to go and just run.

All of these again share common pattern intent as input. Working software is output but there's the thing. They all need infrastructure that understands the patterns. The deployment targets the CI pipelines the edge networks. They all have to be designed for agents. And that's what we've been building at the. Five.

§7 — Shift 1: specs to intent

So what actually is changing again you've heard it it's gone from they still see the big shift as we're moving from specs to intent. Specs still matter and you have large scale technical platforms like myself believe me you're still using specs but for your average user because I hate to break it to you the internet is just a bunch of apps and websites. It's not that hard. If you're the tech company is hard. If you're an end user that's building an experience not that hard anymore traditional development workflows typically would begin with a PRD that passes to a Jira ticket or a Linear ticket. Spec docs written for humans. AI native workflows begin with prompts. Problem descriptions sketches and references. The input is the intent. I want a wellness retreat with booking not a 50 page requirement doc. This is where we have to think about how can we take that intent and those ideas and turn them into realities. By creating the software factories beneath them.

And at Netlify we've been dog feeding this. We have a tool called age of runners. An agent now or a harness takes the intent generates the code that output moves immediately into real engineering workflows. Preview deploys automated test production pipelines what used to take millions of minutes now takes seconds which is pretty darn incredible.

§8 — Shift 2: sequential handoffs to shared creation

And so the second shift that we're seeing in software development life cycle with the rise of agent decoding and the built a persona becoming the every person is we're moving from those sequential handoffs to share creation pipelines. Now for Netlify yes we have sophisticated software development team and all people do participate. And historically it was that relay race that we all knew PMs right the specs. Hands resigned design creates the mock-ups hands the engineering engineering builds it if you have keyway probably not it's just a buy it validates it and hands it to the dev ops for deployment because nobody trusts anybody to go and hit that button. But let me tell you that takes weeks and some crazy billionaire ball tech overlord said there ain't no doors you can't walk through you can't walk the other way back through. So having that mindset of shipping rapidly is now more so reality than ever before.

So now instead of having these handoffs as collaborative product teams are generating working prototypes with agents designers are redefining the experience directly in code. They're not participating outside the life cycle. Engineers are now spending their time validating the architecture and again spending time writing those precious fire wells that didn't exist the way they need to exist now whether it's contact specs recipes etc we'll call it skills for ease of use as well agents handled the testing and appointment and now everybody participates. The cycle time compresses again from weeks to hours.

§9 — Shift 3: passive CI to autonomous development loops

Third what was the other change that we this is the software factory layer that you heard in the previous talk. We moved from passive CI pipelines autonomous development loops. That is what I always brought to developers was like hey you don't have to go and create your own CICD. You can come to Netlify. We'll set it up and we'll get it configured for you. But that has gone even crazier now with autonomous development loops. Atheists [Agents] don't just write the code they're participating in the entire infrastructure life cycle. They're generating the test detecting fall failing previews analyzing build blocks proposing fixes open PRs CICD just becomes a continuous feedback loop and some of you may not be at that level of sophistication but this is where you need to start thinking about how you're reinventing those needs.

And then fire deploy preview and build infrastructure again like I said already provides the observability signals agent needs. When a bill fell is an agent can read the logs because we went and update them, diagnose the root cause and submit a fix all without a human in the loop. And this isn't some future this is happening every day. And this will happen in your workforces as well. There will be a demand that comes in and says there's your common paths turn into a software factory make it go.

Our agent runners are protected. We give agents sandbox environments with full platform access. They deploy configure iterate without humans. Deploy rewards from agents mean every change gets a unique URL preview URL. This is where we bring the human back into it. The human gets to visually look at the output and continue to iterate because when you're flowing and vibing if you vibe code you know all it is is about that preview preview preview.

§10 — Worked example: redesigned build logs

And here's a specific example of a redesigned surface. As I mentioned our build logs used to be human readable narratives great for scanning, great for dev ops, great for me in a buggy terrible terrible for agents. It had no idea what we're talking about. It wasn't late speed, it was lock speed which is even worse. We restructured them into mid structure machine readable error codes alongside that human text. And agent can now parse a build failure identify a misunderstanding fix it automatically.

But again here's the thing. That same structured output made our dashboard clearer for human engineers too. Because we took it and really put emphasis on how an agent would utilize our logs to make decisions that also meant that our developers could debug quicker for agent didn't know what was going on. Because I don't know about y'all. That's a little trust agent 100% Especially not in my club lot. It kind of hates me. Eric categorization at a glance failure reasons and what we learned again was this part of the agent experience really did improve the human experience. It made us quicker to debug any of those problems because we were thinking about how an agent would read it too.

§11 — Legacy systems & three architectural shifts

But I'm sure most of you all live in the world that I live in if only we had greenfield technology and architecture that was simple this would not be a problem at all. In fact you would probably be building the next 500,000 tech startups because you can do that. But the problem that most of us face is we're introducing agents into fragmented systems that have been existing. Even if you're building net new I implore you to think about your agent experience before you start hands on keyboard. A lot of these systems are collections of apis microservices, CI pipelines that again were designed for human operators. There was an intent that a human would be a part of that group even if stuff was sent to work continuously. Agents struggled with this. They can't see across service boundaries. Every API speaks a different dialect. Critical workflows live and tribal knowledge and in someone's head in a slack thread from 2022 in an undocumented terraform module when agents can observe the system they can't act intelligently. No longer can you rely on tribal knowledge or the person that's down the hall and slack to be like yo what did this do? I have no idea you're expected to make it work for your agents because your agent should just work. This is the fundamental change. We just can't both agents into existing legacy architectures. The architecture itself must evolve.

The first architectural shift is from APIs to capabilities. Transistual systems expose rest in points posted this URL put to that would get this resource. An agent looking at a 200 endpoint API surface has to figure out the right context, the right sequence, the right parameters in the right order. And I know we're making jokes about context windows. Believe me, you will run out of time if you don't specify what agents are supposed to do in your systems. Agent native systems expose these intent level operations. Create a site. Look again plain English deploy repository. Provision edge compute. These are capability agents can reason about. They express what you want to accomplish not the mechanical steps to get there. And at Netlify again we've evolved our API service to support both modes traditional rest for existing integrations and capability based interfaces for agent interactions. This also extended to our CLI. When you use CLI commonly you have a developer that has to get yes, no next parameter. That does not work when you have an agent. We had to go rethink about how our CLI will be utilized.

The second shift is from request response. Oh man, I don't know faster. To venture an architecture. Traditional APIs are full based. You send a request, get a response. Agents have to pull guest retry. AI navy systems expose events. Again deploy started. PR created agents subscribe to these events and act autonomously. So if you're still doing stuff asynchronously you need to think about updating your systems to event base. I know we all love Kafka and so you can use any kind of stringing that you love but that's just one way to get there. This was already how we built the Netlify build system. Every deploy emits and so now the structure logs and infrastructure was designed for observability agents are the ones observing versus the humans.

The third shift probably the most important is making architecture legible to agents. Again a lot of these distributed systems right on tribal knowledge. Somebody that knows this service may not know service fee. Agents don't have that knowledge. This is why we created our system of record called blueprints. Yes this is skills, context and recipes. Think of it as the plaud mark number five agents indeed. The architecture decision records all design so coding agents understand the system for they make the changes. The goal isn't better documentation. It's ensuring agents can operate safely and complex systems.

Putting it all together we have moved from static tool change to agent orchestrated system to develop its cycle becomes a continuous human agent loop. So no longer is it a handoff. It is everybody participating at the same time. And the human stays in the loop by providing judgment taste direction. But the blue moves at machine speed. This isn't replacing engineers. It's amplifying everybody's ability to be a builder.

§12 — Trust primitives

Now with all this power you heard it earlier comes with serious responsibility where agents can deploy code provision infrastructure and modify production systems. Trust has to be default and is not optional. We have three principles we follow now five first sandbox execution. They campus agents can't escape their sandbox and access resources they're not granted. Second human in the loop by default. I know you say like you heard me say software factory. You don't need one. But guess what? I still don't trust stuff 100% but we want to make the human in the loop the meaningful part of the job the agent builds the human approves and third audit rollback every agent is every agent action is logged. This is where events become so incredibly important knowing the changes in the system because they a lot of code is not being stored in git which is absolutely bonkers. We still have to have a system of records roll back. TRUS is built on this transparency. If you can't explain what the agent did why would you trust your production?

§13 — Organizational impact

The organizational impact is profound. When agents lower the barrier to building now the entire company participates. Everybody's making prototypes. We're testing hypotheses coming up with ideas supports creating internal tools custom solutions for customers. No longer are you bound by the engineering software development life cycle. You now have the ability to go let everybody get out of your hair and just go right and build their own code. As DevOps professional this has been my dream for over 20 years is build it yourself. Let me work on the hard problems. And now that's what we're going to do engineering evolves into implementing from implementing every feature to really ensuring that the systems of the guardrails, the architecture is tight and solid. The skills recipe and context just whack work. This is where AX is critical. It's a discipline that ensures that democratization happens safely because I don't know about you I still believe in an open web.

§14 — Takeaways

So let me summarize the takeaways. And I want you to take this home first. I hate to break it to you. We ain't precious no more. The builder persona has expanded your platforms don't just serve professional developers anymore agents are enabling therapist teachers students and anybody that has a dream to build and design for them. Second legacy systems must evolve. APIs need to become capabilities that agents can reason about. Again intent level operations. Third safety and trust are foundational sandboxing human and linked reviews full audit trails. These aren't nice to haves. When agents can deploy productions they have to haves. And fourth, this is what you can start shipping well tomorrow. Go fix your structured errors. Go create event driven signals and logical architecture. There's an expert spar. I heard go sign up now if you haven't done it before go learn how to write your damn skills because your job depends on it. We shouldn't have to say that but I do.

So our biggest takeaway here is design for agents didn't just make our systems better. It made it better for humans. And that was really the surprising at all. This wasn't a trade off for a developer experience or the user experience. It was a multiplier.

§15 — Closing: why it matters

And so why does all this matter? Because as Matt Biemann says when anybody can generate software code is no longer the scarce resource. For decades the bottleneck has been writing code finding engineers shipping features. The bottleneck is dissolving. Now the scarce source becomes taste. Know what's worth building judgment. Knowing when to shift. In architecture, designing systems at scale. And this is where we come full circus full circle. A accident just to help agents work with our platform. It forced us to clarify our architecture, our structure and our signals. It in fact made us all better developers. So the judgment to build systems agents can work with that is the engineering skill of the future. An agent experience ensures agents amplify human creativity rather than replacing it.

And so this brings us back to Toria. After hitting the wall of git in a million problems she didn't give up. With an ecosystem designed for agents designed for her she bypassed all of those roadblocks. She was able to drag and drop her intentions into Netlify and it just worked. No get, no CLI, no deployment configurations, no worries trust by default agent handled all of it. She called me that day and I remember it and I'll censor it since it's a stream. She called me and she said girl and I was like oh man. But she's right. That's the most incredible part. I didn't build this site she did. Here's her vision. I hope you all go to the Barbados with us. Here's her vision wide for the world to see. This is ax in action. We design for agents in doing so we may build a possible further massage therapists. In Barbados who writes intentions and not code. That's not just agent experience. That's actually human experience and that's what agent experience is for. Thank you for your time and if you want to participate we have some resources available. Turns out redesign for everyone. Is the agent experience not designing for agents. So don't get stuck in the trap. Remember who you serve. And if you want to learn more you can visit netlify.com/ax. Thanks. For. Questions.

§16 — Q&A 1: 500M apps / environmental impact

MC: So if you have questions please do raise your hand and someone will run at you with a mic. Any questions for Dana. They're blown away. It's all over. One question.

Audience member #1: You said 500,000 apps. You built. We're going to build so much ever. When do we're learning these contexts now what do we talk about what not to build. And how do you stop like the environmental impacts, the impact of complexity of code? Etc.

Lawson: I think that's the challenge that we have right now is the bitter truth is you're going to be stuck building a whole bunch of stuff that's going to be obsolete probably and when it's not years. And so finding the right paths and putting intent to the right areas is what's going to be the keeper. I mean hopefully you know we all continue to think environmentally and conscious about the world because building AI for. Not anybody around the planet what's the point. But there is a bunch of slack right now and a bunch of these applications are going to be a drain in our resources. But this is where development and engineering practices are core to this. Because now anybody in the world can build and literally anybody can. We have to burden that responsibility on our shoulders to make sure that we are implementing compaction, that we are thinking about compression that we are building the right resources to make the internet continue to be open and democratized for everybody. But also the environmentally friendly. And those are the things that these builders won't understand. So when I talk to people say oh you know you're getting development. How do we like well I don't know if I'd be like a builder. I would probably focus on the internals and take that background into computer science and really apply that because there's still a lot that we can do as developers. But that shift is changing. For some of these you know experiences that we all have anybody can do from now. And so not getting stuck in that trap is incredibly important.

§17 — Q&A 2: accountability under abstractions

MC: We've won just to the right question over here.

Audience member #2: It was a really insightful talk. Thank you for that. I wanted to ask about accountability. So how is your company approaching accountability where if you're creating useful abstractions and people building it don't understand what's below the abstraction. Where disappointability set in that. Are you planning to like flip. The accountability and say we will give you exposure to what's underneath if you need if you have an IT team if not we will take accountability. How are you thinking about. That?

Lawson: I mean you know it's it's a it's a push and pull. I mean again it's like what do I want to build right now that's going to be commoditized? You know there used to be a lot of systems that were super simple and were super complex to use that now you just plug and play. And I think we're in a world where nothing is really set on what will we develop next. And so again it's finding the right balance in two parts. A lot of our users at Netlify come in and want to build websites and applications. So we are going to put all the accountability and context and the trust in the system. So under the hood where you saw when guys talk that's on the Netlify. We do every bit of that. Build deploy QA. But in large scale organizations because Netlify is still built for developers we still have this context of a control plane. We're working on things like policy engines, control panels really for you know whether that's a CISO or production R&D whoever's doing the guardrails be able to have that control panel. But a lot of it what we're building is obfuscated because what we found is again the internet is just a collection of apps and websites. They're not that complex. I hate to bring it to you. It's usually some JavaScript and maybe a database. Not a lot of serverless functions in between. People don't describe building like that anymore. They say build me a website that can be shown in portugal. That's a serverless function that's doing locality. They're not going to go in there and write that function. I'm going to do that for them. They're just going to come and tell me all about this in portugal. And so we are trying to balance where a developer needs to put their attention where they don't. And so really utilizing what's important to that system and more of it is governance policy and identity. That's what a lot of large scale enterprises and professional systems care about as far as accountability. And more of the hobbyists. Or solopreneurs they just want it to work.

MC: Listen. We actually don't have any more time for extra questions but please do grab Dana in the hallway chat. Once again, thanks very much Dana.