#51 – Stop Fixing the Car. Fix the Factory: The Future of Software Development with Guy Podjarny

Listen on
About this Episode
Tessl founder and CEO Guy Podjarny joins Dash0’s Mirko Novakovic to explain why AI coding is only the beginning of a much bigger shift: from developers writing code to teams building software factories that can learn and improve themselves. They dig into how Tessl uses skills, evals, and production feedback to make that possible, and why Guy believes hand-written production code is ultimately going away.
Transcription
Hello everybody. My name is Mirko Novakovic. I am co-founder and CEO of Dash0 and welcome to Code RED. Code because we are talking about code and RED stands for requests, errors and duration, the core metrics of observability. On this podcast, you will hear from leaders around our industry about what they are building, what's next in observability, and what you can do today to avoid your next outage. Hi everyone. Today my guest is Guy Podjarny. Guy is the founder and CEO of Tessl, a platform helping teams to build and govern AI native software factories. He previously founded Snyk, which he scaled into 8 billion valuation, and Blaze, which was acquired by Akamai, where he later served as CTO.
Now he's building Tessl which has raised a total of 125 million I think as the third round to shape the next generation of software development. Excited to have you here guy. Welcome to Code RED. Uh thanks great to be here on the I love uh many years later. I still love the German pronunciation of Snyk. You know like the sort of the term of how do you pronounce Snyk has been like our second top support call at Snyk for a good while and for a while on it and I think there was like elements for anyone coming from a German background.
Yeah. Yeah. That comes to that. It's one of the many ways that people pronounce the company name. Snyk. Snyk. Okay. It's It's all good. Yeah. This could take up the whole episode over here. We can continue. Okay. But we always start with the first question, which is what was your biggest Code RED moment in your career? I I think like gave you a bit of a heads up on this meeting on end. I feel like my mind went not to sort of an incident so much as like a but sort of a tough moment in the founder journey of like is this about to blow up on it?
I had so about a year and a half into into Snyk's uh journey we had a lot of uh so Snyk for those who don't know it's sort of a developer security platform the whole ethos was we get developers like build a developer tooling company that tackle security build a dev tool that they will use that happens to to help them secure their their libraries at the time and we got a good number of dev users at the time but very poor number of payers to it and and so in December kind of November December of 2016 usage on who the sort of inbound of VCs that come in and wanted to preempt the next round and invest ahead of the readiness and I was sort of this even though it was my second company felt fairly naive around it got absorbed and sort of leaned into all of them like picked behind the curtain and saw there's no revenue and sort of said uh oh we'd like to be in touch you know and uh you know come come talk to us later and uh and already was kind of in the sort of failure mode and then actually literally the same day I got the I think maybe only offer that I got kind of during that round uh But we also get news that my father-in-law passed away and so we packed our bags and we flew over to Israel, you know, we're from where my uh where he was and he passed away on it and we did it.
So to me the the kind of the Code RED element to it was like for me that was a okay things are are basically imploding you know how do we do we do there uh and and and I think I think probably like the most like a disaster moment that sort of you know felt uh to me you know it was over the Christmas break and you know kind of recovered a little bit from it and persisted in and then Snyk happened after which you know it grew and sort of blew blew past it but I feel like that was probably like the most like red alert to it.
I've had a whole my own share of outages and and the likes which feel less existential that moment as that one. Yeah. But then you learned your lessons, right? Because now you raised 125 million round also without low revenue, right? Very early. Uh we we we I raised it pre-revenue and uh yeah, I mean it helps. This is probably like doubly true in the AI era on it. But it uh it helps when it's your third company and the second hand was uh was Snyk. I think there's a it's easier for investors to sort of feel like it's a it's credible.
You have a decent chance of doing it. I will say that we are I still treat it as a as two rounds in one. And I feel still spending our seed money which is the 20% of that uh and kind of responsible and and kind of building building from it. So, we're not maybe maybe even unfortunately we didn't blow it all on GPUs, you know, which actually might have been the better investment a year and a half ago, but uh yeah, let's talk about Snyk because I I I remember I don't know when it was but when I I mean you are an angel investor in Dash0 and I think when we talked that was when I founded like in 23 you were already fully into AI.
I was not at the time. I remember that you were telling me, oh, everything will change, right? AI native. You have to think uh the thing from scratch and you told me that at Snyk you had this workshop where you started thinking about how to change everything AI native and what that means, right? And then somehow I think in that process you decided to step out and start Tessl because you probably got so excited about it that you said, "Hey, I need to be in the middle of that coding AI wave." Yeah. So, so, so yeah, so Snyk uh maybe like a little bit of context.
I started a bit before on it, but a bit of context on Snyk is so we, you know, we indeed set out to sort of build a developer tooling company that tackles security. And the core premise was we want to bring security closer to where software is produced, you know, like developers are building software, right? They're sort of they're coding it. And as we embraced DevOps, so the the previous what what felt very fast, you know, when DevOps was uh was introduced, uh as we built uh applications faster and faster, security just could not keep up.
And so we had to really embed security into the software development process and that required convincing developers to uh to use security products and a lot of that was around kind of earning the right if you will to be on a developer's desktop right like build a dev tool that is worthy of its space you know amidst to these other dev tools and incentivizes and helps developers like along kind of their reality and their sort of incentives and such build secure software. And so we so that journey was was already about speed, you know, of sort of software creation and and how do we how do we sort of integrate security into that and you know a couple years of wandering in the desert with some near-death moments uh in the process of it and then it took off and grew substantially.
And I think when when AI came along, it felt very obvious to me that security not so much security but like the development will transform and that it will switch from revolving around code to revolving around intent. you know what is it they want to build and the agents will do that for you and I think about four years ago now wrote a little article called uh the the rise of the open source product manager you know sort of envisioning uh how product uh in open source will will just be like described and I think it was a bit premature in terms of like LLM competence at the time on it so took a while but I got really absorbed uh with that concept I think on the Snyk side it led to a lot of uh kind of investing in sort of just building core AI I capabilities and leaning into it.
But what was also obvious is that doing all of that like in a digital transformation uh context is a lot slower. uh and I just got entirely absorbed into what would software development look like in uh in this era until I I fell in love and went to found Tessl and and and in Tessl we'll probably talk a little bit more about so software factories and such but fundamentally Tessl's uh reason for existence is this this belief that there's a new development paradigm forming that revolves around intent uh today we can say that it's about moving from building the car to building the factory right you where you're going from having a human in every kind of assembly point or point in the assembly line into a place in which the developer is the supervisor of a bunch of bots, a bunch of AI agents that are that are building it.
Um, and and and this is like a delegation exercise and a lot of that delegation as as I guess kind of experienced managers like yourself and and me and many of the listeners I'm sure know is really about sort of defining what it is that you want to do, how it is that you're going to verify correct work and what are the kind of guard rails you know that you need to have in place. So what we try to build in Tessl is is not just like on one hand we're sort of helping uh we have AI native there which is a community for sort of sharing learning around this and you know saying how do people how are people kind of thinking about this and and embracing it and sort of building uh the sort of new practice a new paradigm.
We think the paradigm is mostly about people and then from a product perspective we're building kind of the sort of software factory platform that allows you to build a kind of skill centric uh software development process that starts by you defining what it is that you want and then helps with the kind of process of of assembling that into a a repeatable process for producing software. Yeah. And and and you are eating your own dog food, right? you you say that 75% today of your pull requests are only are not or without human intervention on the code anymore right and and running completely autonomous in cases right so how did you get there I mean we are not there yet we we are building Darkplane as you know which we say is the control plane of the dark factory which is like the thing we see in the future we we more give you insights in how the factory works to give you more feedback and and KPIs to automate things, but you seem to be way ahead of a lot of the current development organizations we are seeing.
So, how did you get there? I got to say like I'm super excited about how we're building. I I feel like within the dev world, there's there's sort of those who focus on the craft. It's like I really like the sort of the clean architecture of the code, which I I like I appreciate, but there's those that I fill in that kind that are much more focused on the impact on this ability to bring an idea to life. and and so just sort of love how we're sort of building inside and how we're sort of enabling customers to build and it's very much around the sort of sort of increasingly autonomous software factory.
So actually I checked the stats from the last few weeks on it. It's 81% of our PRs get merged. It's sort of the sort of interesting question about what does it mean without human intervention. Uh so I think primarily for compliance reasons right now there's a whole bunch of changes where just there needs to be a human blessing it. But even then many of these sort of people on the team would would have used agents to sort of ask their questions and define those and they just sort of say okay thumbs up and goes out and then there's about 10% of those for systems that are okay to do that from a compliance perspective that do get automerged.
The way we built it is uh sort of this cascade of trust measures. Uh and so it starts from the fact that everything that we build in the factory is skill-based. So you you create a skill that says um what what are the questions that you want to ask when you say build a feature right if you're let's focus on the sort of the ticket to PR and someone will produce a ticket and in fact that will create a cascade of tickets that need to be built and so that is already a skill and that is a skill that is learning we'll talk about loops in a sec that kind of got improved over time to know which questions do you want to ask up front so that more uh it has a better chance the agents have a better chance at kind of getting it right to begin it.
And then the next piece of defining what you want is the code review element. I think code review is a really core competence for factories because otherwise it becomes the bottleneck. If you can't automerge, if you can't or effectively automerge, then then you you're just going to create this insane bottleneck and increasingly the the human reviewing it, even if you had a human reviewer, they don't know the code anymore. So they're not only uh a bottleneck, they're also not even that good anymore at being the person doing it. So code review codifies taste and it's important over there to separate we we have an element of what is good code but we also have a distinct skill-powered assessment of the risk of the sort of the risk in this change.
So there's a Tessl change risk assessment uh that assesses things that are obvious how much code has changed and you know similarities sort of past code changes on it but also again has some custom lenses and all of those when we set up a new factory and for us we've sort of built it a bit more incrementally we kind of mine the the history right all the past get PRs accounts that you've had uh and and more information right around that feedback and we gather it up into these lenses and so we build that and then the last bit that I will mention because there's actually more than these three pieces is that is is this notion of looping.
So right sort of the first bit was like try to get it up right up front. The second is is really gate it well. By the way, that gating includes knowing to ask questions like if it's a screen cap, be able to in your ticket to PR create videos and sort of run through them. But then in the in the lens, you need to be able to ask a question, right? Did the buttons move, right? As part of the change on it. And what does that affect? But then after you've gone through all of those, it still makes mistakes.
People do make like comment on those mistakes. And so the critical bit is is creating a loop. And so we have a process that repeatedly at the beginning it was daily I think now it's weekly inspects historical like what new comments what new feedback has been given to these PRs a lot of it is human feedback on the PRs but sometimes it's also post deployment what has happened I'd say that we still have a lot of improvements to be had there and I think we can talk about that in the context of Dash0 but you learn from it and then you improve it and I I think that loop is is important if you if you set down a bunch of your team in a room and you sort of grilled them, you know, until uh, you know, uh, the day ends about what it is that is good, you're still not going to get like you're only going to get a limited amount of of ability to uh, to get their opinions.
So, I think the secret is to extract truth out of observation to be able to say run the things, give some thought upfront to what you're going to run, gather feedback, and be able to uh, repeatedly extract feedback out of that loop. and into into the skill. So you are in that loop. You're looking at the feedback and the result is essentially you are updating the skills. Correct. Yeah. So the change goes to the skills and I think like you you introduce another question which is uh okay you change the skill. How do you know that you didn't break like how like this is software right?
If skills are the new code you've just modified the skill maybe it works well for this last week's PRs but like four weeks ago there was another edge case on it like and did you just delete that? to know how do you and so what we also have is we have an eval system a skill eval system which are basically the tests and once again just like tests nobody likes writing tests novel developer likes writing tests nobody wants to write evals uh and so the best thing to do is to extract evals out of observation right you sort of extract sample scenarios you can talk about the last N that have gone through you can pick specific ones whether it's sort of humans or others you know for us there's still a judgment uh element to it and then you create those evals.
And so every time there's a there's a a change then you're able to like know that it didn't regress. And those eval then in turn allow us to answer other questions that you care about which is okay it worked but can it be faster? Can it be cheaper? Uh what about it's like safety right? Can I attempt different things? And so once you have accumulated enough of these eval scenarios you can now have a representative set of changes. And so for example, we went from using at some point sort of Sonnet and Opus to going to GLM53 that was sort of useful for us for a time but then it was actually quite slow and so we benchmarked it against Terra and well actually a combination of Luna Soloul and and Terra now it's mostly uh Luna and Terra and and they they resulted in in results that are much better like when we when we benchmarked our code review we saw that GLM53 was I think three times cheaper per token but was actually three times more expensive than Terra at the time to to get the correct results because the the sort of the the frontier model was just more capable, right?
Like was got it right. It had to do far fewer turns, so it spent less tokens. So I feel like the ordering here though is important. Like the first thing you do is you define the code reviews for what correct is. Then you kind of evolve what are the questions up front looping from the code review. Then you know once you kind of have enough of that code review as you loop and you improve you have something good you start extracting those kind of eval uh and build them out because if you try to the mistake people do is they just sort of get stuck at I need to frame it in the sort of perfect manner and uh and once you define those evals your context actually doesn't even terribly matter like how the words the skills themselves just like you don't look at code necessarily you don't even necessarily look at the words of the skills you know you just look at the change and does it make sense for sort of the modification and you look at the eval results to improve.
Yeah. But if you look at those things like quality, safety etc. you can do that on the code on the PR but you kind of also have to do it on runtime right because also as you explained these UI drifts and and these things you cannot see in the code right you you have to see it running and then look at screenshots or whatever right to see if if it's now working or not. So do you do that too? That that's interesting because that's kind of overlapping with the observability where where you actually can see screen recordings etc and user behavior and stuff like that.
Yeah. Yeah. I think observability there are different uh thresholds of quality. So the first threshold that is easiest to implement is static analysis. It's just an agentic review. So this is like an expert looking at your code. I mean in practice when you have a really good person code reviewing you know like a capable person in your team reviewing someone else's code oftentimes they don't run the software they look at the code and they they kind of spot the problem right or they so there's a lot of value in that and you can improve that and then the the second level is one of execution so that requires a little bit more uh investment the good news is that if you've built a ticket to PR factory then kind of implied in that is that you are able to kind of clone the repo and run the software on it because you're building it as as part of that ticket VR and so you now have an environment like another asset that you're developing is this definitions of environments to run so that the agent can invoke and run your software.
So now it's a relatively small leap that we do support which is to enable you to start running and capturing information. The agent is now able to basically run your software. Now how representative is the environment that it runs in and all of that those are similar problems what we had before with staging. So simple invocations of them are important but you do need to think about you know how do you stage the data and and build that out but yeah now we we do that we both for internal software and for what we can enable with the product you can extract screenshots you can extract videos of the product walkthrough and uh interestingly we get to GTM in a sec we like increasingly the GTM uh team you know like our sort of marketing ourselves they can't keep up with the pace of change you know in product and so increasingly we're trying to kind of shift GTM left and inject a lot of the judgment that we need in in sort of the sales and the marketing side and the production of the assets that we need for them to actually be with the product.
So the aspiration that we're we're already doing but we're not doing well enough yet. we're sort of evolving uh and we're dogfooting this and then a lot of these things will come into the product is is automated creation of demos and and so that's important because now you can say here are my gold demo paths I've made this modification to the feature does it break any of the gold demo path simulate those and see what has happened here's a new feature what's the right messaging for it is there a landing page that is needed and all of these things should feed back to the developer uh to say the the judgment needs to come from the experts from the GTM side, but then these kind of problems need to sort of show up as you're developing the software.
So, I think it's kind of automations and agents all the way down. And I'll just quickly say because I feel like I've been rambling that the third level of quality is when you start tapping a Dash0, right? And when you start saying, okay, what what happened in production? So, fine, I I shipped this thing. I think that world for us internally is uh we're sort of not as advanced over there but I feel like there's a lot of promise in tapping into analytics tapping into observability logs and understanding what has happened so you can form an opinion about a change that actually has rolled out and you are seeing how it behaves so you can take insight back into into production.
Those insights, by the way, have their own workflow of how much do you automerge them or not. The factory itself, we're much more lenient about self-improving it. The the product has a lot more of those compliance requests. Yeah. By the way, I can totally relate to the problem. We we have the same issue with we releasing so fast at the moment that we are also automating the uh creation of like the outputs, right? Sales presentations, demos, etc. But still you somehow have to enable people on on those things right on the demos on the sales pitch and that's creating a bottleneck at the end of the day right not not only on the go to market but even for the end users too right because now you're releasing a lot of things and you somehow have to educate people so there is probably some limit what you can really roll out as software so that human can still digest it right maybe at one point when agents become the number for one user that's not a problem anymore but at the moment I would say the end user is it the go to market person or or just the person who uses the product is still overwhelmed sometimes from from the speed of development which which is an interesting problem to solve yeah I think it's a I think it's a real problem and I eventually in the product I think the answer is every product should have its own agent for starters and the agent should know it so this is I sometimes think about the analogy of to like professional services.
Like if you're a salesperson that sells professional services, you can't demo your services per se, right? You're you're you know you you you demo aspects of past projects and capabilities that they have delivered and uh and the likes. But then you know you you have a product, right? you're you when it moves and it changes and it has like this ever growing capability then I think the salesperson should make available or whoever it is that is enabling the customer should sort of represent here are here's our agent right and here are the outcomes that it helps you achieve and your own like the Tessl agent which we have knows about the new capabilities that are in the product and if there's a customer agent that is consuming which is very common for us we're maybe a little bit biased because we're in this world so often times our consumer is an agent we enable skills and sort of information so it is available but yeah I agree it's an interesting I I don't think I don't think the solution is slowing down maybe on the interface side it is because people don't like instability but in terms of competence I think it's about abstracting the conversation then having agents kind of know the details yeah so now we talked about the skills the loops and then there is a full software factory right so where do you think are we on that journey and and how Does it look like do do you think there will be a time where you create a ticket or a specification and everything else will be fully automated?
Let me map that out indeed because I can refer to skills and loots on it like a little bit messy. So I think building your factory in the right way. Uh you should build it from skills to loops to factory. So like skills are really about encompassing what it is that you uh want right and what good looks like and you can evolve those as we've discussed into eval. And then loops are really about executing those skills in a way that you can learn from. And so you run them, you associate a skill with a project.
You uh collect the logs and have the instrumentation uh for it. You you're able to judge and assess a little bit of the output or have a mechanism for getting feedback. Now you're running those skills. Skills are only valuable when they're in motion, right? you're if you're running them, but you're running them in a in in a way that is well instrumented so you can learn from it and then you start running it. So that's the loop. By the way, technically a loop is any agent run because then agent calls the LLM and then loops on its output.
But I'm using kind of the broader like factory term of the loop uh that is in self-learning. And then when you go to factory, I think the primary the primary delta between just running loops uh to a factory is is primarily when you're trying to shift to a ticket to PR interaction, right? So loops can be you can be developing in a very manual fashion even if you want and you can introduce a code review loop or a vulnerability remediation kind of automation loop, right? Or a a cost optimization loop or a context management loop.
You can do those loops skill-based independently and that's not a bad way to get going because factories are scary. Going to a mode in which your team builds with ticket to PR predominantly is a cultural shift. So you it ticket to PR is its own loop. Take a ticket know get it to PR and then PR to production is its own loop as well. But I think the beyond it being a loop it's the biggest shift in how developers operate. Right? And so for us when we introduced when we kind of declared that we're moving to ticket to PR like we initially we had a ticket to PR capability and some small subset of features were being built in that fashion and again we always evolve the product as we learn from our own practice as well and and then we kind of bring it to us as we learn more but when we we made the switch to say from here on you shouldn't be building on your machine everything that you build should be logged as a ticket and should be a PR and when you find a problem like when when there's a mistake in the PR like really try to avoid fixing the symptom like really sort of telling it no code it this way or the other but rather give the feedback and let it build so that we can learn so we can loop and we can learn uh and that was interesting because one is it it was a really good way to evolve the the product right it's actually make the skills improve and get them to be better but two is it was interesting to interact with the with the challenges that developers had in making this transition, right?
So, some some were just purely cultural. People are just like, I I don't want to build this way. In fact, we had a developer on the team, very good developer, who decided to leave, like he said, I get it, you know, I understand what you're trying to do, but I don't want to build this way. And, you know, part of his friends, it's all good, but it's not it's not for him. So, it is it is a big change because people are quite attached to coding and working. And then beyond that though, there were a lot of these legitimate things that we had to fix in the factory.
So uh it wasn't fast enough. We had to build like more interactive models for them to to build it. They were already building with agents locally by the way, right? Like nobody was hand writing the code. There were specific domains in which the agents were not good enough. So design was a good example. It's actually like a really good uh side tangent on on fixing technical problems. So design skills are are good in like expressing intent, but design is oftentimes in the small details. And so to begin with our design team has built a set of skills and lenses to be able to review the product.
But even those were were a little bit too fine. And we actually created a thing that became a core building block in the product called verifiers which are a small set now now they use a decision model but a small set of definitions of what does good look like? And it could be every button that looks like this should have sort of this you know font or this uh uh this color. And so these are a long list of verifiers. They're stored in their own file in the repo. and they're packageable if you want into a reusable plug-in uh and uh and we run them.
And so with design that actually made a big difference because again now you loop to sort of say no no no this button should be here should be there and then you learn from that you create a verifier you create this list of verifiers and they become really really good and then when Jev came out we've like we were running it with a with a a small I think primarily with Luna uh at the time and when Jeff came out we were sort of set up to run benchmarks and we started was actually a lot faster for about a third of the uh cost.
uh we've seen gotten a little bit more cynical as we sort of look and inspect a bunch of its decisions on it. So we feel like there's still room for improvement on it and we're now bifocating. We sometimes use a small model, sometimes use a decision model uh to run it. But it was a good example of like I guess what I'm trying to say is like when you move to a factory mode, you have to consider uh you have to make a commitment to say I am at least for this scope I'm going to move to this mode.
I will now expect my team to fix the factory. Don't don't fix the car. So when you find a problem do that and today we can say that more than 70% of the team every week improve the factory. So they're not just building features they're building and improving the system factory self-improving as well in many ways. And then and then you have to apply that cultural shift. So every time we we had a list of every person in the team here's the number of like factory PRs they submitted. Here's the human PRs you know that kind of they went direct.
And whenever there was human PRs like every the the team that led this and sort of the managers will go to the person says like what is getting in your way like why why are you doing sometimes it was about nudging them to sort of behave that way and sometimes it was like well this is a problem and so okay we came back and we improved it. So again a little bit longwinded here but but it's like super it's like it's like the DevOps transition where these things require. Yeah. But it means so number one you're you're basically not coding any line of code anymore manually and you're not for a while prefactory for us I think.
Yeah. Yeah. And you also try to not really prompt it anymore right directly what to code. You want to prompt the factory essentially or or or change the factory in a way that you don't need to prompt anymore and adopt it. Right. That's correct. So we we provide the requirements. So I guess there's a prompting element to it. There is a skill. What we try to eliminate is interactive coding sessions. And so there is interactive ideiation. People will run their agent and they will have it they will interact about some feature, some capability. In fact, a very common practice is you will go you will explore an idea with your agent.
You will create a notion document or some sort of short decision document. You'll post that on Slack. That'll be a bunch of collaboration. You'll go back to your agent. You'll say, "Hey, pick up all the comments that we just read on Slack. We have this sort of skill on it. Let's create the right tickets." And then those tickets get created. For us internally, we keep debating between logging the plan as a plan file versus logging sequence of tickets that are the plan. Pros and cons to both. So, we're kind of doing a little bit of both.
And it's a for customers, you see both paths. They're both legitimate, but you build a plan and then the plan get executed. So, what you're trying to avoid is is local learnings. you see developers still veering a little bit into that right a lot of developers for instance or some developers on the team have their own review when a PR arrives to them they have their agent review it with their skill so that's an interesting question that to me is still a shortcoming of our product that it doesn't give you that right the product should enable personal taste is like do you do you want personal taste in your team like when you you really in theory want to say that when one developer reviews a PR or or their peer you you want to get the same result So is it just about avoiding the conversation about what's kind of a how do we sort of resolve our differences?
this is still a journey you know and and eventually there's going to be a question about what happens when data trumps taste and uh so that also requires and I think the job of a factory builder uh whether you're building your own factory or you're using you know product like ours is to is to define and enable the interaction points for the humans right like where do you where do you meet the factory at the entry point for those definitions at the sort of the skill creation and the eva management at the kind of loop findings that come up.
We call them findings that propose a change and and and then we can talk a little bit about trusting the factory and safety uh if you want. But I think those are like interesting interactions and and yeah, you aspire to be as outcome like the the aspiration somewhere in the future is you define your you define what you want to build, you know, like what like what what do you want to build? How would you verify correct behavior is and uh uh what are the guardrails you want to operate within and you can choose whether in some places you want to be quite granular with these definitions and in some places you're you're actually quite abstract.
Yeah. Yeah. And because we are coming to an end already from a time time I see I want to talk about you you described how a developer quit the job because he didn't want to work like that right so what do you think will the role of an engineer or the job role will become over time and will those who don't want to work in that way still exist somewhere or is it just a competitive thing market thing that once the factories are running you cannot compete anymore with the speed and output and and and finally everyone will either work that way or they will be gone.
I I I think so I used to think that coding will remain a niche practice. So there will be some places where someone would hand uh craft code. I no longer think that. I feel like coding uh I mean maybe if you're you know for fun it's almost like you're sort of you know you have a workshop at home and you sort of build your sort of chairs because you enjoy doing that and you don't care about efficiency you know you're purely doing it for fun. But I feel uh beyond that type of like artistal antique style uh coding I think everything will be will be built by agents and and I think the the barrier to that will be describing taste and describing what are your preference.
I think the job of the developer will will be maybe three-fold. You know, one is you need to define like you need to be the kind of the product communicator a little bit that understands kind of knows a little bit more which questions to ask. It might interact with the system to do that, but still you need to to guide the system, right? To take in some sort of input with agent assistance and all of that and decide what to build. And there's a lot a lot that goes into that because often times you're it's about deciding what not to build, right?
like you're you're going to reduce that. There's a whole world of personalized software that I think will come that might reduce that. By the way, like know can you create for every one of your customers their own kind of version of the software but uh but if you put that aside I think curation is still important. I think the second thing you need to do is is just kind of manage the the boundaries right or the guardrail. So you want to define the constraints you know what and uh and and these are often times the definition of of what makes you you right it's like what's the difference between JPMC and opening ChatGPT and saying build me a bank you know there's a bunch of learnings a bunch of decisions a bunch of riskmanagement decisions a bunch of uh there are more if the first one was about what you build you know this one is a lot about how you build and then I I guess this the third one is uh saying like I have this unwritten blog post in my the thinking that humanity's greatest advantage over AI is irrationality.
Uh it's this these places in which you are have conviction in a path and you're going to make a decision that is counter to the data. No, counter to the statistics and you'll make a bold decision. And you can do that as a human because you're accountable because if you get it right enough times, you'll get promoted. If you get it wrong enough times, you'll get fired. You know, there's no agent in that. And and it's that alpha. So maybe that's taste, maybe that's, you know, intuition, you can call it what it is, or just sort of daring.
But eventually, like every every successful company, every piece of art, you know, that sort of made a change, every every one of those has been counter to the statistics, to the norms, right? Like, you know, uh non-conensus uh at the time. And and I think I think that type of like irrational choice can only happen if you're accountable. And so they require humans to make them. So I think that would be the uh future job of an engineer, not distant future. I will say a little bit a window into how development will look like pretty soon probably, right?
With with those factories, but uh right now today I I really Yeah, but but as I said, right, when we see organizations, they are not there yet, right? And uh I think they will get there. And for me, it's exciting, right? I'm more a builder. I like to build things. I don't care too much about the details, right? So, uh for me this this is amazing time, right? But I can also totally relate when I was an engineer and I loved code and I love the craftsmanship of creating code almost an art, right? How code looks like and if this going away I can see why developers are not liking it, right?
It's it's obvious. So, but it's I don't think that change will be rewarded, right? So yeah, I think it's it's the reality of it. And again, you can still there might be still artisal, right? There's all these math kind of uh uh games and the likes, you know, chess has been solved basically by AI and it's bigger than it's ever been. So as an entertainment factor, as a craft, as a as a showing of skill, right? Like playing most instrument instruments, you can still play them. Although you can simulate all of those on your computer and we still very much appreciate it.
But those are entertainment. they're not production systems on it. So I think the production systems will will be there. And I will say that the the other kind of unsolved problem that definitely we're sort of focusing a lot on in Tessl is this notion of building software factories you can trust and eventually that trust boils down to quality which we talked about like would it produce is it all AI slop right or can I kind of produce good quality. It's about safety and security like would the agent behave? Will they change stay in the lines?
Will they not leak information? There's a bunch of controls that that that we have that we're building that others can build around identity around others to to enable. And then the third is uh cost. It's like okay, you can run this, you can run up a build pretty quickly and it's okay that it costs you a fortune if it makes you a fortune, but when it cost you a fortune and it doesn't um you're in trouble. So I think all of those are things that are actively being worked by worked on by by kind of us and others and I think I think think once they're really kind of unlocked you'll see a much faster adoption of uh of this new world.
Yeah, absolutely. Thank you guy for the conversation. Thanks for listening. I'm always sharing new insights and insider knowledge about observability on LinkedIn. You can follow me there for more. The podcast is produced by Dash0. We make observability easy for every developer.



