Latest / Code Story | Startup Podcast for CTOs, CEOs and Technical Founders / Making AI Deterministic for Developers and their Agents, with Patrick Vuong of Moderne

Transcript

Making AI Deterministic for Developers and their Agents, with Patrick Vuong of Moderne · Code Story | Startup Podcast for CTOs, CEOs and Technical Founders

• 0:01
  [SPEAKER_01]: Hello listeners.
• 0:02
  [SPEAKER_01]: Today we have a special guest in the code story podcast, Patrick Wong, director of product at Bedurne.
• 0:08
  [SPEAKER_01]: Bedurne is the agent tools company, building the knowledge, discovery and execution tools that AI agents rely on so they can operate faster more accurately and at far lower cost.
• 0:20
  [SPEAKER_01]: In today's episode Patrick is going to tell us all about the company and how modern is enabling developers to build software faster using agents and agent tools with the best context.
• 0:30
  [SPEAKER_01]: Their approach to semantic models produces deterministic, over-probabilistic, or inference-driven tools, which for this engineer, slash host, has been a point of skepticism for AI since the beginning.
• 0:45
  [SPEAKER_01]: Well Patrick, thank you for being on the show today.
• 0:46
  [SPEAKER_01]: Thanks for being on code story.
• 0:48
  [SPEAKER_01]: Looking forward to it.
• 0:49
  [SPEAKER_01]: Really excited to jump into Madurin today, but before we do, tell me a mountain to a little bit about you, maybe your path is point, influences, hobbies, family, things like that, but really whatever you want to tell me.
• 1:00
  [SPEAKER_00]: So maybe let's start with worm from.
• 1:02
  [SPEAKER_00]: So I'm Canadian, originally born and raised in Toronto, and I went to the University of McMaster in Hamilton, Ontario.
• 1:10
  [SPEAKER_00]: There, I essentially went into the program for business, but it was looking to find where my passion lies, especially leading to a career.
• 1:18
  [SPEAKER_00]: And it's interesting.
• 1:20
  [SPEAKER_00]: I ended up finding it through an experiential learning program.
• 1:25
  [SPEAKER_00]: So not even through the day-to-day courses.
• 1:28
  [SPEAKER_00]: This program was where they select 12 different students, split them into two teams.
• 1:33
  [SPEAKER_00]: And each week, we had a company come in and bring in the real world business case.
• 1:40
  [SPEAKER_00]: And then the final piece of it is you actually go to this closing ceremonies where it's almost like a draft and you find out which company you end up with And that was where I got my career start on Microsoft.
• 1:52
  [SPEAKER_00]: I've been the biggest thing that I got from that program
• 1:55
  [SPEAKER_00]: was learning how to take customer need or understanding the problem and turning it into an insight.
• 2:01
  [SPEAKER_00]: And then starting at Microsoft because of this program is being the huge journey.
• 2:06
  [SPEAKER_00]: Eight years there, different countries from first Microsoft Canada to then going to the headquarters, doing marketing there, then doing go to market, doing some revenue, then doing technical product marketing.
• 2:20
  [SPEAKER_00]: And for out this whole career, the common stretch and theme of it has been working with developers from doing the app dev to dev tooling and then doing the partnership between Microsoft and GitHub.
• 2:32
  [SPEAKER_00]: And Microsoft has really truly took me around the world from building flagship demos he now took a Microsoft build in Microsoft Ignite and in my favorite part was always sitting down and doing the executive briefings where
• 2:44
  [SPEAKER_00]: Customers would actually fly over to Seattle, meet with us in the narrative and the product group that I was in charge of was agentic DevOps, where humans and agents start to work together to reinvent software, but all of that closed two weeks ago.
• 2:58
  [SPEAKER_00]: I officially joined Medarian in now and leading product management.
• 3:02
  [SPEAKER_01]: That's amazing.
• 3:03
  [SPEAKER_01]: It's quite amazing story.
• 3:04
  [SPEAKER_01]: It sounds like you have gone all over the world and had some interesting conversations, worked in some pivotal areas in technology.
• 3:12
  [SPEAKER_01]: And I think that's a really interesting segue, actually, into modern.
• 3:17
  [SPEAKER_01]: So what is modern?
• 3:19
  [SPEAKER_01]: Tell me in my audience what the company is and the product's product's sweet is.
• 3:24
  [SPEAKER_00]: So similar how I've just gone through a full transformation and same as the industry, Madur and Elsa has gone through a transformation very recently.
• 3:33
  [SPEAKER_00]: So I think if we go back and we talk about where we started.
• 3:37
  [SPEAKER_00]: So Madur and started focusing on helping customers get their code-based foundations in order.
• 3:43
  [SPEAKER_00]: So really focused on tech debt.
• 3:45
  [SPEAKER_00]: When we look into tech that it's when teams take shortcuts, prioritizing speed, quick fixes for like quality and long-term scalability.
• 3:55
  [SPEAKER_00]: And if the code base is not constructed correctly, it makes it harder to maintain, cost more, and to add new features.
• 4:02
  [SPEAKER_00]: And I think this is more important than ever, especially in the world of AI, imagine your agents are working on that code base.
• 4:08
  [SPEAKER_00]: And then this solution, it was actually built on an open source project called open rewrite, which is what our founders, Jonathan Steiner, and Olga, absolutely maintained at MudPerry.
• 4:19
  [SPEAKER_00]: And we should have a team here at Mudern that we also maintain it.
• 4:23
  [SPEAKER_00]: We essentially use open rewrite to handle large scale framework and library migrations.
• 4:28
  [SPEAKER_00]: Think about upgrading frameworks, fixing vulnerabilities, cleaning up, tech that to get your code base AI ready.
• 4:36
  [SPEAKER_00]: And this is where the change started, to know up.
• 4:38
  [SPEAKER_00]: So this is what we're doing for a bit, and we continue to do this now, because it's truly, you have to modernize to innovate.
• 4:47
  [SPEAKER_00]: It's not like you can go right in, because imagine your agent's coming in, and it's
• 4:51
  [SPEAKER_00]: a complex code base.
• 4:53
  [SPEAKER_00]: That's the input.
• 4:54
  [SPEAKER_00]: That's going to affect your output.
• 4:56
  [SPEAKER_00]: So as the industry continued to change, we were like, okay, we actually can be with you across this journey.
• 5:04
  [SPEAKER_00]: And we're seeing how these new frontier organizations get to that next step.
• 5:08
  [SPEAKER_00]: So we have grown ourselves where in addition to preparing your code base for AI, we now actually provide deterministic tooling or help agents become token efficient or even help agents do factory orchestrations.
• 5:23
  [SPEAKER_00]: So think about leaps of agents working across the lifecycle and how we're doing this is we're essentially building tooling for agents.
• 5:33
  [SPEAKER_00]: So, as I'm just maximizing how coding agents want to work more effectively, or even some helping some of these customers use agents to operate it autonomously with like dark factories where it's fully agent orchestrated and human stays in the loop.
• 5:48
  [SPEAKER_01]: Okay, so that brings up a whole slew of questions for me, but the first one, I want to, I want to ask as a baseline, just to keep the audience tuned into the why.
• 6:02
  [SPEAKER_00]: So I think it comes down to two things.
• 6:05
  [SPEAKER_00]: So just as Jenny, I gave developers new generations of tools.
• 6:10
  [SPEAKER_00]: But during gives AI agents the tools they need because of two things.
• 6:15
  [SPEAKER_00]: To work accurately and to work efficiently.
• 6:18
  [SPEAKER_00]: When we look at these agents, the first piece is that they are essentially building suggestions and the answers are non-deterministic.
• 6:28
  [SPEAKER_00]: The second piece is a cost tokens, but when we look at AI and we look at the ROI of it, especially this is why we want to equip tooling for these agents.
• 6:40
  [SPEAKER_00]: AI ROI is absolutely recognized that scale.
• 6:44
  [SPEAKER_00]: MIT Sloan actually recently said large scale AI transformation is just at around 8%.
• 6:50
  [SPEAKER_00]: So some of the blockers of why ages need some of these tool links, especially thinking about it at scale, is three different walls they hit.
• 6:58
  [SPEAKER_00]: One is, it just can't maintain around 10,000 repos or that context, so we had to help them with that.
• 7:06
  [SPEAKER_00]: Secondly, like I mentioned, was the accuracy piece.
• 7:09
  [SPEAKER_00]: It's non-determined mistake issues that seem minor in a demo, but they compound that scale.
• 7:15
  [SPEAKER_00]: These hallucinations could be catastrophic when you look at it scale.
• 7:20
  [SPEAKER_00]: Then the next thing, as we're starting to see with the recent news, we're starting to see token-based
• 7:26
  [SPEAKER_00]: Agents are actually burning millions of tokens rebuilding the context every single time to understand what's happening and then these aren't just edge cases or starting to see these as outcomes and this will why if you're able to provide deterministic tooling for these agents and also way is where they can receive contacts and search really quickly or able to help across all of those amazing it's something jumped out of me there when when you were describing
• 7:55
  [SPEAKER_01]: You know, the non-deterministic versus deterministic, you mention that you're building tooling for agents that are deterministic.
• 8:02
  [SPEAKER_01]: Tell me about why that's important.
• 8:05
  [SPEAKER_00]: How do we start with the foundation of how we built it?
• 8:08
  [SPEAKER_00]: So there's two technologies that we actually looked at that.
• 8:11
  [SPEAKER_00]: It took quite a few years to build.
• 8:15
  [SPEAKER_00]: One of them is essentially regarding semantic depth.
• 8:18
  [SPEAKER_00]: So, it's called this loss to this semantic tree, and think about it as a compiler, accurate model of your code.
• 8:26
  [SPEAKER_00]: So not text matching, not ASTF approximation, it's full-type resolution, symbol attributes in cross-file understanding.
• 8:34
  [SPEAKER_00]: So think about it where
• 8:36
  [SPEAKER_00]: It's exactly what the compiler sees your code and it is reusable at scale.
• 8:41
  [SPEAKER_00]: If we're able to create that kind of clone for your agent, that's like all the context that they would need.
• 8:49
  [SPEAKER_00]: And then to take that a little fair there, so once we have that, it's this thing called a recipe that is built on top of this LST.
• 8:56
  [SPEAKER_00]: You know how right now in the industry, having agents work as close as they can to get a really good
• 9:06
  [SPEAKER_00]: recipes are a little bit different because they're built on the detail of this lossless semantic tree.
• 9:12
  [SPEAKER_00]: It's essentially a programmable recipe that can drive deterministic executions.
• 9:17
  [SPEAKER_00]: These are programs and they're not prompts and it essentially allows you to drive a transformation that is deterministic.
• 9:24
  [SPEAKER_00]: So thinking about something as complex as migrating spring boot or safely repeatedly and you can do it across thousands of re-pos
• 9:35
  [SPEAKER_00]: It's the agent for understanding that, hey, we need to go and migrate Spring Boot 4.
• 9:41
  [SPEAKER_00]: Let me look at my LST, then reach for a recipe that can help me make this Spring Boot 4 change versus making suggestions and doing some non-deterministic actions.
• 9:53
  [SPEAKER_01]: So amazing, and the engineering me is completely geeking out at all of this, and the skeptical part of me towards AI is really excited to hear tooling that is deterministic.
• 10:07
  [SPEAKER_01]: As we peer into text acts across the industry, where does modern fit?
• 10:12
  [SPEAKER_00]: Let's look at the landscape.
• 10:13
  [SPEAKER_00]: So one is agents are getting smarter every month.
• 10:18
  [SPEAKER_00]: and your STLC already has processing governance built in.
• 10:21
  [SPEAKER_00]: But, the STLC was designed for the human.
• 10:24
  [SPEAKER_00]: So, when agents are producing changes across hundreds of repos, the power class review cues, manual approvals start to become the bottleneck.
• 10:34
  [SPEAKER_00]: it's actually not the code.
• 10:36
  [SPEAKER_00]: So now you have two sides of that same problem.
• 10:38
  [SPEAKER_00]: Agents are powerful, but lack destructuring context that's safely on enterprise code.
• 10:43
  [SPEAKER_00]: And the STLC has the structure, but was in built code the speed and volume of this agents that the agents are creating.
• 10:51
  [SPEAKER_00]: So where we see modern fit is absolutely that deterministic harness.
• 10:55
  [SPEAKER_00]: So when we think about the harness, we think about deterministic tooling grounded in a semantic model of your code.
• 11:03
  [SPEAKER_00]: It helps as like the factor orchestration essentially the sequence of agents that can be governed in audible workflows.
• 11:10
  [SPEAKER_00]: So think about it as agent does the work.
• 11:12
  [SPEAKER_00]: The harness make sure the work actually lands.
• 11:15
  [SPEAKER_00]: That's where I see modern fits as the
• 11:20
  [SPEAKER_01]: This is really interesting, and as an engineer and having built software for years now, we'll see more of this fits, it's really interesting, and also kind of this new STLC that's a little more agent and driven, this is really nicely.
• 11:35
  [SPEAKER_01]: I'm curious, so you mentioned early on in the conversation that Moderna is sort of shifting past here.
• 11:42
  [SPEAKER_01]: The pivot to where you are now with this,
• 11:50
  [SPEAKER_00]: That's a great question.
• 11:51
  [SPEAKER_00]: We actually think we are with customers across this whole journey.
• 11:56
  [SPEAKER_00]: So, from the ones even before the pivot, where they're getting their code base foundations in order, so upgrading framework's leaning up tech debt, so that their code is AI ready, but there's still supports you there.
• 12:08
  [SPEAKER_00]: Dan Middurn supports the customers that now their AI code is ready, where we're supporting customers that are using coding agents and they want to make them more effective.
• 12:19
  [SPEAKER_00]: We help you there, especially with some of our products that I can talk about, the help agents search better to get better context.
• 12:27
  [SPEAKER_00]: And then finally, we're working with the frontier customers that are thinking about these new organizations.
• 12:34
  [SPEAKER_00]: of agency humans, where they scale completely.
• 12:38
  [SPEAKER_00]: Big about dark factories, where agents are fully operating and then bringing human in the loop when it's needed.
• 12:45
  [SPEAKER_00]: So essentially, we meet customers wherever they are in their journey and we help them move forward with modern to get to those three different stages.
• 12:53
  [SPEAKER_01]: Very cool.
• 12:54
  [SPEAKER_01]: Tell me about some of those products that you know, ECD mentioned, you can talk about some of those.
• 12:58
  [SPEAKER_01]: Some of the things that you're building, give me a
• 13:02
  [SPEAKER_00]: Yes, so this is how I like to think about it for agent tooling.
• 13:06
  [SPEAKER_00]: So again, just how it has really changed the way the developers work.
• 13:11
  [SPEAKER_00]: Midterons trying to change the way AI agents work to make the more accurate, efficient, and productive outscale.
• 13:20
  [SPEAKER_00]: So this is how we're looking at it.
• 13:22
  [SPEAKER_00]: One, how do we help agents search better?
• 13:25
  [SPEAKER_00]: We have this product called TriGrap, which gives agents faster ways to search, symbol aware precise code search that assumption though, reading fewer files and burning fewer tokens.
• 13:37
  [SPEAKER_00]: Then secondly, we help agents with context.
• 13:40
  [SPEAKER_00]: Is this product called pre-fake, which gives them essentially a pre-computed architectural context and understanding of their code base before they even start?
• 13:49
  [SPEAKER_00]: And we started to see some of the results.
• 13:51
  [SPEAKER_00]: It's four times faster, reasoning, 55% fewer tool calls, and then 30% fewer tokens used.
• 13:58
  [SPEAKER_00]: Then the other piece is how do we give them that visibility?
• 14:02
  [SPEAKER_00]: It's another product called Change Log, which gives them the awareness of what's already in flight across the portfolio.
• 14:08
  [SPEAKER_00]: So they're not duplicating work or sequencing it wrong, and how we're giving these agents all these tools is through MCP.
• 14:16
  [SPEAKER_00]: So think about it as your cloud code, your compile it, or whichever agent you're using or that the customer is using.
• 14:24
  [SPEAKER_00]: Going back to what we were saying that deterministic harness, we're giving the tools to your agent, whichever agent you're using through mcp to search better get better context and get awareness so that you can essentially execute deterministically.
• 14:39
  [SPEAKER_01]: again, super, super cool and completely geeking out.
• 14:44
  [SPEAKER_01]: Every time you say deterministic, the skepticism, the AI skepticism in me, as an engineer, really starts to kind of melt away there.
• 14:53
  [SPEAKER_01]: So with the tooling you're building for agents, what does the future look like?
• 14:58
  [SPEAKER_01]: So about what you offer, how you're going to take this to the next level, as you follow the industry, as it, you know, with the continued advent of AI, what does the future look like for what you
• 15:09
  [SPEAKER_00]: I think we're bucking in the three themes.
• 15:13
  [SPEAKER_00]: The first one is continuing to invest in deeper deterministic tooling.
• 15:19
  [SPEAKER_00]: So, this is how we look at it.
• 15:21
  [SPEAKER_00]: The bigger efficiency gains for agents is actually offloading work from entrance to fast deterministic tools.
• 15:29
  [SPEAKER_00]: So they don't hallucinate their cheaper and they're more auditable.
• 15:33
  [SPEAKER_00]: And some of the things that we're thinking about, for example, is expanding tri-grap.
• 15:38
  [SPEAKER_00]: Remember that search capability to multi-repo search, adding multi-repo recipe execution.
• 15:45
  [SPEAKER_00]: So thinking about that scale piece all-callable by agents.
• 15:48
  [SPEAKER_00]: We're even working towards the other side where how we can think about tying this to deployed binaries so you can find vulnerable methods and production and you can fix it from there.
• 15:58
  [SPEAKER_00]: So that's one pillar.
• 15:59
  [SPEAKER_00]: Again, giving the agents what they need for a deterministic tooling.
• 16:04
  [SPEAKER_00]: The second one is that other way of I was mentioning where it's humans and agents making this organization and how we're thinking about it is almost this modern factory that we want to go
• 16:18
  [SPEAKER_00]: This is where modernization becomes autonomous.
• 16:22
  [SPEAKER_00]: So you set a goal, for example, migrate to Java 25, remediate every CVE, enforce standards, and the factor just runs.
• 16:31
  [SPEAKER_00]: So a four-minute agent plans the work.
• 16:33
  [SPEAKER_00]: A technician agent executes using our deterministic tools and memory compounds across the fleet so cost fall as the system learns, so almost like self-healing.
• 16:44
  [SPEAKER_00]: What recipes don't cover, agents can then handle or create, and we also have a capability where now new recipes can feed back into the next run, and agents can write their own recipes, or we can use AI to write these recipes.
• 16:59
  [SPEAKER_00]: So the organizations that are always behind in the modernization curve, if they use this factory, then now can stay ahead of it.
• 17:06
  [SPEAKER_00]: And then finally, the last pillar we're thinking about is what we were talking about before, which is that agentic ready STLC.
• 17:16
  [SPEAKER_00]: So as agents take on more work, you need visibility and governance, right?
• 17:20
  [SPEAKER_00]: What we want to bring to this suite is artifacts that can show your dependency landscape.
• 17:26
  [SPEAKER_00]: Transcripts that can capture every agent session or audit trail change logs that can track
• 17:33
  [SPEAKER_00]: Totally all of this together would create this institutional memory where every agent Sasha and essentially will make the next one more effective.
• 17:43
  [SPEAKER_00]: And in this economy or this age-in economy, having institutional television is the durable asset.
• 17:49
  [SPEAKER_00]: Yeah, no doubt.
• 17:50
  [SPEAKER_01]: We talked about who the customer is.
• 17:53
  [SPEAKER_01]: And I hear you saying, you meet the customer where they are based on what you used to offer in which you offer now.
• 18:01
  [SPEAKER_01]: What about size of customers?
• 18:02
  [SPEAKER_01]: Is this targeted?
• 18:03
  [SPEAKER_01]: Is this mainly for the enterprise where can startups use this that are maybe coming into more of a middle size or growing?
• 18:10
  [SPEAKER_01]: What does your thought there?
• 18:12
  [SPEAKER_00]: I would say essentially we're for all customers that open-rearrate open-source project.
• 18:18
  [SPEAKER_00]: This is where you can go one app at a time, but when it comes to the modern, for enterprises you're about, you're able to do multiple repuls all out of time because we're looking at it horizontally.
• 18:30
  [SPEAKER_00]: And then when it comes to our new side of agent tooling, as long as there's like an existing codebase, using, we essentially improve how agent search,
• 18:39
  [SPEAKER_00]: how they get contacts and this applies to any type of organization.
• 18:44
  [SPEAKER_00]: That's amazing.
• 18:45
  [SPEAKER_01]: That's really good to hear as a startup.
• 18:46
  [SPEAKER_01]: Because it definitely, everything is super intriguing.
• 18:49
  [SPEAKER_01]: Well, Patrick, let's switch to you for a second.
• 18:51
  [SPEAKER_01]: You know, you entering into a new chapter with Modern.
• 18:55
  [SPEAKER_01]: You what makes you most excited going for Microsoft to entering the startup world with the company.
• 19:01
  [SPEAKER_00]: There's a few things.
• 19:02
  [SPEAKER_00]: One is, I feel if there's a thread that just goes across your career and your life and there's things that just stay consistent.
• 19:11
  [SPEAKER_00]: And to me, it's always been with the developers, just seeing what they are building and being able to work on the tooling piece of it.
• 19:20
  [SPEAKER_00]: It was a really strong connection that I found even when I was looking for post-microsoft, which I found out modern with agente tooling.
• 19:27
  [SPEAKER_00]: However, what caught my attention is essentially at Microsoft, I was talking about this concept of a genetic DevOps, something about agents across the software lifecycle, and how humans and agents work together.
• 19:40
  [SPEAKER_00]: Now I get to tell the story of one layer lower.
• 19:44
  [SPEAKER_00]: where we're changing the way how agents are working and we're focusing on helping to see how agents can work with each other and providing tools to change the way they work.
• 19:56
  [SPEAKER_00]: And again, back to, I think no, my favorite buzzword now, deterministic.
• 20:01
  [SPEAKER_00]: Being able to do that for this new audience, which is agents, is super intriguing to me.
• 20:08
  [SPEAKER_00]: And I'm really excited.
• 20:09
  [SPEAKER_00]: I think the other piece I see with just my first few weeks that start up is really exciting to see the passion as well with the people that you work around.
• 20:19
  [SPEAKER_00]: It doesn't feel like work.
• 20:21
  [SPEAKER_00]: It's just like minded people coming together, especially on a category that we're trying to create excellent.
• 20:27
  [SPEAKER_01]: I love all of that.
• 20:30
  [SPEAKER_01]: And it's a really fun ride drawn.
• 20:32
  [SPEAKER_01]: In your journey, who is influenced the way that you work?
• 20:35
  [SPEAKER_01]: You know, it's a little broader and Microsoft and and modern.
• 20:39
  [SPEAKER_01]: Tell me about, you know, maybe a person or many persons or something, you look up to and why.
• 20:43
  [SPEAKER_00]: So, no, if this was not a black cast, and if you saw my camera on, you would see I have some like hostess here, and I think one person that I look up to, and even when I bring into work is Kobe Bryant.
• 20:57
  [SPEAKER_00]: It's not about just his highlights, but what I really like about Kobe is his obsession for his craft.
• 21:05
  [SPEAKER_00]: He does four AM workouts, the film study, the relentless attention to detail.
• 21:13
  [SPEAKER_00]: All of those characteristics is something that I want to bring to within this authentic tooling or agent's world where how do you be a good listener so that you can find the right customer needs and what the industry is looking for and where it's moving a deep understanding of the industry so when it comes to make a decision it's not just speculation.
• 21:35
  [SPEAKER_00]: And in similar, the ability to adapt, just like Kobe, where plays all these different teams, where I'm able to tell a product story to all different types of audiences, from very developer-centric audiences, to CEOs, to
• 21:51
  [SPEAKER_00]: frontline workers because anyone that uses an agent they'll start to experience those pieces like of what we talked about.
• 21:58
  [SPEAKER_00]: And then I think the last part is just the discipline that compounds over time.
• 22:03
  [SPEAKER_00]: That's what separates good product work from great product work.
• 22:07
  [SPEAKER_01]: Totally love the shout out to Kobe.
• 22:09
  [SPEAKER_01]: So
• 22:10
  [SPEAKER_01]: Last question, you've worked at Microsoft for eight years, and you're now transitioning to Moderna, and it's super exciting, you're working on the cutting edge of stuff, and say you're getting on a plane and sitting next to someone who's about to make this same transition.
• 22:24
  [SPEAKER_01]: What advice would you give them?
• 22:25
  [SPEAKER_00]: I mean, the biggest thing I'm learned throughout my career is what's better than just shipping individual features is thinking about it as creating a category and in the world of AI where features are happening in such a rapid pace, all those features actually bolster
• 22:47
  [SPEAKER_00]: So instead of focusing on marketing each of those features, what is that story you're driving and every time you have a new feature, it bolsters it and creates that product truth and makes that story even stronger.
• 23:02
  [SPEAKER_00]: I love that.
• 23:03
  [SPEAKER_01]: I think that's fantastic.
• 23:04
  [SPEAKER_01]: Well Patrick, thank you for being on the show today.
• 23:07
  [SPEAKER_01]: Thank you for telling your creation story heading into modern and all the things that modern is building the right tools for agents, not only tools, but again the buzzword that we both love the deterministic tools, which are incredibly important when it comes to engineering and to AI in general.
• 23:23
  [SPEAKER_01]: And I think the lossless semantic tree is a fantastic and fascinating approach.
• 23:29
  [SPEAKER_01]: Building recipes that drive deterministic transformations, modern fits nicely into this new SDLC that we're all heading in.
• 23:36
  [SPEAKER_01]: That's Agent Driven, so I really appreciate you walking us through that and giving us your story.
• 23:41
  [SPEAKER_01]: Thank you so much.
• 23:44
  [SPEAKER_01]: As we close out today's episode, it's clear that the future of the STLC isn't just about adding more AI, it's about adding the right guardrails.
• 23:53
  [SPEAKER_01]: In an era of agent-driven development, but Dern provides the essential deterministic harness that ensures our move toward automation remains both powerful and predictable.
• 24:04
  [SPEAKER_01]: And proving that a corestone of this shift is building the deterministic tools that engineering teams actually need.
• 24:12
  [SPEAKER_01]: Thanks for tuning in today.
• 24:14
  [SPEAKER_01]: If you'd like to learn more about modern, go to modern.au.
• 24:18
  [SPEAKER_01]: That's m-o-d-e-r-n-e-dot-a-i.
• 24:22
  [SPEAKER_01]: And also check the links in the show notes.
• 24:25
  [SPEAKER_01]: And thanks again for listening.