# Does Code Quality Even Matter?

Max Kanat-Alexander · AI Engineer NYC 2026 · October 13

[Watch recording](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2631s)

[00:43:52](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2632s) All right.

[00:43:53](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2633s) So today I figured I'd pick a nice uncontroversial topic that nobody has any opinions about.

[00:43:59](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2639s) Right?

[00:44:00](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2640s) Nobody has said anything on this about social media.

[00:44:04](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2644s) And of course every take about this on social media is really deeply nuanced.

[00:44:10](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2650s) People have lots of depth and really big thoughts.

[00:44:13](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2653s) You know, maybe there's a little bit more to it than like yes or no.

[00:44:18](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2658s) And, you know, of course, if you ever ask a senior engineer a question, we always have

[00:44:22](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2662s) the same answer to every question, every senior engineer's favorite answer to every question,

[00:44:26](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2666s) which is, it depends.

[00:44:30](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2670s) Now, that's not a very helpful answer, though, frankly, because what does it depend on?

[00:44:36](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2676s) So let's start with this.

[00:44:38](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2678s) Why did code quality ever matter in the first place?

[00:44:41](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2681s) I see a lot of people be like, well, it made me feel good.

[00:44:44](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2684s) That's not really a sufficient justification.

[00:44:46](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2686s) So let's see if we can inject some nuance into this conversation and help everybody at

[00:44:50](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2690s) least be able to have a basis for reasoning about it while we're discussing it.

[00:44:54](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2694s) So let's see if we can make a framework here.

[00:44:56](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2696s) That's what we're going to try to do with this talk.

[00:44:59](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2699s) So we're going to start off with everything you want to ever accomplish with a piece of

[00:45:02](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2702s) software depends on two factors and two factors alone.

[00:45:06](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2706s) And that is understanding and executing on that understanding.

[00:45:09](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2709s) Whether that's aligning a model, scaling a system, driving adoption, anything, all software

[00:45:14](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2714s) success is determined by these two factors.

[00:45:17](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2717s) This is why we have things like debuggers and observability and evals and even tests.

[00:45:21](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2721s) All those things actually are there to improve your understanding or ability to execute on

[00:45:25](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2725s) that understanding.

[00:45:25](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2725s) People think that they're there for other reasons, but fundamentally they're there for that reason.

[00:45:30](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2730s) Everything we have ever done in the field of code quality is exclusively and only for

[00:45:36](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2736s) these two things.

[00:45:37](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2737s) It's not for anything else.

[00:45:39](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2739s) And that doesn't have something to do with correctness or something else.

[00:45:41](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2741s) It has to do only with these two things.

[00:45:44](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2744s) Now, there's two understandings that are the most important to have

[00:45:46](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2746s) if you're going to be a software engineer.

[00:45:48](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2748s) There are other understandings to have about software,

[00:45:50](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2750s) if you're going to be a product, if you're going to be in sales.

[00:45:52](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2752s) But if you're a software engineer, there's the two that are the most important.

[00:45:55](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2755s) And the first is, what is the behavior of the system?

[00:45:58](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2758s) Like, concretely, not what does a doc say the behavior of the system is,

[00:46:02](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2762s) but what is the actual behavior of the system?

[00:46:04](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2764s) And the second one is, how do I correctly and safely modify that behavior?

[00:46:11](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2771s) On a very small system, if you want to understand what the system does,

[00:46:16](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2776s) I just tell you what it does.

[00:46:18](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2778s) It prints hello world.

[00:46:19](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2779s) You say, I wanted to say hi world.

[00:46:21](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2781s) I say, okay, I will make it say hi world now.

[00:46:23](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2783s) There's very little to understand about it other than purely what it does.

[00:46:28](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2788s) That's all of the understanding that you need.

[00:46:30](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2790s) However, any real software system is enormously complex.

[00:46:34](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2794s) This is a real map of the code base of Chromium,

[00:46:39](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2799s) which is the open source project behind Chrome.

[00:46:42](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2802s) And if you think about all of the different ways

[00:46:45](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2805s) that these components can interact,

[00:46:46](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2806s) they have essentially infinite possible behaviors.

[00:46:50](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2810s) Like, I could not describe to you in words

[00:46:53](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2813s) the behavior of Chromium as a whole, as a system.

[00:46:58](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2818s) However, what I can describe to you, and as we all know, everybody's been a software engineer

[00:47:02](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2822s) for a while, I can describe to you components of the system.

[00:47:06](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2826s) I can successfully describe to you how a component of the system behaves.

[00:47:11](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2831s) So this is the URL parser, the actual functions and stuff for the URL parser of Chromium.

[00:47:16](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2836s) It figures out all the different parts of the URL.

[00:47:19](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2839s) And this is the whole reason that code exists.

[00:47:25](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2845s) The whole reason that we have code at all in the first place is for structure.

[00:47:32](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2852s) What do I mean by that?

[00:47:35](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2855s) Both of these two things on the left and on the right will print Hello World if run on

[00:47:40](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2860s) a Linux machine.

[00:47:42](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2862s) However, on the left you can see that it is Hello World.

[00:47:46](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2866s) It has the identity and structure of Hello World.

[00:47:50](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2870s) On the right, you just see a series of instructions with no particular identity, recognizable

[00:47:55](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2875s) or understandable identity.

[00:47:57](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2877s) It's not a component.

[00:47:58](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2878s) It's just a bunch of instructions.

[00:48:00](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2880s) While that's understandable there, if that was millions or billions of lines of that,

[00:48:04](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2884s) it would be much harder to grok.

[00:48:06](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2886s) In the past, we've talked about things like readability or testability or things that

[00:48:11](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2891s) seemed like human concepts about code.

[00:48:14](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2894s) But what actually mattered the most always was that the system had some sort of understandable

[00:48:19](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2899s) structure.

[00:48:19](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2899s) So it's the structure that actually matters.

[00:48:23](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2903s) And when this matters the most is when you want to modify the system, the second understanding

[00:48:30](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2910s) that we talked about.

[00:48:32](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2912s) All modifications to a system carry two categories of risk.

[00:48:35](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2915s) The first is that you will introduce some sort of problem.

[00:48:38](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2918s) And a problem isn't just a bug, it's anything bad that could happen.

[00:48:42](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2922s) Like your project could take much longer than you expect.

[00:48:44](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2924s) It could not behave in the way that you wanted it to for your users.

[00:48:48](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2928s) The project could fail because you have budget overruns.

[00:48:50](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2930s) Any kind of problem could happen from just you trying to go through the process of making this change.

[00:48:55](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2935s) And the second is you could make it harder to make future changes.

[00:49:00](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2940s) In particular, what that means is you could make it more likely to have future problems.

[00:49:03](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2943s) You could increase future risk of the system.

[00:49:06](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2946s) These two things are caused by problems with understanding.

[00:49:12](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2952s) So the first has to do with the difficulty of understanding the system in the first place.

[00:49:17](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2957s) And the second is you make the system harder to understand.

[00:49:21](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2961s) can reduce every post-mortem I have ever read for any incident to these two factors

[00:49:27](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2967s) in one way or another.

[00:49:29](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2969s) The production configuration was too hard to understand.

[00:49:31](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2971s) Somebody made something impossible to understand.

[00:49:33](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2973s) There were emergent properties of the system that were impossible to understand.

[00:49:36](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2976s) Whatever.

[00:49:37](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2977s) Point two feeds into point one in a vicious cycle that compounds in a non-linear fashion.

[00:49:47](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2987s) So the difficulty of understanding does not grow linearly, it compounds over time.

[00:49:52](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2992s) You will eventually reach a point, and all systems eventually tend to reach this point,

[00:49:57](https://www.youtube.com/watch?v=akEqiXFo3GM&t=2997s) where every modification involves some sort of problem.

[00:50:04](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3004s) Some systems get to the point where you can't modify them at, if you think of your giant

[00:50:10](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3010s) 100 million, 500 million line mainframe code bases, everything, every change is some sort

[00:50:16](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3016s) of problem.

[00:50:16](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3016s) You'll see it in organizational issues, you'll see it all over the place, you'll see it in

[00:50:20](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3020s) timelines, whatever.

[00:50:22](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3022s) And look, there's a lot of arguments about maybe future models will fix this.

[00:50:25](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3025s) Look, maybe they will, maybe future models will have infinite ability to deal with complexity

[00:50:29](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3029s) somehow.

[00:50:30](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3030s) But we don't have to discuss that today because I think models are doing something else really

[00:50:35](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3035s) interesting right now.

[00:50:37](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3037s) They are creating a new kind of software, a new category of software.

[00:50:42](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3042s) This category has always existed, but it's about to become 100,000 times more common

[00:50:49](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3049s) than any other form of software, and that is disposable software.

[00:50:56](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3056s) So what is that?

[00:50:58](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3058s) Okay, so imagine a world in which the consequences of failure for your system are very minimal

[00:51:04](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3064s) or nonexistent.

[00:51:06](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3066s) Imagine that there's very few people that depend on it, and almost no other systems depend

[00:51:10](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3070s) on that piece of software.

[00:51:12](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3072s) Change management, very minimal, non-existent.

[00:51:15](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3075s) Imagine the cost of replacement went to near zero.

[00:51:19](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3079s) You could replace the whole thing in hours or days.

[00:51:22](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3082s) And it had basically no cost of maintenance.

[00:51:25](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3085s) In that world, code quality does not matter.

[00:51:32](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3092s) Because all of those things we were trying to prevent

[00:51:35](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3095s) about the compounding risks over time don't exist.

[00:51:41](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3101s) Traditionally, we've always built durable software.

[00:51:45](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3105s) lives for years, it's depended on millions or thousands of people, there's huge consequences

[00:51:50](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3110s) of failure, potentially business catastrophic consequences of failure, and it requires enormous

[00:51:55](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3115s) maintenance.

[00:51:56](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3116s) Most of the software engineers in the world spend most of their time maintaining these

[00:52:00](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3120s) giant durable systems.

[00:52:02](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3122s) I expect this to continue to exist.

[00:52:05](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3125s) So this is one of the areas where I think sometimes the conversation goes a little astray.

[00:52:10](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3130s) Durable systems will continue to probably be the most important systems in the world.

[00:52:17](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3137s) And there will be probably more of them.

[00:52:20](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3140s) But the most numerous systems will be disposable software.

[00:52:26](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3146s) They will be replaceable in hours.

[00:52:28](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3148s) They will be depended on by a few.

[00:52:29](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3149s) Or change management just won't matter.

[00:52:31](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3151s) And look, if it doesn't work, we'll give everybody agents.

[00:52:35](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3155s) They'll make a version of it themselves.

[00:52:38](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3158s) Maintenance will be unimportant or nearly free.

[00:52:40](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3160s) Don't like the calculator on your OS?

[00:52:42](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3162s) Make your own.

[00:52:43](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3163s) Want to plan a party for your kids?

[00:52:45](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3165s) Write a party planner software just for that one party.

[00:52:49](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3169s) Throw it away.

[00:52:50](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3170s) Code quality doesn't matter.

[00:52:51](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3171s) Nobody cares.

[00:52:53](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3173s) In the future, we will apply engineering rigor to the degree of disposability of the software.

[00:53:00](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3180s) On the left, nothing, none of our practices of engineering rigor matter at all.

[00:53:06](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3186s) On the right, all the practices of engineering that we have built up over the last many decades

[00:53:11](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3191s) matter greatly.

[00:53:12](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3192s) We can determine where you are on this scale by those four factors that I have been talking

[00:53:17](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3197s) about.

[00:53:18](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3198s) Consequences, cost of replacement, dependencies, and cost of maintenance.

[00:53:22](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3202s) If they're all low, it's

[00:53:23](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3203s) disposable software. If they're all high, it's durable software.

[00:53:27](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3207s) And look, any person who's written software for a long time knows you should err on the side of it being durable. You should err on these all being higher than you expect them to be.

[00:53:36](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3216s) But there's also a new thing you can do in the world. You can make software more disposable. So, like, what does that involve?

[00:53:46](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3226s) Well, come up with better isolated environments.

[00:53:50](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3230s) So, hey, you can only deploy to this environment that has access to only your data.

[00:53:54](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3234s) No customer data, no personally identifiable information, whatever.

[00:53:58](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3238s) You can enforce independence.

[00:54:00](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3240s) You can say, okay, no inbound API calls from other production systems are allowed to this

[00:54:06](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3246s) system in this environment.

[00:54:07](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3247s) And so everything deployed to that environment is disposable.

[00:54:11](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3251s) Redundancy.

[00:54:11](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3251s) You can have an old clunky backup system that is hard to use.

[00:54:16](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3256s) And then, look, if people want to vibe code their own more efficient front ends,

[00:54:19](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3259s) you let them vibe code their own more efficient front ends

[00:54:21](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3261s) because there is an old, durable, clunky backup system that they can use

[00:54:25](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3265s) if their crappy little vibe-coded thing fails.

[00:54:28](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3268s) Which it will fail. That's fine. But it doesn't matter if it fails.

[00:54:32](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3272s) And you can limit scope, just like I talked about.

[00:54:34](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3274s) It's just a calculator for this one person.

[00:54:36](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3276s) It just plans this one party.

[00:54:38](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3278s) There's so much more we could do here and talk about ways of increasing disposability.

[00:54:45](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3285s) In fact, I think this is a whole new discipline of software engineering.

[00:54:50](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3290s) Not to think about how we improve the rigor of durable systems, but how do we take our

[00:54:55](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3295s) systems and how do we encourage disposability or allow more disposability, allow people

[00:55:00](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3300s) to throw these things away.

[00:55:02](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3302s) Interesting thought.

[00:55:03](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3303s) Now, I want to re-emphasize that durable software engineering is not going away because this

[00:55:10](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3310s) is the biggest confusion that I see on social media today.

[00:55:14](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3314s) In fact, I believe the absolute amount of durable software in the world will increase

[00:55:18](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3318s) because AI coding tools make it easier and easier to make more durable software.

[00:55:25](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3325s) another important thing to understand is that disposable and durable are not black

[00:55:30](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3330s) and white.

[00:55:31](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3331s) There's a spectrum, like I showed before, but that spectrum, what changes across the

[00:55:35](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3335s) spectrum is how much effort you're going to put into engineering rigor.

[00:55:39](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3339s) Okay?

[00:55:40](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3340s) And that's both immediate effort and effort over time, just like we've always talked about

[00:55:44](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3344s) for software.

[00:55:46](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3346s) However, what you want to do, and I think what you want to care about the most, is reducing

[00:55:51](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3351s) the cost of effort.

[00:55:53](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3353s) Reducing the cost of rigor.

[00:55:56](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3356s) like if rigor is cheaper if it's the easier and easier you make it to be rigor the less you have

[00:56:02](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3362s) to worry about where you are on the scale so this is another approach you can take

[00:56:07](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3367s) if you change your mind it's much easier to like you're like oh i thought this was going to be

[00:56:12](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3372s) disposable and now it needs to be durable the cheaper you make it to make it durable the easier

[00:56:17](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3377s) it is to change your mind or to be wrong because you're never going to be 100 right all the time

[00:56:22](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3382s) on that estimate. So that involves a different set of practices that are not engineering

[00:56:27](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3387s) rigor themselves, but that are about how to decrease the cost of engineering rigor.

[00:56:34](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3394s) Now, I could talk about this for hours. I have spent a tremendous amount of my career

[00:56:38](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3398s) doing this. I don't have 10 hours. I have about five minutes left on that timer. So

[00:56:43](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3403s) I'll talk about what I can, okay? Let's talk about standardization. Why do we do standardization?

[00:56:50](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3410s) People are like, well, I don't know, because the boss said so.

[00:56:52](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3412s) Well, no.

[00:56:54](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3414s) We do standardization because it removes possibilities.

[00:56:58](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3418s) If you don't have any PHP in your system,

[00:57:01](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3421s) you don't have to figure out what are all the linters for PHP,

[00:57:04](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3424s) what are all the practices, what are all the security holes I have to fix.

[00:57:07](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3427s) You just eliminate possibilities through standardization,

[00:57:10](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3430s) and it just reduces the cost of rigor.

[00:57:13](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3433s) Same thing with frameworks.

[00:57:15](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3435s) Why don't you want to have every front-end framework

[00:57:17](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3437s) or every back-end framework in existence?

[00:57:19](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3439s) because it makes rigor more expensive.

[00:57:21](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3441s) Like, yes, rigor is still possible.

[00:57:22](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3442s) Yes, you could still have the agent code up all your tools,

[00:57:24](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3444s) but you have to do it every single time.

[00:57:27](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3447s) You know, protocols,

[00:57:29](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3449s) why do you want to have standardized RPC protocols?

[00:57:30](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3450s) All the same thing.

[00:57:32](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3452s) Standards are all for this reason.

[00:57:34](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3454s) Okay?

[00:57:35](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3455s) What I call in-workflow tooling.

[00:57:36](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3456s) So in-workflow tooling is tooling that just occurs.

[00:57:38](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3458s) The programmer doesn't have to choose to run it.

[00:57:40](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3460s) They don't have to understand how it runs.

[00:57:42](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3462s) It just happens.

[00:57:43](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3463s) If it's there, it feels and seems free,

[00:57:46](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3466s) and it is reliable.

[00:57:48](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3468s) Reliability is very, very important.

[00:57:50](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3470s) It doesn't have a ton of false positives.

[00:57:51](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3471s) It's fast. It just happens.

[00:57:54](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3474s) And the more that's true, you can apply it to your disposable software too.

[00:57:57](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3477s) If it's free and fast, who cares?

[00:58:01](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3481s) Making testing easier.

[00:58:02](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3482s) So this is not just about, like, hey, how do we do better testing?

[00:58:05](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3485s) Look, how do you make it so that nobody has to think about how to do better testing?

[00:58:09](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3489s) How do you make it so that every test is fast and deterministic

[00:58:14](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3494s) without anybody having to be a deep expert in testing?

[00:58:16](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3496s) There's a ton of work that you have to put into test infrastructure to make that possible.

[00:58:22](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3502s) For example, one of the great dreams that I've always had as a test owner is that everybody

[00:58:27](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3507s) would provide in-memory fake versions of their services and I could just run those in-memory

[00:58:31](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3511s) fake versions of their services.

[00:58:32](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3512s) Guess what?

[00:58:33](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3513s) The coding agent can do that.

[00:58:34](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3514s) So you can just do that now.

[00:58:36](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3516s) But you have to choose to do it and make it available to everybody.

[00:58:40](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3520s) And another thing is, look, maximum strictness.

[00:58:43](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3523s) You just turn the strictness up everywhere.

[00:58:44](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3524s) You set all your lint rules to maximum.

[00:58:47](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3527s) You never compromise on anything.

[00:58:49](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3529s) And it eliminates, it's very similar to standardization.

[00:58:52](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3532s) It eliminates a ton of conversations.

[00:58:54](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3534s) Sometimes the linter is wrong.

[00:58:55](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3535s) As long as the false positive rate is relatively low and doesn't have catastrophic consequences,

[00:58:58](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3538s) it doesn't matter because all of a sudden there's a bunch of future lint errors or future

[00:59:03](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3543s) issues that you don't have to deal with.

[00:59:04](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3544s) Ask anybody who's been like, oh, I suddenly want to turn on my linter in this million

[00:59:08](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3548s) line code base.

[00:59:09](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3549s) And they're like, oh, wow.

[00:59:10](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3550s) Now here's my 100,000 line change that I need to make.

[00:59:13](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3553s) Much easier to do that up front and have it on for everybody.

[00:59:16](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3556s) Now look, like I said, I could literally stand here and talk to you about this straight for

[00:59:21](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3561s) ten hours.

[00:59:21](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3561s) There is much, much more you can do here.

[00:59:24](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3564s) This is just a few areas, but also a whole area of software engineering discipline that

[00:59:28](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3568s) you can apply on the other axis.

[00:59:31](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3571s) So this lets us now answer our question, not just it depends, but yes or no.

[00:59:37](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3577s) So does code quality even matter?

[00:59:40](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3580s) For disposable software, no.

[00:59:44](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3584s) For durable software, yes.

[00:59:47](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3587s) And we get to answer a third and even more interesting question,

[00:59:50](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3590s) which is, does it have to be expensive?

[00:59:53](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3593s) No.

[00:59:54](https://www.youtube.com/watch?v=akEqiXFo3GM&t=3594s) Thank you very much.