Before anyone reimagines the software lifecycle for agents, someone has to secure the place all that code lands. Entire CEO Thomas Dohmke, formerly CEO of GitHub, and Apiiro co-founder and CEO Idan Plotnik see the same problem from opposite ends of the pipeline: agents now write, review, test and deploy the code, and nobody reads it.
This week on Dev Interrupted, they join Andrew to argue that the fix is context, injected before the prompt through hooks and captured afterward as session logs committed next to the code. Idan puts numbers on the perfect storm of agents shipping more code as Mythos scans surface 10x the vulnerabilities, while Thomas makes the case that code is the what and the session log is the why. They close the conversation on why every pull request needs a business owner, not just a code owner.
Show Notes
- Entire: https://entire.io/
- Entire CLI (open source): https://github.com/entireio/cli
- Apiiro: https://apiiro.com/
- Apiiro Guardian Agent: https://apiiro.com/blog/introducing-apiiro-guardian-agent/
- JPMorgan's Patchmageddon report: https://privatebank.jpmorgan.com/nam/en/insights/latest-and-featured/eotm/patchmageddon
- Connect with Thomas: LinkedIn | Twitter/X
- Connect with Idan: LinkedIn
Transcript
(Disclaimer: may contain unintentionally confusing, inaccurate and/or amusing transcription errors)
[00:00:00] Andrew Zigler: I'm really stoked because today on Dev Interrupted, we're talking about something that you can't deny, a transformation that's happening within the SDLC, and frankly, we talk about it constantly here on the show.
[00:00:12] Andrew Zigler: I won't shut up about it. And if you're a frequent listener, then you know how much one of the things I opine about is the modern Git forge, and the way that, uh, software is shipped and secured and understood and, and just the way that our software is consumed. And honestly, building something faster and safer are two goals that you can't compromise in today's market.
[00:00:35] Andrew Zigler: And, you know, we've given quite a bit of attention to the mechanisms and mindsets that allow teams to change into this new way of working around both shipping in a Git forge, but then also having hardened real-time defenses as you build software. So needless to say, I'm stoked for today's chat because joining us today are two titans of the industry on [00:01:00] exactly these topics. Yes, we have a Dev Interrupted science fiction double feature in store for you today. In one corner, we have Thomas Domke, the CEO of Entire, the Git forge of the future, which I've brought up a number of times on our show here. And as the former CEO of GitHub, Domke has a unique vantage on where this technology needs to go to meet the challenges of modern agentic development as a team sport.
[00:01:26] Andrew Zigler: And joining him is Idan Plotnik, the CEO and co-founder of Apiiro. And Idan's team is at the forefront of agentic AppSec, having recently shipped their own Guardian agent alongside a full software supply chain control center to enforce proactive cybersecurity for dev teams and their agents. So Thomas and Idan, welcome to Dev Interrupted.
[00:01:49] Thomas Dohmke: Hey, thanks for having us.
[00:01:51] Idan Plotnik: Thank you very much. Uh, what, what an opening. Uh, and I, I, I would just say that there is no such thing as DLC anymore. It's [00:02:00] ADLC, agentic development lifecycle. Everything is agentic across, I think, any company in the world. So
[00:02:06] Andrew Zigler: Absolutely. Now we're gonna be talking about how you change that S into an A and why every other acronym that we're working with these days is getting changed and morphed by all of this technology. And I wanna start by, you know, maybe throwing this first question at you, Thomas, about some of the writings that you had about the technology in the industry and how it's moving from engineering as a craft to a more assembly line model.
[00:02:29] Andrew Zigler: And I'm wondering, you know, where do you think the industry sits right now in this transformation and time?
[00:02:36] Thomas Dohmke: I think it's still very early days, and while it feels like forever ago that, that ChatGPT launched and, uh, and, uh, we started playing with GPT-3 and then GPT-4, um, I, I believe we're still very early in this transformation, and we're all trying to figure it out, um, quite literally, uh, by, by prompting agents, uh, you know, seeing them run. You know, sometimes we're getting [00:03:00] overconfident and, and let, let it run for, for hours or even days on end. And, and then we, uh, it's Monday and we scratch our heads, um, uh, of what it actually produced and, uh, how much, how, how much token got, got wasted. so I think it's early days. Um, it- the, the... especially in, in software development and coding, uh, the world has, you know, changed dramatically in multiple phases, right?
[00:03:20] Thomas Dohmke: We went from auto- autocompletion in 2021, um, to chat in 2023, and then clearly 2025 was the year of agents with Claude Code and Codex and Cursor and of course, um, Copilot agent. and now we're in the middle of 2026 and, and, uh, we have all these agents writing all the code. Um, and now we're asking ourselves the question, how do we review all this?
[00:03:40] Thomas Dohmke: Or do we even review all this? Um, how do we ship this with confidence? And we need to slow down a little bit here and there as well.
[00:03:47] Andrew Zigler: Yeah, I think slowing down and evaluating and understanding the code that we're shipping is a challenge that we're all grappling with. We have this sudden increase in throughput. Everyone's battling these new bottlenecks, especially around [00:04:00] review. There's even bottlenecks around ideation, like the idea of the backlog evaporating.
[00:04:04] Andrew Zigler: There's so many interesting phenomena happening for teams. And Thomas, you noticed that, you noted that we're pretty early in this transformation. But at the same time, you know, Idan, you're talking about an environment where agents are shipping code four times faster, but having been recorded as shipping 10 times the amount of vulnerabilities.
[00:04:23] Andrew Zigler: So we're talking not only about an increased throughput in the code and the supposed impact that we're having for the downstream consumers, but also on the surface area and on the threats. And now we're even further abstracted from finding them. So where do teams tip the balance between productivity and risk?
[00:04:41] Andrew Zigler: What do you see work?
[00:04:43] Idan Plotnik: Yeah. So, so first, I don't think that we can ever stop the train, or it's already gone. Okay? So we cannot, uh, uh, slow down anything, um, at least in, you know, the Fortune 500 companies that we serve. I would call it the perfect [00:05:00] storm. The perfect storm has, on one hand, every company adopted the coding agents, and developers doesn't write, review, test, or deploy the code.
[00:05:12] Idan Plotnik: The agents are doing it. On the other hand, we have another storm, which is called the Mythos storm, where all of our customers, regardless, I literally spend, uh, three days on the roa... in, in the roa... on the road meeting customers, they all scanned their code bases with Mythos or cyber model from OpenAI while they're doing black box testing.
[00:05:35] Idan Plotnik: And then what happen, you are bombarded with more vulnerabilities that you didn't know a-about, and then everything collapse. Like the CISO and the CIO knows or the aha moment happens when they say, " Hey, my AppSec team, we, we're not growing the AppSec team, we're not bringing more people, but now I have 10x more vulnerabilities from Mythos, [00:06:00] from scanning the code, from scanning, running back bl-black box testing.
[00:06:04] Idan Plotnik: What do I do?" And the last thing that I would say, uh, and I will give the credit to JPMorgan, because JPMorgan just released a document called Patchmageddon, and proved in the data that, that the number of zero day exploits that they discovered is much higher than the ability to fix them, and you don't even have a fix.
[00:06:34] Idan Plotnik: So you have a zero day, you know that the, the, that the attacker has this zero day, but you don't have a fix because the open source community didn't fix it fast enough. So I think we are in a real chaos, okay? So, and, and we need both the side of reviewing the code, but also making sure that the code now it's not human.
[00:06:56] Idan Plotnik: Uh, we need to train the, the, the coding agents to [00:07:00] write secure, but also compliant code on every prompt. And this is how we help our customers.
[00:07:06] Andrew Zigler: Yeah. And you basically have said the, the boat has flipped over here, right? The ability for us to catch up on those problems, on those vulnerabilities has escaped us at this point. It's reached a terminal kind of velocity. So how do we protect against this new environment that now encases all of the work that we do? And you're calling out that a lot of that involves shifting practices left, looking further left in terms of understanding how we provide context, how we secure, and in also having the right policies in place that act as guardrails for these agents in this environment, so they can make real time decisions, right? What do you think about that frontier? Like, we all talk about shifting left and security's always moving left. Everything's always moving left. Now there's something even further left, and it's the agent,
[00:07:54] Idan Plotnik: Yeah, I, I, I think...
[00:07:56] Andrew Zigler: the agent
[00:07:57] Idan Plotnik: Yeah, I think Thomas actually, uh, [00:08:00] invented the concept, uh, back then in GitHub, shift left, where y- he put all the scanners and guardrail. The thing here is that you need context, and, and un- unfortunately, context has a, like, it's a double-edged sword. On one hand, it's too generic, and on the other hand, without the context, you cannot actually stop developers, and then you have friction between security and development teams.
[00:08:24] Idan Plotnik: And, and this is what we're, solving to the industry. We're saying we developed a patented technology that understand the software architecture for every change, and we generate risk intelligence on top of the software graph. And then we're able to guide the coding agent, no matter which coding agent you use, okay, anyone, um, based on the organizational specific context of understanding the software architecture and the policies and the risk on top of that.
[00:08:54] Idan Plotnik: And then we have, uh, hooks. We are using hooks like everyone. Uh, hooks [00:09:00] are known, like, um, like now are, are, are standard. Pre-prompt hooks, pre-commit hooks, post-commit hooks,
[00:09:07] Andrew Zigler: hooks.
[00:09:08] Idan Plotnik: all of your hooks. But, but, but, but the secret sauce is, is the context. What do you bring into these hooks? Because it can be the same problem, five years ago, where we tried to stop developers at the pull request, but then we stopped every pull request because we had no context to understand what is a risk to the business and what's not.
[00:09:30] Idan Plotnik: So we use the same data fabric that we built for the last six years, and we inject seamlessly, enrich the prompt with the context that you need. And this now in Fortune 500 companies, proved 81% prevention of vulnerabilities and compliance violations. And the pre-commit hook, we do auto-fix. So our coding agent talks to your coding agent [00:10:00] and auto-fix it before it goes to a, a, to, you know, the new edge of source control manager, which is Entire, okay?
[00:10:11] Idan Plotnik: So you get into Entire or other, uh, solutions clean and compliant code, um, in an agentic way.
[00:10:21] Andrew Zigler: Yes, exactly. It all has to h- be housed somewhere. And great that you're talking about Entire because it's really what, what I wanna shift my attention to in my next question as well, because we're talking about context being the answer. So, you know, we have the king of context here, Thomas, to really fill us in on what that even looks like for the tooling, and where that stuff has to live.
[00:10:40] Andrew Zigler: And one of the things is, like you described, Idan, is understanding, like, the exact fingerprint of the organization and all of its software, getting that fingerprint. That requires a lot of work, a lot of tooling, but then also having it just in time, putting it in the agent's hand when it's needed at the right level of [00:11:00] context, because if you just have a fire hose and point the fire hose at everything, it's not useful. But ultimately, all of that data has to house somewhere, it has to get aggregated. It has to get... It has to live. And there are so many ingredients that go into good context, uh, so much of them around the agent sessions themselves. So Thomas, what do you think about the things that we should be storing and keeping as artifacts over time, and, you know, what in our system right now is so insufficient that's causing this runaway escaping problem of being able to keep up with even security threats?
[00:11:33] Andrew Zigler: What, what do you see?
[00:11:35] Thomas Dohmke: You both already mentioned shift left, which Idan I didn't invent, but certainly we practice it more and more. I think the term also comes from, from analysts. Um, and it is all about, right, that you detect the security vulnerabilities before they reach your production system. and lead to, um, you know, data leakage, or you have to do a press conference and explain, uh, how you lost millions or sometimes hundreds of millions of, of customer records. Um, with, with [00:12:00] AI agents, we've basically went all the way to the left. Um, if you wanna go further left, then you have to sit in my brain, uh, because now I'm using my hands and my, my mouth, my voice, my language, uh, to feed all the ideas in my agent. So there isn't really a further left. There isn't, uh, a step where I have to convert my ideas into, uh, something abstract like code or a diagram anymore, right?
[00:12:24] Thomas Dohmke: I can just type and it starts appearing in front of me. And I think the mind-blowing examples are the one, the one-shot ones where you can just say, uh, you know, "Build me a game," or, "Build me a quick web page," or something, something really com- complex, even, even training a model. That's the transition that has happened and where we are now, and that means that we're actually producing at work are these session logs, the interaction between me and my agent or agents, right?
[00:12:49] Thomas Dohmke: Like, I have multiple, um, some of them are writing code, some are reviewing legal docs. You know, some of them are summarizing my daily podcasts to me or my, my blogs and of [00:13:00] course, um, a lot of them then take all that work and, um, review it and, and, and give me, uh, insights, um, from a security perspective, from a deployment perspective and so on. And one of our thesis at Entire is that, okay, so if that's the work product, um, if that's the thing we're writing every day, um, similar to documents and Slack conversations and so on, then we should also store those logs, and they shouldn't just sit on my computer in some, you know, tilde .Claude or tilde .Codex cache directory. They should be sitting together with the code, um, in the repository. and so that's the f- the first feature that we announced, um, earlier this year in February. Um, with our open source CLI, you can automatically, uh, store, um, your agent logs in the git repository together with your code. And so code, you know, is the what or the how, if you will, and the session logs are the why, and it reflects, you know, my ideas, call it intent, you know.
[00:13:51] Thomas Dohmke: I think most developers never heard of that outside of intents on iPhone and whatnot. Um, from a technical perspective, they didn't thought-- [00:14:00] think about their day as my intent today. It's like my ideas, my, my workload, my, my bug fix requests and all that. all the tool calls, you know, the model reasoning as much as is available.
[00:14:10] Thomas Dohmke: Um, you know, some of the model providers are encrypting that, uh, these, these, um, chain of thought steps as they consider them intellectual property. Um, and of course, the response and the commit into the repository, all that is stored together with the code. And then you can do fun things with those. Um, you can resume a session.
[00:14:27] Thomas Dohmke: You can hand over from one agent to another. It's, you know, some of them have outages, um, or you just wanna move from your Mac Studio to your MacBook, um, uh, on the couch or, um, um, on a, on a plane. Um, or, or the other way around, actually. You have to close your laptop because the TSA is reminding you that it's not the time, you know, to type on your keyboard. Uh, and you wanna hand over to, um, uh, to a computer that, that runs in your office. Um, all the way to using that information as intelligence, um, semantic layer graph and whatever you call the thing that either the agent can use or the human can [00:15:00] use. And, um, we know f- some funny examples of startup founders extracting all the, the most fun prompts and the most fun, uh, agent responses or the shittiest agent responses, and they're presenting them in their town hall meeting. Uh, it's kinda like the joke of the, joke of the week or joke of the month, right? There's a lot of learning from that, both from a, um, entertainment perspective, but really from a, "Okay, so I know what I'm doing." But maybe Idan or Andrew or Stefan have a better way of prompting Claude, um, uh, for, for a- adversarial code review or, you know, to not have it repeat the same mistakes over and over again. So you need long memory. Um, uh, you need, to be able to learn. Uh, the agent needs to be able to learn. Because the ultimate goal from my perspective is now that we can have these agents run, you know, as long as we need them to. And more often than not, that means now hours or nights, and not just three seconds.
[00:15:57] Thomas Dohmke: Um, and I've actually one running here on my, on my, [00:16:00] on my other Mac. Uh, not on this one because on this one because I'm conscious of the task manager, uh, uh, destroying the CPU load.
[00:16:08] Andrew Zigler: on a, mine's on a computer in the back, but it's
[00:16:10] Andrew Zigler: going. I,
[00:16:11] Thomas Dohmke: And I have a little, you know, portrait size display, um, that an agent found for me because I wanted one that is exactly the same size as my studio display, so they are aligned on the top and the bottom, otherwise it irritates me. Um, but
[00:16:23] Andrew Zigler: I got one of those too. Okay, great. Um, we're on the
[00:16:25] Thomas Dohmke: we
[00:16:25] Idan Plotnik: by the way, guys, you, you, you know that you can run the coding agents in the cloud, so, uh, I'm running them so they will not kill my machine
[00:16:33] Thomas Dohmke: that, uh, you can...
[00:16:34] Andrew Zigler: w- more of how my viewports work
[00:16:36] Thomas Dohmke: I, I have it running on a Mac, uh, in, in my office. Um, A, it serves as a heater in the winter. It's a 2019, it's a 2019 Mac Pro. And B, I, I like, uh, the ... I, I hate the latency on, on typing in the cloud. But anyway, um, it doesn't matter. But like the ... My point is I want that agent not to finish while we are recording this podcast. Uh, because if we do, if we do that, then, well, you know, I- Idan, [00:17:00] and I both talk a lot, so I can just wait for Idan to answer something, and then I can type in the meantime really quickly the response. But my point is, you know, you wanna, you wanna have the agent similar to a team member. Um, uh, and certainly as startup, you know, leaders, we, we know that feeling.
[00:17:12] Thomas Dohmke: We want team members to have autonomy, agency, and creativity, uh, until the point when we realize it went too far in a direction that I don't agree with, or spent too much money, uh, that I also don't agree with, or worse, both of those, and you spent, you know, millions of tokens on the model self-optimizing something that plays no role to our business, right?
[00:17:33] Thomas Dohmke: And so how do we make these loops longer? That is, I think, the, the real challenge, uh, and why, why I think, yeah, the, the boat has flipped over and we are living in a, I think to some degree, crazy world and, and a massive code that are being produced. At the same time, we haven't figured it out at all, and we are still so early in the journey.
[00:17:50] Thomas Dohmke: And, um, if you come back here in two, three years, maybe even just in one year,
[00:17:54] Andrew Zigler: Yeah, just a few
[00:17:55] Thomas Dohmke: the way we're working will be, will be, will be very different.
[00:17:59] Andrew Zigler: Absolutely. [00:18:00] And
[00:18:00] Idan Plotnik: just want to complete, complete what, uh, uh, Thomas said on, on two points because I see this on a day-by-day, uh, discussions with CISOs and CIOs. They are saying exactly what Thomas is saying. Uh, we are now-- we gave these coding agents 24/7 tasks, and now we see them reasoning on top of the code bases again and again.
[00:18:24] Idan Plotnik: Now you have a, a, like, problem where you can multiply the coding agent by the, uh, number of changes, by the number of repos, and then you-- every a-agent changes something else in the repo that the other agent needs to know about, and this is exactly what Thomas is saying. If this literally spends... They are spending so much money on things that they can solve with a entire or with, uh, Apiiro on the security side, where we are now giving [00:19:00] the context when you do autofix or prevent, you don't need to reasoning again and again and again.
[00:19:06] Idan Plotnik: And when we compared a task of autofix of a very complex vulnerability on a, on a large monorepo, uh, one query costs $6.10, where in Apiiro, uh, with the data fabric, the same task costs $0.20. And this is a huge cost saving to the customers. The second thing that I wanna touch on, and I, I agree with the intent, uh, uh, point of view, but, but in the large enterprises, what they did, because as you know, everything is regulated, and they need guardrails and yada yada.
[00:19:42] Idan Plotnik: So they actually, uh, using Apiiro to scan the Jira ticket or the GitHub issue that, that a, a, a product manager actually wrote and run a threat model on them before they copy and paste it or give [00:20:00] the agent, um, a way or access to the intent to start the task. Okay? So, uh, we can proactively or continuously run on every Jira ticket or GitHub issue, run a threat model, give the output of the threat model, which are countermeasures to the coding agent, so they can run a more secure and compliant task, uh, uh, in the background.
[00:20:25] Andrew Zigler: Yeah. There's a really interesting kind of paradox happening here where you need to have everything so you can slice it down to exactly what you need, but you can't give everything everything, and you have these situations where, like, things are so expensive, right? And if you just, like, were to work on a monorepo type of level or if you wouldn't, uh, actually look at the specific slices of what you need to do, you get this cognitive burden between all these coordinating sub-agents because you divide them by role-playing ins- like, instead of cognitive locality, right?
[00:20:59] Andrew Zigler: Instead [00:21:00] of an agent that owns end-to-end some mental model that it can keep in its head and reliably work on and deliver, especially for long-running, you know, folks have a, a tendency to split that up into seams to where things are moving between lots of agents. You get onboardings and offboardings and loss of context, and all of this compression is, is lossy. And in order to really fight this, one, you need a place where it all goes so you can understand what's moving and get the shape of it. You need to close the loop because, you know, um, like, uh, uh, Thomas, I love how you called out, like, the idea of, you know, having loops that run on the organization and all of this data and look back at sessions and find learnings and elevate new things, and they become, like, shareable stuff across the company as well.
[00:21:43] Andrew Zigler: And that's actually really exciting for me because that's a macro version of, like, I have a loop like that that runs on my agents with their transcripts, and I get, like, a recap like that at the end of a week, and it helps me catch stuff they didn't catch. I see the instant value of that happening on an [00:22:00] organizational level.
[00:22:00] Andrew Zigler: In order for that to happen, you have to just have all of that context. You have to be able to pivot and, and study it, and then consumers and, um, experts in their domain, like Apiro, can come in, right? And what's this slice of data? What makes the things most secure? How can I coordinate all of this cognitive locality in the safest and expensive way?
[00:22:23] Idan Plotnik: And k- everything that you said and for every change, this is a huge
[00:22:29] Andrew Zigler: yeah, every change. And at the same time, it's like we see the rate of commits. I see my GitHub, you know, commit history thing. Like I see what's happening, and everyone else is on that same page. I'm not special. I open my laptop on Monday, and Claude Code's down for me just like it is for everyone else.
[00:22:45] Andrew Zigler: And
[00:22:45] Idan Plotnik: Afri
[00:22:47] Andrew Zigler: it's like, it's so... Like, this velocity also brings me to my next point, which is I would love to get y'all's vantage on in terms of how developers and product managers have to evolve [00:23:00] for the skills they need to work with this new context. 'Cause I don't know about y'all, but I find myself constantly in a position of explaining this context management and slicing and dicing and making it just in time and understanding the value of how to, uh, compact that information into like a layer that is durable for you and the agent.
[00:23:19] Andrew Zigler: There's so many ways to, to crack that egg, but folks need to be thinking about it. So how do you, you, you create this, uh, you know, an entire... You create this world where literally entirely everything lives, the transcripts and the delivery and everything in between. And but just because that's there doesn't mean people know how to work with it, or they know how to put good stuff in it or pull good insights out of it.
[00:23:39] Andrew Zigler: So where do you think about teaching and, like, getting the, the team to think in this loop-like way on top of all of this data?
[00:23:46] Thomas Dohmke: We were mentioning it earlier when we started the call, uh, we believe we're early in this, uh, journey, and we're going to reinvent the life cycle the way we are working. And you mentioned, um, different roles and companies, um, how do PMs evolve, [00:24:00] designers, um, marketing folks, security analysts. I think they're all going to, be centered around code as the, as the one, uh, thing that we all share, that all our agents produce, right?
[00:24:12] Thomas Dohmke: Um, if you look at, um, Claude, uh, uh, um, or ChatGPT work, Claude Code work and, and ChatGPT work, they're effectively coding agents, um, with a little bit of a layer on top of it, to, to work on your Word files or, um, you know, your, your Gmail or whatever it is, have you. Um, and, and developers figured that out a little bit earlier than everybody else that, you know, just use a coding agent because there's an access to tools and, and APIs and, and all that to, to, um, do, uh, a lot of the things that are outside of coding.
[00:24:40] Thomas Dohmke: And, and obviously that's also true for a marketing manager. And a marketing manager can, uh, produce landing pages, um, process, um, spreadsheets. Um, uh, and so to some degree they have become engineers. Um, uh, same for product managers and designers. Um, today you don't really want your PM, uh, write you a Google Doc, uh, with a, with a [00:25:00] concept, um, or write you a Jira ticket or, or, you know, s- start kind of planning and tracking, which was the first part of the software lifecycle, was always planning and tracking, and then you had to do daily standup to break your epics into user stories, into, into work items.
[00:25:14] Thomas Dohmke: I think that's just a... the long term, that's all going to be a waste of time, uh, because you're producing artifacts that then somebody else copy and pastes into, into a coding agent, then you could have just started with a coding agent to begin with. Um, and, um, if you, uh, actually, you know, look at open source projects, more often than not, now when people report issues in open source projects, they, uh, ask Claude first, um, uh, to analyze, you know, their data issue together with the code base.
[00:25:39] Thomas Dohmke: Um, uh, it- it's open source, you know, uh, uh, have gained another superpower. Uh, it, it can e- because it can use the code base together with your agent and whatever problem, error message and so on that you see to analyze that problem and then give the person reporting it back to much more context on what's happening without necessarily sharing your data.
[00:25:58] Thomas Dohmke: Or, you know, you can [00:26:00] get, you know, a step further and have it create a pull request, um, or a change request, um, uh, uh, where you already made a modification to the code base. And I think we should, you know, many developers have that certainly as like the, the, it... Everything needs to be perfect. You know, we were so skeptical of self-driving cars because every time you talk with somebody about self-driving cars a few years ago, they were all like, "But what if?" On the left turn, something unexpected happens, right? And, and then it, it, it, it rains like crazy here in Seattle, and then it can't do this. And like, yeah, but how often does it actually happen in your, in your, in your day-to-day? And so it's ... You're much better off if, um, you know, you're, you're planning for the 90% case.
[00:26:38] Thomas Dohmke: Um, and that also means the 10% that are the hardest part still requires, uh, engi- engineers in the organization. And I don't think we will see organizations where a PM or PMMM roles are driving the whole, uh, uh, uh, you know, ship or whatever. Uh, but certainly we will, we will see more organizations where everybody, uh, is a creator.
[00:26:58] Thomas Dohmke: Uh, everybody can [00:27:00] produce an artifact within the company that, uh, lives in the same, in the same space, um, and, and ultimately results, results in coding. And then if you, you know, believe in that future, then obviously now you have, uh, a very different, uh, software de- development life cycle that you've had before.
[00:27:17] Thomas Dohmke: One that is much more collapsed i- into, into loops, right? Multiple of, of these loops. And, and then some are short running and some are long running, and we have to figure out, um, we get value out of the long running loops, um, uh, and, and basically decide at the beginning of the loop, how long should it run? What are my evals? Uh, at what point do I wanna, wanna interrupt? Because what we're seeing in 2026 is that our confidence level, uh, our excitement level goes really high if something works well, And I get excited and it's like, okay, now I can, uh, now I can keep, keep you running. And, um, so much, uh, uh, uh, text and, and, and output is produced that I
[00:27:57] Thomas Dohmke: E- especially when you have multiple terminals open or [00:28:00] multiple threads in, in, in the Codex app, that you very quickly lose all the context, um, uh, and you're, you're not able to catch up. And if you're working on three or four projects at the same time, it's even worse. And, and so we also gotta accept that we don't have that knowledge anymore of how every single line of code worked. But if we're honest, that was also never the case. Uh, we were just pretending, uh, on the ever-growing code basis. I'm sure, um, Idan cannot earnest on a Friday afternoon do a code review that ships to production tonight, uh, a- and, and confirm, "I found all the bugs." Um, and so I think that's the, the road we have to think about and what, what engineering, uh, looks like.
[00:28:40] Idan Plotnik: This is like spot on, and I want to take exactly what, uh, Thomas said to the security world. Now you are unable to, like, go and identify the vulnerabilities because the developer didn't, didn't write the code. So if it, they didn't write the [00:29:00] code, they are unable to review the code and identify the vulnerabilities.
[00:29:03] Idan Plotnik: So the vulnerabilities today, we s- we see a, a, a shift from the traditional OWASP Top 10, the legacy SQL injection and things like that, to a much, much, much more complicated business logic vulnerabilities. And if you're not providing the context early on in the pre-prompt, uh, hook, you're unable to do a code review or, or, or, or you're unable to prevent these vulnerabilities in, in the first place.
[00:29:34] Idan Plotnik: So I'm just saying it's the same problem to different use cases. Developers doesn't write the code, developers doesn't review, doesn't test, doesn't deploy, and it means more risks getting in. And I would just say one last thing to, to this point between product managers and, and developers. I think, and again, in the, in the prisma of, of security. [00:30:00] The spec driven design now needs to, to embed all the security and requirements in whatever the spec is, which is not a document anymore, okay?
[00:30:12] Idan Plotnik: As, as, as Thomas said, and, and this is the new agentic development life cycle, where everything driven from the intent directly to the coding agent, and you need to inject all this context that, that Thomas was talking about, but also, um, the organizational security and compliance policies in.
[00:30:30] Andrew Zigler: You hear that? Like Idanis begging y'all listeners to put the security requirements, the security vulnerability, like the things about security into the spec. Spec, it needs to be at the beginning. You can't tack it on at the end. If you do that mindset, then you're, uh, fixing every loop that's running, all of these little loops that are shipping our
[00:30:48] Idan Plotnik: Yeah.
[00:30:49] Andrew Zigler: So
[00:30:49] Idan Plotnik: b- both Thomas and I are coming from Microsoft. Uh, I also sold my company to Microsoft, and, and I felt the challenge of [00:31:00] going and filling as a GM for filling up questionnaires before delivering to production. Thomas, uh, I don't think you had these, this problem because you had a different pipeline, but in my case, I suffered, and I have a lot of scars on my back at 2:00 AM in the morning, and I need a rubber stamp for someone that never review our code to approve that what I, uh, wrote in the questionnaires are actually true, which is like today, it's a waste of time and no one should do that.
[00:31:32] Idan Plotnik: No one, no one. No matter if you're a bank or you're... If you're Google or Microsoft, you should n- never do that.
[00:31:39] Thomas Dohmke: I think we also have to be real, right? Like, there's an ideal state of how the life cycle works and that you start with all these things first. And, face it, um, with or without agent, um, we have a hard time expressing what we actually want. Um, uh, I'm spec driven development.
[00:31:54] Thomas Dohmke: Idan alluded to it, um, uh, between the lines. I, I'm not I, I don't think we head [00:32:00] into a world where we have all writing specs, um, a- and then the specs are so perfect that the agent can implement this because that never worked when the human was, um, uh, the other, you know, the part of our team, the human engineers were implementing it, and it certainly doesn't work with agents and, um, a lot of the plans are actually now generated by agents.
[00:32:14] Thomas Dohmke: And you look at this and it's like 10 pages of wall of text in front of you. You're like, "Yeah, it looks good, you know. Let's build this," because you know you can always iterate on this faster. That's what we all learned when we started coding, uh, that software ... 'Cause the cost of producing software is, is so marginally low, uh, you can always go and fix it later.
[00:32:32] Thomas Dohmke: And the same is true for security. You know, when we talk about shift left, we mean before we deploy to production. Uh, but if I have a great idea, it's Friday afternoon, uh, I, I don't start with, you know, uh, opening a ticket or starting a pull request or a trail or loop or whatever. I open my agent and say, "Hey, I, I want this," and build me a quick prototype.
[00:32:53] Thomas Dohmke: And then by the time it's Monday, that prototype has evolved in, uh, 20,000 lines of code. And long as [00:33:00] I then, you know, get into the phase of, okay, let's have, um, Apiiro or, uh, Mythos or whatever it is, review that code, um, and make sure my request is draft first and all that, I think, I, I think we're still fine.
[00:33:14] Thomas Dohmke: And, um, we found For me, I found the the joy in, in, in coding again, uh, because now I can do a lot of things on the side, um, uh, without, you know, figuring out how to install Python 3 and Pygame and all, all, you know, the dependencies and all the challenges that we had pre- before when we had side projects.
[00:33:33] Thomas Dohmke: Every, every Sunday you spent more time on updating your dev environment, um, and figuring out what I did last Sunday. Uh, now on Sunday you can just reopen the session and everything still works, and if not, the agent knows it from the entire session log on how to do these things.
[00:33:47] Andrew Zigler: Yeah, and you can have this... Your ability to explore projects is only limited by your fluency and expressing your curiosity and having, you know, the whole thing you mentioned about the 12-page markdown file where it's like, oh, [00:34:00] there's the spec and they wanna build it. I have... We could go down a whole rabbit hole with that because I couldn't agree more.
[00:34:05] Andrew Zigler: I talk about a lot on the show about how that's just, like, not the way, uh, but also around using the power, like the graph, breaking that down into more graph-like forms that allow agents to move through it in a directed, uh, way to get just the slices of context, right? And it's like those little habits are so transformational and can only happen in environments like that Entire provides, right?
[00:34:26] Thomas Dohmke: Yep
[00:34:27] Andrew Zigler: there's another problem that y'all both called out that I, I want to spend a little... I wanna spend a moment on, and you talk about ownership in this process, and I think that's a huge deal, and it's something that a lot
[00:34:37] Idan Plotnik: huge
[00:34:37] Andrew Zigler: are struggling with. There g- there's an abstraction where engineers who used to be like, "I, I..."
[00:34:42] Andrew Zigler: They would call themselves like, "I am a TypeScript developer. I'm a Java developer. I write Kotlin." Like, the, that kind of identity has been shed away. Everyone is now managers of agents and their decisions. Uh, but with that also too just becomes a, an abstraction from the work that you're shipping and delivering.
[00:34:59] Andrew Zigler: You're spending less [00:35:00] time reading the code. Hell, you're even spending less time now reading the plans. Like, and so you're so removed that, um, what happens is actually this is something we saw at LinearB. We had, uh, an update to our benchmarks for 2026. looked at, like, 2.7 million pull requests since the beginning of this year, and we split them into cohorts, like human only, AI assisted, and then, like, fully agentic PRs.
[00:35:24] Andrew Zigler: Like, what happened to them? And you see this, uh, huge rate where the agentic PRs, there's a big volume of them, and then they hit a, a stage of, like, review or merge, and they just linger and they sit, and you get upwards of, like, 70% of these agentic PRs just still sitting, waiting to be reviewed or merged, or maybe they're not even relevant. So, and a lot of that is because there's no owner. There's no, there's no person who's, who kicked that off necessarily owns the task. There's no one hopping into someone's Slack channel being like, "Idan, can you please review my PR?" And you're like, "Oh, it looks good to me." And then, like, "We're [00:36:00] really, we're really excited to ship it."
[00:36:02] Andrew Zigler: Like, that's not happening anymore, so what does ownership look like now for engineers?
[00:36:07] Thomas Dohmke: I, I would love to see the statistics of how many human-generated PRs are also sitting, uh, there for a long time and never get merged. Um, uh, c- certainly for, for GitHub Issues, um, if you, if you look at an open source project that you haven't seen before, uh, y- stars is one metric, um, uh, I think, you know, you, uh, as, as, like, popularity, um, often is also a vanity metric.
[00:36:29] Thomas Dohmke: I think you're looking at, like, when was the last commit? Um, you're reading the README, and then you're, you're seeing issues and pull requests and just to kinda t- correlate all these numbers to figure out is the project healthy or not. Um, but the more and the popular, um, and bigger, uh, an open source project is, the more you have both issues and open pull requests that, that never get merged.
[00:36:46] Thomas Dohmke: Um, and if I just look at our own stuff, um- Sure, we could just close all the old stuff. Um, and often that's a bit like in Slack or in Discord, you know, uh, Shift + Escape marks everything as read. Sometimes that's the best way [00:37:00] of, uh, being productive today instead of trying to figure out every channel, is there something relevant for me?
[00:37:03] Thomas Dohmke: Do I have to respond? And just see who comes back to you and, uh, and has a follow-up question. I was like, "Ping Thomas, uh, uh, you, you never responded to the question I had for you." so th- I think that's number one. Like, we, we already lived in a world where we waited for pull request review and, um, in the beginning, I think in the pre-show, we talked about being remote and being across time zones.
[00:37:21] Thomas Dohmke: Um, the folks in, uh, that work between Israel and US West Coast or Australia and, and Europe know exactly what that is like. That the person reviewing my pull request is in a different time zone and has different holidays and all that, and I keep waiting and waiting. And what we do is we use our social capital and, and ping the person in, in our company, uh, company chat to get it resolved.
[00:37:40] Thomas Dohmke: There is no... Ownership is certainly a problem, I, I agree with you on that. But I think that's a part of the problem, uh, that, that is much bigger, which is the, uh, we, we are used to human-to-human collaboration, and we solve human-to-human problems by talking, uh, or chatting, or, or we're also living in a world where sometimes it's just better to grab the phone and, and [00:38:00] place a quick phone call because voice and the way you're saying things, um, it's, it's easier to transport in a call than, than on a, on a chat or, or vice versa.
[00:38:08] Thomas Dohmke: Uh, especially when, when English is not your first language, um, it, it goes both ways. But, uh, in the agent-to-agent world or the agent-to-human world, um, we haven't really figured that out. And, um, we went through, you know, the last year we went through like a phase of, you saw, um, Daniel from, uh, from Curl as an example saying, "I get all this AI slop now on pull requests."
[00:38:28] Thomas Dohmke: And I think in the last six months you saw a bunch of maintainers saying the opposite, which is, uh, pull requests have, have gotten really good and it solved, uh, a number of, um, CV, uh, CVEs or, or other issues, um, uh, that have been re- reported effectively by AI. Um, often it's a human taking the AI pen test result and, and gives us, gives this to you. Um, but the amount of stuff that AI is, uh, finding and fixing for us, um, uh, uh, is, has gone up so much and the quality equally with it, that I don't [00:39:00] think we can pretend anymore that, uh, uh, AI is not actually helping us, um, with the, with the progress in those, in those projects. And so then you have all these pull requests and I see Idan wants to talk.
[00:39:10] Thomas Dohmke: But you have all these pull requests,
[00:39:11] Idan Plotnik: Yeah.
[00:39:12] Thomas Dohmke: so how do you go through all of them, uh, and not leave them open and, and basically, uh, uh, get exactly what you were describing, which is, um, 70% of them stay open, uh, just like before 70% of security findings stayed open because nobody wanted to go, go, go through those long lists?
[00:39:26] Idan Plotnik: I have two things to say. One is that we, uh, we see an, a very, very unique trend right now because we provided the open source community our autofix with the context that we have, and we've seen the data that because we provide them a certainty score, and we run the tests for them, and all the, the low, medium, um, im- potential impact are merged automatically.
[00:39:53] Idan Plotnik: They have a rule mer- if, if PURE autofix it, then merge it automatically, and it [00:40:00] reduces the number of pull requests dramatically. But on the other hand, I wanna say that when you said ownership, uh, I thought about totally different thing, okay? What we did in our data analysis across the Fortune 500 companies that we have is we wanted to see, because we scan every PR as well, but we scan it from a different point of view, okay?
[00:40:23] Idan Plotnik: And we saw that the number of components, meaning restful APIs, um, um, microservices or code modules, um, open source dependencies, usage of internal dependencies grew in over 1,000% because the coding agent are actually adding more and more and more, and no one actually saying, "Hey, is this is... Do we need this API or not?"
[00:40:50] Idan Plotnik: How it's connected to ownership, if you don't have an ownership of a code component or a code module or a service, then [00:41:00] the pull request that is tied to it has no code owner, okay? And it's the coding agent. What, what I'm trying to say is that at the end of the day, if you have a business owner that cares about this functionality because we need to close a $10 million deal with a customer, okay?
[00:41:21] Idan Plotnik: Believe me, even if it's not a human and an agent wrote it, someone will merge the PR because I will go to the team leader and say, "Hey, Thomas, what's going on with that? We have a deadline, and we need to deliver this feature to the customer," or, "We have a critical CV that we must fix. This pull request sits for three days.
[00:41:41] Idan Plotnik: Go and whatever. I don't, I don't care what you will do with that. I want it in production." Um, so, so, so we see that if there is an business owner to this PR, things will happen. Okay?
[00:41:56] Andrew Zigler: Yeah. No, and I,
[00:41:57] Idan Plotnik: Does this make sense?
[00:41:58] Andrew Zigler: No, it does make sense that [00:42:00] it's really less about the idea of the individual attributed person for the code getting through the code race. We're, we're talking about the owner for what is the deliverable, what's the impact of that goal, and, and that is something where the ownership doesn't get abstracted.
[00:42:16] Andrew Zigler: And you solve that with two things, or you solve it by acknowledging one important thing, and that's what Thomas said around social currency, around that being the currency of the past, the way that we would transact and get these things done. You need to solve them now with mechanics, with, with things that understand and can get these certainty scores, like you said, or otherwise be able to instrument and mechanically, uh, assist the agents.
[00:42:41] Andrew Zigler: All of like, I find my most successful loops, and anyone who really experiments with loops understands that a prime ingredient of making a core loop is having the mechanics and the machinations around the loop to support it, and watch when it stalls. And just you have to understand that you have to abstract [00:43:00] from that intelligence running inside of it to control it.
[00:43:02] Andrew Zigler: And the same is, the same is true here. You have to still have that owner, um, across that whole process. And I just wanna ... You know, we're coming up on our time here, and there's honestly so many topics that we could keep down exploring, and this, this topic is only just gonna continue to expand, so we're just gonna have to have both of y'all back in the future to keep chewing on this.
[00:43:20] Andrew Zigler: But, uh, there's one last thing I wanted to ask y'all, and just from your perspectives, as teams are adopting and using these tools and shipping more code, and we have all of these problems and possible playbooks that we've identified today, I think there's a ton to unpack here. What, what do you think is the strategy for engineering leaders right now?
[00:43:37] Andrew Zigler: We get this asked, asked this question a lot by our audience about how do they talk to their leaders, their CFO about proving the ROI from their AI adoption and these toolings and, and how they're shipping software?
[00:43:49] Idan Plotnik: Thomas, you wanna start?
[00:43:50] Thomas Dohmke: No, you go first.
[00:43:51] Idan Plotnik: okay, okay. I, I have a very clear ... Again, re-reminder, I'm coming from the point of view of the CISO and, uh, [00:44:00] eventually the CIO. So we are-- we have a very clear playbook on how to go to the CFO, and we are saying the following. Let's talk for a second about Autofix. Autofix, for us, in our pricing model, is fixed up to $4 per fix, okay?
[00:44:18] Idan Plotnik: Between 0.2 to $4 per fix, okay? It's ... You pay us for ACUs. We are going back because we have all the data across the history, and we are saying, "Hey, in your organization in the last year, your backlog grow in 79%," and we saw an average that it takes you to fix a vulnerability four hours. Four hours of, uh, like two hours triage, two hours, um, uh, fix and test.
[00:44:48] Idan Plotnik: You calculate that, and you get to, on average, $78 for a vulnerability. So we go to the CFO, and we say, "It's not only that we reduce the [00:45:00] cost by 100%, we actually reduce the risk because we fixed much more in a short period of time in less amount of, time and money eventually that it cost you to do that."
[00:45:16] Idan Plotnik: So this is Autofix. Prevent is a totally different beast because, uh, like we have the Guardian Autofix and Guardian Prevent. Guardian Prevent, actually, we prove, we run a POC, and we say, "Okay, run these 10 prompts without the Guardian Prevent. Run these 10 prompts with the Guardian Prevent." We show that without, uh
[00:45:39] Idan Plotnik: You pr- you, uh, generate much more vulnerabilities. And then we say to you, how much time it take you to fix or prioritize, fix, and test these vulnerabilities. And on average, we, um, prevent 80% of these vulnerabilities, and then you translate that to money. Uh, now we are working, uh, [00:46:00] I'm, I'm cannot share too much information about that, but in, in high level, we're working on Apiiro Pro- uh, Guardian Protect, which actually protect the coding agents from attacks, okay?
[00:46:12] Idan Plotnik: And there it's not, you know, all the discussion with the CFO, they don't care about the, the how much money you save them. You actually sh- need to prove them that you blocked the, the attack on the coding agent, and then they're able to, uh, actually close the deal. And I wanna say that we literally this week closed the deal, um, on, on an MVP, okay, for the Guardian, uh, Protect.
[00:46:37] Idan Plotnik: And I, I hope this makes sense, like how we
[00:46:40] Andrew Zigler: it makes
[00:46:40] Idan Plotnik: prove to the SL-
[00:46:41] Andrew Zigler: sense. I lo- I love that you like, you got, you got out like the whiteboard and you were like, "And here's the math and here, and then here's how much it would cost." Like,
[00:46:47] Idan Plotnik: And we have a simulator
[00:46:49] Andrew Zigler: that was worth A+, one of the best explanations of how it works from your perspective. And that's, and that's for, that's for vulnerabilities, that's for the proactivity.
[00:46:57] Andrew Zigler: You, you get the kind of like weigh the [00:47:00] costs on both what it's gonna save you by like, oh, I, I spotted this so early, but then also just how efficient the process is. What about in an open-ended problem? Like Thomas, maybe turning this to you, like when you're building a very open-ended surface as your software
[00:47:13] Thomas Dohmke: If you look at engineering teams of, you know, startup product teams, um, I think there have, has always been kind of like the three Types of features you can build. Idan is in this first category, which is y- you're fixing security vulnerabilities while protecting against those, um, because they're ultimately undermining your customer trust, um, and probably promises that you have made, um, to, to certain customers, you know, from a certification perspective and all these kind of things.
[00:47:39] Thomas Dohmke: And if you lose customer trust, you're not going to close deals. And so that is part of the fundamentals, right? Av- availability is in the same category, uh, uh, data residency, all these kind of things. And the challenge has always been is how much time do I allocate to that bucket of work over the ones that are more fun? Uh, that's the one that I think most people don't wanna work on if, if [00:48:00] they get to, you know, choose what to do and prioritize this week. If you think about, um, joining a hackathon, uh, the first thing you're not going to do is I wanna say fix security vulnerabilities, uh, i- in a project I haven't even written, right? The, the second bucket is, um, the, where you have clear signal from your customers, um, and you'll land a deal if you ship that feature. Also, quite easy to say, "Okay, this takes us this amount of time, and it lands us this size of deal," and somebody can predict there's 10 more deals and, um, and so let's build this.
[00:48:29] Thomas Dohmke: Uh, let's pri- hi- prioritize this. And then, you know, if you actually look, and Idan allude to this from a security perspective, but it's obviously also true for features that you're building. While we have a long... or we can have another podcast about tokenmaxxing all that, the truth is also if you look at cost, um, uh, per line of code written, um, the a- the agent can do that much cheaper, uh, than a human can, even when you, when you loop, um, and, and you do that, uh, you know, multiple times. Um, and, um, when you, when you see the numbers out there, for example, Gergley, [00:49:00] the pragmatic engineer, where the m- budgets are in certain companies that he's talking to, we're talking 500 or 1,000 or maybe 1,500 a month. That is still just a, you know, small percentage of, of my engineering salaries. And I think some of these companies have the problem that effectively they hired 1,000 interns.
[00:49:17] Thomas Dohmke: Those are the agents. Uh, and now they had all these head, all this headcount without actually having a clear definition what they're working on. And then they... somebody realized, "Shit, we are paying now 1,000 interns, and they're not actually bringing anything big back other than, uh, uh, pursuing side quests."
[00:49:31] Thomas Dohmke: And that brings me to the third bucket, and that has always been the challenge, you know. What feature am I building that is future revenue, but I don't have the clear signal yet? And in startups, um, you're constrained by, uh, uh, your runway effectively, right? Like, you have only a certain amount of runway and people that you can hire.
[00:49:48] Thomas Dohmke: And so the best startups are the ones that are utterly focused on a few of these main quests, maybe they give their employees 10 or 20% time for side quests, but that's it. And agents are no different. [00:50:00] Um, you cannot make the side quests that the a- agents are following, uh, all of a sudden 90% of your, uh, uh, token budget. Um, then, then that's the problem, right? You're basically allowing these agents to build stuff that are not part of the area that you're focusing on, that you have prioritized. And so that is now the time, uh, that is now the thing that we should spend time every day is what are our main quests, what are our prio- priorities, um, what do we think, you know, aligns with our strategy, um, uh, uh, and where we wanna go as a company or a team, and what are our side quests?
[00:50:32] Thomas Dohmke: And, and I think the side quests need to have a constrained time and, and, and token budget. And the, and the main quest you have to then ultimately measure against the, the future revenue growth that you're predicting. And, uh, and hopefully, uh, you know, you run your company in such a way that at some point you can backwards...
[00:50:47] Thomas Dohmke: look backwards and, and, and see that, yeah, you know, we built these features and they worked out or, or what startups do, they pivot a- and they move, they move somewhere else. And so I think that's how, uh, engineering leaders and, and managers and, and, product managers have to think about [00:51:00] that. But we said that multiple times.
[00:51:02] Thomas Dohmke: That hasn't actually changed to how we did it before. Except before we were very constrained by headcount. And
[00:51:09] Andrew Zigler: Right
[00:51:09] Thomas Dohmke: the headcount kind of like got removed, except it's of course still there that because we're running our companies as businesses that
[00:51:15] Andrew Zigler: still happening, same conversation. We're just focusing on a different constraint, a different
[00:51:19] Andrew Zigler: part of this conversation
[00:51:21] Thomas Dohmke: got much easier to hire people because you kind of spin up an agent, um, that the most complicated part was to buy, buy a Mac Mini in, in April or so. Um, but other than that, it's so easy to spin up more and more processes that all earn good money. And so we have to go back to, okay, we're running a business. We wanna make revenue. We have expenses, and hopefully at some point we have a margin, uh, that is positive. And what are the priorities and what are not, and what do we spend our time on and, and whatnot. Um, but I, you know, tell... end that on a, on a positive note, um, all that has become much more fun and exciting, I think.
[00:51:55] Thomas Dohmke: That's, that's at least my takeaway from the last six months. Yep, there's new challenges. Um, I think those [00:52:00] challenges give us confidence that we will have jobs in, in 5 and 10 years, and that we will have, um, uh, challenges and opportunities in our companies. But, um, creativity, um, autonomy, agency has been, you know, 10x'd, uh, for, for many of us.
[00:52:15] Thomas Dohmke: And if not, then let's figure that out of how we can make that possible for the next generation of developers of like how can, how can they enjoy coding as much as we did when we... I started on a Commodore 64, uh, uh, or, you know, some of you probably on a PC, uh, uh, and, and, and, and have that same, ah, it appears, something appears in front of me, and I was, I was the Iron Man or Superman that, that created it.
[00:52:37] Andrew Zigler: Amazing. Well, this has been a fantastic chat. We've dove into so much in this conversation that we're just gonna have to unpack it again in a future one. And we're gonna include links for both of y'all's, uh, websites and, and, or the platforms y'all are building for Entire and Apiiro. Make sure everyone knows the best places to go and continue y'all's stories.
[00:52:56] Andrew Zigler: And if you've been listening and you've made it this far, then clearly you're obsessed with this [00:53:00] conversation too. Please come find us on drop us a comment. We're gonna be posting the, an accompanying, uh, newsletter for this on LinkedIn and Substack. And to think we almost made it through a recording, y'all, where we didn't say tokenmaxxing.
[00:53:13] Andrew Zigler: I promise it will happen eventually, but not this time. And that's it for this week's Dev Interrupted. See you next time. And Thomas and Idan, thanks again for joining me
[00:53:22] Idan Plotnik: Thank you. Thank you very much for having me.
[00:53:24] Thomas Dohmke: See you next time.
[00:53:24] Andrew Zigler: Thank you.
