AI agents have officially arrived on an internet that simply wasn't built for them. So how do we build the infrastructure to keep them safe, productive, and contained? This week, Andrew sits down with Matt Boyle, Head of Product, Design and Engineering at Ona (formerly Gitpod), to discuss evolving cloud development environments into secure, enterprise-grade "agent jails." They explore the mechanics of Project Veto’s kernel-level security, the slow death of the traditional IDE, and how the rise of AI is transforming developers into full-stack, T-shaped product owners. Finally, Matt shares his vision for the future of the SDLC, detailing how organizations can safely balance strict compliance with the bleeding edge of autonomous software factories.
Show Notes
- Learn more about Ona (formerly Gitpod) and read their latest blog announcements, including Veto.
- Connect with Matt on LinkedIn|X (Twitter)
Transcript
(Disclaimer: may contain unintentionally confusing, inaccurate and/or amusing transcription errors)
[00:00:00] Andrew Zigler: Today we're talking to Matt Boyle, the head of product Design and Engineering for Ona company you may formerly know as Gitpod. And today we're talking about how a agentic AI is only as good as its workspace and how Ona is taking that workspace to the enterprise as an entire platform.
[00:00:17] Andrew Zigler: And what that entails, because cloud environments, you know, they're built for human devs. We talk about this a lot on Dev Interrupted, how agents and agentic engineering is arriving into an internet, not built for it yet, but these age agentic environments, they need to be ephemeral, secure, and pre-configured. And all of that becomes the new stakes for building a platform for, AI engineering. So today we're diving in with Matt about how you scope that, how you design it, and what the implications are of having that kind of safe, disposable and configurable work environment for your AI at scale. How do you share the distribution of the gains of your 10x and a 100x agentically [00:01:00] enabled engineers to everybody else?
[00:01:02] Andrew Zigler: I think that's the challenge at hand. and what's most interesting. to reflect on, and, and, and a joke that I loved from when I first talked with Matt is the idea of trying to create an agent jail. Um, the idea of creating a place that contains it so well. Uh, so how do you take that solo agent jail experience to the enterprise?
[00:01:20] Andrew Zigler: That's what we're gonna figure out today. So, Matt, you know, welcome to Dev Interrupted.
[00:01:25] Matt Boyle: Thank you. I love that intro. One thing that really resonated that you said to me there, and I've never really thought about it in in that specific terms yet, is, you know, agents have arrived into a, into an internet that's not ready for them. And so I think we're, you know, for the very first time in a long time, we're building something's already happened and we're building behind it a little bit, right?
[00:01:42] Matt Boyle: To try and get, get all the things that, and assumptions we made in the past up to us, up to the place we need them to be. So I really like that framing.
[00:01:49] Andrew Zigler: Great. I'm, I'm excited to dive into more of it and kind of see what you think about some of the other ideas we've been talking about on the show too, because y'all have a big mission ahead. Um, the idea of an agentic [00:02:00] platform, a place where you can run agents off of your laptop in scalable, auditable, configurable, and secure ways. That's like the real next big challenge, I think for enterprises and, especially larger companies that are trying to integrate it into their pre-existing tech. The Brownfield problem in AI right now is really big. So I, I, I want to just know a little bit more, Matt, about the pivot from being in a world where you are, you have these ephemeral workspace environments at Gitpod and seeing this opportunity, and like you said, like you know, that was built for an internet that agents didn't exist in. So what were the first steps y'all thought of? Like, oh, how can we re-envision this for this new world? We're all stepping into?
[00:02:42] Matt Boyle: Yeah, I actually really, I like the word re re-envision versus versus a pivot. 'cause the really interesting thing about what we're doing with Ona is we, we are building on top of Gitpod. Like we, we haven't kind of changed the product fundamentally. We're actually just taking it further than it was before.
[00:02:57] Matt Boyle: And like, the way I think about this is, and why we kind of [00:03:00] felt the need to rebrand and, and to kind of come out with, with Ona is if you think about, um, Gitpod's mission to start with was to, to make it so you're always ready to code. And like that mission is still kind of showing up in the way we're building, but the, the ultimate goal was to make humans more productive by creating environments where you hit play and the tests run and the code's always ready, really focused on getting people to have.
[00:03:23] Matt Boyle: A really fast time to first commit. And you know, in large organizations where you have, uh, real diversity in languages, code bases make it incredibly easy to be productive. you know, some of our larger customers before joining, before adopting owner, their time to first commit might be somewhere in the 30 to 40 days just because of all the bureaucracy you've got to get through setting up the laptop.
[00:03:43] Matt Boyle: And we can distill that down to. Hit in a burn, which is create environment and everything else happens. You get to use the, get the best engineer in the company to set up their laptop in the cloud. Then everyone gets to benefit from it
[00:03:53] Andrew Zigler: and I
[00:03:54] Matt Boyle: then.
[00:03:54] Andrew Zigler: that. Zoom in on the idea there that you said of time to first commit because it's like a developer experience metric of trying [00:04:00] to make it easy for them. So a again, the idea of it being designed for the humans using the internet, right?
[00:04:06] Matt Boyle: That's it. But then as you take this one step further, everything, the, the, I guess the real sort of realization for me was everything that you've done or can do to make a, um, a human more productive actually makes an agent more productive too because, you know, if you think about what we're doing as we go down this agentic journey, we're really focused on giving our agent as much context as possible.
[00:04:26] Matt Boyle: Like MCP has become really popular in terms of, okay, there's all this information, there's wealth of information about our company and Confluence or Notion, let's give our agent access to it. This, it was just kind of implied in the past that humor would have that context and they bring it into their coding sessions, and now we're really starting to think about how to make that programmable.
[00:04:43] Matt Boyle: But one of the really big unlocks for us that we realized is the most important thing actually to, to make programming, um, really productive for agents is the run loop. Having the ability to run the tests repeatedly and say, okay, that passed, that failed. Why? Fix [00:05:00] it. Take that as an input into the next round is how you go from generating code or reviewing code in a way that,
[00:05:06] Matt Boyle: it is useful, but then a human has to come in to finish it off, to really get into a place where if you've got great tests and documentation and you can give the agent context, you can actually start to run some really, really impressive, uh, uh, features, ideas, uh, changes end to end. Because, uh, you really do have the full, uh, input, validation output available to the agent.
[00:05:26] Matt Boyle: And so kind of dropping that agent inside these cloud development environments that we spent the last four years developing immediately provided so much value that it made sense to really drive down this path. And, um, you know, we're gonna be, we're gonna be spending way more time in, in this, but one thing I also wanna be
[00:05:41] Matt Boyle: really clear on, which might be somewhat surprising, is like we are gonna continue to invest heavily in environments. Like the environments are really, really important. Uh, arguably more important than the agent. I think the more access you give to, to the environment, the safer it can be. Uh, the more comfortable you can plug in.
[00:05:57] Matt Boyle: Private context that you don't want to egress outside your [00:06:00] company, the more successful agents will be. And so, uh, the environment is still very, very central to everything we do. Um, and just making it so the agent can run there safely in a way that companies and yourself are, are, are comfortable with is, is, is how we will build a really impressive agentic, uh, capability here.
[00:06:15] Matt Boyle: I think.
[00:06:15] Andrew Zigler: and that environment that has to be so finely built for the agent and its needs, like, I guess the idea of upleveling Gitpod into being like this, this home, this like housing, this container for an agent then lets you, like you said, feed into a loop because you're solving a critical part of how do you evaluate things maybe off my machine or when I'm not at it or, or otherwise.
[00:06:42] Andrew Zigler: And so it actually lets you solve the idea of I can configure this perfect environment where an agent can figure it out. This makes me think of something that I experienced a lot when I used, used, used to be a classroom teacher of the idea is you create the environment that has all of the tools and resources and methods of [00:07:00] learning and figuring out the answer and self-correcting when you're wrong and teaming up with other people and cross comparing, just creating that environment and then getting out of the way. So the learning can happen. That same thing translates to agents and taking them to scale. So like you said, you have to create the environment that has all of the right tools, all of the right resources, all the right answers, and their peers that they can work with in order to arrive at, yeah, at at solutions, at scale.
[00:07:30] Andrew Zigler: in that world, like how do you create effectively that container for them? What more does it really need than what Gitpod already had? Because I think,
[00:07:41] Andrew Zigler: the challenge I see is like, like even the networking around that is not built for agents. Like how do you tackle that?
[00:07:48] Matt Boyle: Yeah. And this is, this is a really difficult problem that we're spending tons of time thinking about. The, effectively the, the thing that is, um, very, very powerful about the way we've. [00:08:00] Kind of built out our primitives is there's absolutely no reason why a single, let's call it a prompt box, couldn't drive changes across 10 repositories at once.
[00:08:09] Matt Boyle: And this is actually more representative of how enterprise, uh, works, right? Like if you want to make a change to the front end of a dashboard, it might be you need to make a PR to the front end and then to the API gateway to expose route, and then to a, um, backend service. Uh, and maybe you have to make a configuration change in Terraform to make all these things happen.
[00:08:28] Matt Boyle: And so previously, like a human would orchestrate those three or four changes, make sure the sequence, make sure the land we're really well placed to do that actually, like incredibly well placed to, to orchestrate that whole thing. So one person can kind of just give the desire and then we can work towards that end state together.
[00:08:45] Matt Boyle: Because we run inside our customers VPCs, typically that gives us like a unique, position to be able to kind of do security and networking at like a few different layers. So ultimately we have to kind of, um, adapt ourselves a little bit to align with whatever our [00:09:00] customer's sort of network requirements and policies are.
[00:09:02] Matt Boyle: So there's definitely a lot of sort of individual fine tuning we do with our customers, but once we've got those things in place, we have quite a lot of, success in being able to drive this out, uh, at scale. Because ultimately all these are our, our machines running in inside the network.
[00:09:14] Matt Boyle: Like a lot of these companies have a lot of maturity around, around running them and thinking about them this way. So there's quite a natural, um, Ability to adopt here because even though it feels unique for a developer to say, oh, my environment now runs in the cloud, actually, these companies have been running workloads that look an awful lot like this for a long time.
[00:09:32] Matt Boyle: You just gotta think about them a tiny bit differently. And then the real changes we had to make in terms of is, is like thinking about integrations that we want now that maybe before weren't so important. You know, have it giving the agent access to MCP servers for Jira, for Slack, for notion, for Confluence, uh, giving people the ability to plug in, uh, to private repositories that they have, that they've never exposed to the internet before in a way that they're comfortable with is, is really, really powerful.
[00:09:57] Matt Boyle: And, um. In, in some of our largest customers. [00:10:00] Um, we, we work particularly with, um, financial firms and pharmaceutical companies, like they're able to give our agent access to, uh, data they consider quite classified. They would never send this to, like an open source model or something outside of their network, but they're comfortable of doing it through Ona because of the perimeter that we can put in place.
[00:10:17] Matt Boyle: The final thing on this is yesterday we launched something really cool. Um. Called Project Veto, and we can share a blog post to to, to our launch announcement for this. But one thing that's been very clear to us, uh, from the beginning here is that security hasn't really, it's not ready for the agent age.
[00:10:35] Matt Boyle: And you can, you can see tons of podcasts and, and discussion about this. I really enjoyed Lenny's podcast on this, where he talks a little bit about the lethal trifecta and how it's just kind of not solvable right now. Uh, anyone who says that they can solve it, that, that they can't. And so we've been really investing in this sort of defense in depth.
[00:10:51] Matt Boyle: And Project Veto is our first, um, product that we're gonna continue to invest in this space where, um, we hired the, the folks who built Falco. [00:11:00] Which allows you to do like runtime controls and uh, EBPF layer. So like at the kernel, and we're already seeing some evidence where we, uh, we've got some, some data points where we can, let's say you try to run a command, um, where say you wanna block people from curling to a, um, to an external endpoint.
[00:11:17] Matt Boyle: One thing that agents do is 'cause they have such a strong reward function. Is they'll try and use curl, it will fail. And then they'll write a Python script which reimagines curl and makes the request that way because they're just so incentivized to achieve the outcome. And um, some of the things we saw agents do was like rename, curl to something else, uh, which bypasses an awful lot of control.
[00:11:36] Matt Boyle: So change curl to curl and then use that instead. And it works. In a lot of cases, we've started to re really develop the primitives to block that, um, where we can. Stop certain classes of this straightaway. So agents renaming things, moving things around, trying to get clever about moving around the, the, the tools like we can block those 2, 3, 4, 5 levels deep and you can expect to see us continue to invest in this space where we really can keep the [00:12:00] agent, uh, abounded in control.
[00:12:02] Matt Boyle: And this, this is one of the biggest asks from our customers and for large enterprises is, you know, just make me feel really good about running an agent in a way that if it tries to do something, it shouldn't, like we see it and we can stop it.
[00:12:11] Andrew Zigler: I'm really fascinated by that solution because I've oftentimes found myself as someone who runs agents all the time, but in the cloud, like I, I don't do it.
[00:12:22] Andrew Zigler: on my laptop anymore for all the reasons that, you know, Ona exists because it doesn't scale and I need it running all the time and all of those answers, right?
[00:12:29] Andrew Zigler: But like all of the time when like those agents are working in that way. I've constantly been thinking like, it's almost as if the machine they're sitting on itself isn't like really well designed for them. So the idea of you, like even changing out like the kernel level or the system level of what's available and how they can operate is I think the, a really powerful idea. I've thought about the idea of, you know, we have this like containerization and virtualization of almost like how do you enrobe the agent's experience inside [00:13:00] of something where it can't like break the kernel, right? It can't modify or rename, curl or, or have all these crazy incentivized ways that it's trying to just achieve its, its goal.
[00:13:10] Andrew Zigler: Because, you know, when we had Jeffrey Huntley on the show and he talked about the Ralph Loop, that's what he emphasized really strongly was like, you know, Claude, Claude, especially early Claude Sonet, it's like a, a trigger happy, like a squirrel. And if you leave it alone, it'll just. Like, press every single button inside your code base and just like break everything. and it will always, always try to achieve its goal. So the idea of like modifying at the kernel level to be, have guardrails, I think is, is really powerful. Do, do you see that as becoming like a whole virtualized machine or a whole new like operating system almost level that they're, they're working on, that lives inside of, of Ona.
[00:13:48] Matt Boyle: Yeah, so the way, the way we're thinking about this today is, uh, we're very opiniOnated about what our environments look like, uh, which is also one of our, our learnings from building, building, um, Gitpod is, it's really [00:14:00] important that you own as much of the stack as possible to really have these controls in place.
[00:14:04] Matt Boyle: Flexibility seems nice and it can be powerful, but every time you give flexibility, you lose a little bit of control to be able to do this unless you, you know, you've got incredible engineering resources to, to fine tune for every single eventuality. So, you know, we're really standardizing on, uh, ECT machines, uh, providing our own image, providing our own virtual machine on that.
[00:14:23] Matt Boyle: And then we can guarantee the kernel. And so as long as we can guarantee that code runs in that. We will be able to have a lot more control over the security perimeter. Um, and we're gonna continue to invest in, in it from that angle.
[00:14:33] Andrew Zigler: So the idea here is that it becomes another primitive that people are modifying and customizing as they need for their specific workflow for their specific security needs. Um, but it becomes yet again, like another like thing in this pi, this agentic pipeline that you're configuring down to like a very specific level.
[00:14:53] Matt Boyle: Absolutely. So the way that veto works today is, uh, you can kind of specify some rules that you care about. Like, I don't [00:15:00] want people doing these things, but I, I'm comfortable with 'em doing these things. Um. We have our own list of rules, like, hey, here's some we recommend. for example, um, one of the things that really sort of gave us a lot of confidence, this was a good approach, is when we looked at like UL and thought about how we potentially could have been in a really good place to, to help the, so we've got rules to kind of help with that immediately.
[00:15:19] Matt Boyle: And then kind of, it then becomes like a, um, risk appetite of specific organizations of, of what they want to allow to happen within, within their enterprise. So there's definitely a configuration piece to this, but there will be some general rules that probably can apply to all agents as we, as we look to roll this out.
[00:15:34] Andrew Zigler: And as, as you're going down and down all the way down to the kernel level, what about in the other direction and going up and the things that you expose, the, the capabilities and the, and the gains from Ona to more people to within an organization, maybe even the non-technical folks who are definitely having their Renaissance moment and being able to access and build technology.
[00:15:54] Andrew Zigler: How do we bring them to Ona?
[00:15:56] Matt Boyle: Yeah, I, I love this question. There's a, there's a few things [00:16:00] here because obviously having defense in depth is really important. And right now we're talking about, um, I guess like quite a mature class of attack where we want to defend against that. But the other side of this is exactly that, is how do you get comfort that you can let anyone show up to your platform and they can use it safely?
[00:16:14] Matt Boyle: 'cause the product guides them in, in the right way. I was just listening to the, um. Boris's podcast on, on Lenny's podcast. Um, and he talked about like latent demand, right? And how you sometimes have, you know, piece your product being used in a way maybe you didn't really expect. And that's certainly been, um.
[00:16:31] Matt Boyle: One of the learnings I've got from owner over the past, um, few months that I've been here is we're seeing quite a lot of adoption actually with what we kind of, um, what we would call citizen developers, right? Like it's not the hardcore engineers, but it's kind of like the engineer adjacent. So for example, I've seen business people use Ona to generate slide decks.
[00:16:49] Matt Boyle: And, and the reason they do that is 'cause they can expose it on their network and share it with people. Uh, and it's. You know, they, they've got a lot of sort of power and control that way. Um, we've seen people really enjoy the fact that we have [00:17:00] vs code in a browser because there's like a class of data scientists who, they wanna write some Python, but they, they really don't care about c.
[00:17:06] Andrew Zigler: Python notebooks.
[00:17:08] Matt Boyle: Exactly, but, but they don't, they don't care what IDEs they use and they don't wanna spend any time investing in, in like making it work on their machine. They just want it to work. And so it's been really interesting to, to see that like latent demand show up for us. And to your point, sometimes they're the people you need to kind of have the best, I don't, I don't say anything about its security, but just like making sure the product guides them in the right direction and so we've got all the things you'd expect. Like we've got really basic RBAC, uh, we have network level controls, we have the ability to share things and, um, and even control permissions to kind of push, pull from git from within the platform.
[00:17:40] Matt Boyle: But I think one thing I'd like to see us double down a little bit more is I, I think a little bit more about personas now. You know, and it's not just about permissions. It's like, why do you show up to our platform? Like, what are you trying to get done and is there an experience we can tune towards where we can, uh, potentially just frame things a little bit differently for you if you are a.
[00:17:57] Matt Boyle: Uh, you know, a, a backend developer who's very [00:18:00] comfortable with certain terminology versus someone who just wants to, um, you know, run something inside vs code. We can probably shape the platform a little bit easier for you. Um, have the guardrails in place, um, security wise, but also just make sure we make a really pleasant experience and hide some of the complexity that you don't need to see right now.
[00:18:16] Andrew Zigler: That's really wise observation because obviously AI being here on the scene allows you to cha throw away those preconceptions or those norms we had before about how we made and shipped products, how we packaged them and made them available to people because now you really can personalize this. it meets everyone on their level.
[00:18:33] Andrew Zigler: Like when computers were first invented and people were using computers and science labs, no one was thinking about how do we make this safe for people to use in their living rooms? Like that takes time to evolve there. But like as we're learning with things like OpenClaw you know, just hitting like the most starred repo on GitHub. Ever, um, like the massive adoption of like agentic assistance and the ways of working with these tools is [00:19:00] it's living and expanding outside of a tech-focused world. So I think anything that we can do to bring this technology to them at their level and make it safe, because as they have the capability now to take advantage of it, we have the capability now to make an improved experience that protects them from the things that. That maybe are not as obvious to you and I, right? And in that world too, like a lot of other norms change as well. in something like Ona or, or working in that kind of world. Like anything can, that can access the internet, can become an IDE now, you know, you could code on your phone. Um, this is something that I, I do all the time.
[00:19:36] Andrew Zigler: I'm curious, like, what do you think about, um, the idea of how a, a tool like Ona frees people up even from their laptops and, and the way that they do with their work?
[00:19:44] Matt Boyle: Yeah. So in in our, in our company, in our organization, and in our most forward looking companies that we work with, we, we do not see much IDE usage anymore at all. Um, it's very, very rare for an engineer in our company to open a fully [00:20:00] fledged IDE and we, this week we shipped, um. Uh, what we could call review like in the product.
[00:20:06] Matt Boyle: So you can, Ona will generate code for you, and then it will show you the changes and you can comment on them like it's a GitHub poll request exactly the same experience, but without leaving our product. And then you press one button, you send it back to the agent. The agent fixes it based on your review, and you're ready to actually merge more and more.
[00:20:22] Matt Boyle: I am convinced that the, the IDE might not see it till the end of this year. I think, um, people who are not willing to let go of habits they have today, I think will continue to use it. And, you know, you can see IDEs even trying to shift into this. If you use the latest version of Cursor, it looks an awful look like owner where they're trying to step away from the VS Code, uh, browser a little bit into more of this like conversation
[00:20:44] Matt Boyle: orchestration on the left hand side, and it may be some sort of review panel. Um, and so yeah, I do more and more of my development on the phone, on my phone now. Like I raise pull requests instead of tickets now. 'cause it's easy, like it's so cheap to show instead of telling now that actually throwing up the PR is actually [00:21:00] much faster than, than writing the ticket at times.
[00:21:02] Matt Boyle: And you can even work backwards from that into a ticket if you want to. But yeah, all these notions we had of how we should work and, and, um. The pace that of delivered that was possible are all thrown out the window. And if you let go of the IDE is something that you need actually, it's quite freeing actually.
[00:21:16] Matt Boyle: And you start to realize like how much more you can actually get done if you don't need to defend on, on that interface.
[00:21:20] Andrew Zigler: Yeah, I, I completely echo that.
[00:21:22] Matt Boyle: Okay.
[00:21:23] Andrew Zigler: Abandoning the IDE and moving into the terminal was one of the best moves that I made for just my speed. And it's something now where, you know, I was a diehard IDE user, but like now I, I can't even go back. Like I just, I much prefer to be in the terminal. Um, I just think there's a, it actually what.
[00:21:39] Andrew Zigler: How I've thought about it before is it gets you closer to the craft. I think in a lot of ways it's, you're kind of getting rid of complexity and the layers that you needed before to kind of work with it that way. But like you said, those experiences, those IDEs are also now very, so conversation driven, like the chat window takes up most of the screen tools like Cursor, like they opt you [00:22:00] into an experience where you have multiple chats and you're, they're trying to not even really show you the code anymore. So it's like everyone's evolving into that new way of working. And like you said, it sometimes that involves like piecing together what you need and working backwards. There's so much context, flipping over and, and exploring. And honestly, I spend most of my time just gathering all of the context and aligning it all up.
[00:22:22] Andrew Zigler: And before I would even start to execute it, which is like speaks to a fundamentally different skillset that I think engineers have to be building and adapting. Uh, what do you think about like the skills that engineers of today and tomorrow need?
[00:22:36] Matt Boyle: Yeah, I mean, one thing you started, uh, this podcast you introduced me is the, the head of product design and engineering, and. It might seem quite unusual, I guess, to group all of those so closely, but I think the, it actually represents how we think about the future of, of, of engineering and, and product and design is we hire people who are very T-shaped now and like really, really look for people who have depth in one area, but can branch [00:23:00] out in both directions.
[00:23:00] Matt Boyle: So. You know, we have a designer who can ship. We have a, um, very product minded engineers who will, can go and speak to our customers, represent great empathy, and move it all the way through to, to production too. And I think this is the way I think about, uh, the skillset of engineers of the future is like
[00:23:18] Matt Boyle: in the 2010s we used to talk about like full stack engineer, and I think about that again, but full stack means something a little bit different to me now. It means full stack product. It means thinking about design and it means being able to kinda execute on that too. And if you really embrace this, um, and, and find people who, who are kind of committed to, to working this way, you know, some of the
[00:23:38] Matt Boyle: most, uh, technically challenging things in Ona have been built by like, teams of two people because they're just so empowered and capable of driving things from idea, you know, maybe it's very unclear too. And they can drive clarity around the idea, they can plan it, they can execute it all the way through to, to production.
[00:23:54] Matt Boyle: Um, so they're the people I really love working with. And, you know, we're, we're seeking out more and more of those people who [00:24:00] are, they've probably spent their career going deep on one of them and are now starting to explore the other two parts of the craft. Now that the barrier to entry's a little bit lower and the rate to which we can see people grow in those areas is, is phenomenal.
[00:24:11] Andrew Zigler: And I, I'm sure you've seen this too as well. The ability now for engineers to spread out into that wider fan shape of being able to do things has never been, those possibilities have never been more, more open. Um, the idea of even working with, um, agentic tools to grab the understanding that you don't have to have a sparring partner as you're learning and to ex expand into those areas, I think is really critical. Um, I love the idea of like, you know, the designer who can ship and the engineer who can go to customer meetings. Uh, we actually talk a lot about the importance of that cross interdisciplinary, like access to customers and problems that engineers that they really need to, uh, ship software that's impactful, In this world too, I'm sure you're envisioning a lot of the time that engineers [00:25:00] spend isn't now, you know, in a Claude code session necessarily, because a lot of it is spent a aligning and getting the decision on what needs to happen, but then also becoming like the context guardian, like having the really great Jira ticket that has all of the excellent context in it, and then being able to like engineer this like shared layer between the humans and the agents I think that becomes like the new challenge for engineers to go after.
[00:25:29] Matt Boyle: Absolutely. I can give you, I can give you a concrete example of, um, this workflow and how it's showing, showing up for a little bit, which is, which is fun and might seem wild to some people listening to this depending where they're on the journey, but like, yes. So I, I spend most of my time in, in meetings, honestly.
[00:25:44] Matt Boyle: But there's, I have this real desire to have a Slack integration. It's something we've been talking about for a little while and I'm just like, you know what? Today is the day I'm gonna build it. So Ona has this plan mode and so I gave it the Slack docs I gave access to, um, another [00:26:00] integration we built recently, which is the Linear one
[00:26:02] Matt Boyle: and so I asked it to explore our code base, uh, figure out how we should build this, and then from that I used our notion integration to push that design doc to, to notion. I then, uh, while just before I attended a meeting, I sent it to some of the most senior engineers in my team and asked 'em to review it, leave comments and feedback.
[00:26:17] Matt Boyle: I, I read it digested where I think it could be improved and, approve their comments, changed it a little bit and told owner to pull that back in. I wanna pull that back into the platform. Um, and I asked it to, to make a Linear project for me and to split it into, uh, tickets smallest shipable increments it could come up with, uh, and to map the dependency between those tickets too.
[00:26:39] Matt Boyle: And so it pushes all that to Linear and Linear shows me which tickets are blocked by which, and, and which ones, uh, can be done in parallel effectively. Um, I then used Linear for Agents, which is another integration we built to assign the ones that didn't have dependencies to agents owner went off and built them.
[00:26:56] Matt Boyle: I carried on with my meetings and at lunchtime there was four prs ready for me to [00:27:00] review, um, which I shared with the colleagues to make sure we were aligned and happy and, and off we went. Anyway, this goes on, you can see how this is playing out, but by the end of the day, I went from, I'm gonna build this, this morning to it shipped in the evening, and then today we're just doing the configuration pieces to be able to do it.
[00:27:16] Matt Boyle: I feel like this would've been a once, two week project in the past for me to be able to go from, okay, I want this, like, I need to figure out how to do it. I need to explore our code base. I need to understand it. so to be able to, do this in, in a day is just mind boggling to me when I reflect. But all of this is just about bringing humans into the loop at the right points.
[00:27:35] Matt Boyle: Really spending that time and planning and, you know, giving it to your point, like the great context and encouraging the agent to explore specific parts of the code base that I, I knew were good for it to explore. And then from that you can accelerate development so, so quickly.
[00:27:50] Andrew Zigler: I love that you brought us here to the story of how you use loops and how you are using engineering, agentic engineering tools, um, in the background to enable yourself and [00:28:00] do things. You called it like a two to four week project in the past, you know, but like you, you were in meetings the whole time this thing was even being built, right?
[00:28:06] Andrew Zigler: That's actually the real benefit, is that you didn't really spend any time aside from understanding really clearly what you wanted and arranging the resources that were needed. Um, the way that you described it of. very cleanly laying everything out, breaking it up into a very atomic tasks, para or parallelizing things as you need, and then assembling at the end.
[00:28:26] Andrew Zigler: You know, that's something that we talk about a lot on the show. It sounds crazy to many people, maybe not. a lot of Dev Interrupted listeners because we have some amazing cutting edge folks on here every week that are echoing the same stuff You are, Matt, about how that's what makes for a successful engineering output now.
[00:28:41] Andrew Zigler: And, um, and so I, I love to hear that story. I, I have a lot of similar success, especially with bringing other people in to iterate on, those outputs, those experiences. especially for, this is a call to action, I think for product managers, engineering managers, folks who are in a, like a team lead position and [00:29:00] have an opportunity to be doing projects like this, uh, like between or during meetings, and then sharing, having a system. Where you can share the outputs back to your engineers and your team and quickly get a register and a read on like, is this useful? Is this solving the problem actually lets you unlock like an iterative speed? so you, you talk about the Ralph Loop and I know, uh, that on Ona, y'all had this amazing blog post about the Ralph Loop. And Ona I think is critical to what makes the Ralph Loop successful. Um, the idea that it's the environment that, um, allows that loop to run over and over again and get that output eventually.
[00:29:36] Andrew Zigler: And you can just rely on that environment being configured exactly as you expected. But I'm wondering about like. How do we take that further? So like the Ona world and the Ralph world. I think that, like, I I also compare this, the idea is like Stevie Yegge's Gas Town, the idea of you scale that up into almost like a, a software factory and that lives somewhere.
[00:29:57] Andrew Zigler: And I made a joke like on here a few months ago, where a [00:30:00] week ago, where I was like. know, oh, what's, what's gonna happen? Is my gas town gonna call your gas town? Like, I don't think that's where this is going, but now I actually think that is where this is going with things like agentic engineers, uh, engineering platforms like Ona.
[00:30:13] Andrew Zigler: Like you could have those systems and those factories, and then have to now think about how do you wire them up between each other. I'm just curious to, to pick your brain on how you think it's like the evolution of engineering. Like things like Gastown will collide with things like Ona.
[00:30:28] Matt Boyle: Yeah, it's a, it is a great question and we spend a lot of time intention here. I think because we, we're, we're, you know, we're a series A company. We have a lot of flexibility to, to move around our SDLC process, how we think about things. Um. But we also, because of the customers we have, we also have, um, you know, we have SOC 2 compliance requirements, like our customers have even more stringent requirements than we do.
[00:30:52] Matt Boyle: And so it, it's really important that we try and stay as close to the cutting edge as possible. And we think of a lot about, like these really long [00:31:00] running loops where, you know, you saw Anthropic, rust compiler, but like there's, there's all these checkpoints that are built into the SDLC process that again.
[00:31:08] Matt Boyle: The, the, the world wasn't built for agents yet. We're not ready for these incredibly long running processes. And so I spent a lot of time in this tension about how far do we push owner today in terms of, its like long running capabilities versus how do we make sure that we're actually serving what our customers need today, which is it has to map to their SDLC process.
[00:31:25] Matt Boyle: And it doesn't mean we can't put a bit of tension on them to encourage them to change things, uh, you know, where, where they need to. But a lot of the things in their SELC process were wisely put in place for, for certain reasons. You know, um, uh, I, I think if people found out the bank was running huge Ralph Loops to develop a, a brand new feature, they'd be pretty uncomfortable with that.
[00:31:44] Matt Boyle: Um, so I spent a lot of time on this particular problem with our customers trying to reimagine not just what SDLC looks like for those who can move incredibly fast, but how does it look for those who, you know, have these really intense compliance obligations? And, um, I don't have all the answers yet, but I have some really good ideas about, [00:32:00] uh, things we can start to explore here to speed up various points and then we can look to work together to maybe.
[00:32:05] Matt Boyle: Really start to reimagine SDLC for scale, not just for the smaller companies where they can just, you know, run a Ralph loop forever.
[00:32:12] Andrew Zigler: Do you think the SDLC stays a human and agent collaborative place, or do you think it moves fully into the domain of the agent in that world?
[00:32:20] Matt Boyle: For me, this is such a good question, I feel, I feel. This splits into, into two, doesn't it? I think in the, in, in, in the medium term, I think humans as being in the loop makes tons of sense. Because I think when I think about the best engineers in the company, uh, today, they're the ones who have the most context actually of the things that shipped the system, uh, architecture.
[00:32:42] Matt Boyle: And if you give a really senior engineer access to AI tools, they fly. Whereas we still have the same problem where we need to give guidance to, to, uh, more junior engineers who they have access to the same tools, but they don't achieve the same outcomes. And so why is that? It's because humans are still very, very important to, to the planning and the loop [00:33:00] process.
[00:33:00] Matt Boyle: And if you ask, um, if you ask an agent like, what should we build next? It still doesn't give you a great answer even if you give it all the context in the world. So at least in the. The midterm. I think humans being in the loop is incredibly important. I would not dare bet against like entirely autonomous, uh, features teams existing in the future.
[00:33:18] Matt Boyle: And when I say the future, like could be next year with the rate of development we're working on. And so I, uh, I'm. I guess cautiously, um, pessimistic I guess for this year. But like we, the, the, the framing I always try and keep in my mind is like build for the models that are gonna exist in six months and 12 months.
[00:33:36] Matt Boyle: And like when I approach our product with that lens, like I really do think the software factory that you talked about is a really interesting one. And whether the person who puts that thing on the conveyor belt, the front, is that a human or an agent. And it's probably likely gonna be a bit of both, I think.
[00:33:49] Andrew Zigler: The idea of the autonomous software factory running by the end of the year or maybe early next year. It's definitely something to consider. Right? And, and I think when that happens, like we'll have to, we'll [00:34:00] have to have you back to talk about how like the idea of that living on something like Ona is a reality because it, if anything, I think that that would come into existence on a platform like Ona, because like we said at the beginning, agents have arrived into an internet.
[00:34:15] Andrew Zigler: That's not built for them yet. And challenges upon us now to construct that internet and Ona is tackling this, I think, in a lot of fascinating ways that appeals to, you know, really strict and compliant enterprises, but also like lightning fast teams. And you don't get a lot of product coverage and tools that are that relevant and that important right now. So I think it's a really exciting story to follow. You know, we've been covering Ona here on Dev Interrupted for a while, and we'll continue to, but. it's been a blast having you on the show to talk about like the vision behind it. I'm curious, like, do you have any final notes you want to end on for our audience where maybe they can go learn more about Ona and what you're working on?
[00:34:53] Matt Boyle: Yeah. So head over to Ona.com, read some of our blogs, like we're, we're trying to get, uh, way more, [00:35:00] um, involved in posting how we're thinking about where things are going and how we're thinking about the space. So we'd love for you to read all those and, uh, message me on LinkedIn or Twitter if you're like, Hey, I, I have an interesting take on something you said, or I disagree with you.
[00:35:11] Matt Boyle: I'd love, love to hear from you. Um, we recently, in the last few months, we launched a, um, a cloud offering where you don't have to have. You know, you don't have to deploy this into an enterprise or have an enterprise account with us. You can sign up and pay like 10, $20 a month and start experiencing owner.
[00:35:27] Matt Boyle: So if anything I said sounds interesting, please give it a try again, send me your feedback directly. I respond to everybody. I love hearing it.
[00:35:33] Matt Boyle: So if you're interested in agent security, runtime security, especially like really want to hear from you.
[00:35:37] Andrew Zigler: Awesome. Well, we're gonna include all those links in the show notes and I love to call to action for people to come and find us on LinkedIn continue the conversation. I've really enjoyed having, uh, these conversations continue beyond the podcast here. So please come find us, share what you think, about these tools and where, all of this is going.
[00:35:54] Andrew Zigler: We definitely wanna hear from you. So thanks for listening to Dev Interrupted, and we'll see you next time. [00:36:00] And Matt, thanks again for coming on the show.
[00:36:02] Matt Boyle: Thank you. It's a pleasure.
