# Does Code Quality Even Matter?

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

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

[01:10:28](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4228s) All right.

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

[01:10:35](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4235s) Right?

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

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

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

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

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

[01:10:58](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4258s) the same answer to every question, every senior engineer's favorite answer to every question,

[01:11:02](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4262s) which is, it depends.

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

[01:11:12](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4272s) So let's start with this.

[01:11:15](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4275s) Why did code quality ever matter in the first place?

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

[01:11:20](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4280s) That's not really a sufficient justification.

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

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

[01:11:30](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4290s) So let's see if we can make a framework here.

[01:11:32](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4292s) That's what we're going to try to do with this talk.

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

[01:11:39](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4299s) software depends on two factors and two factors alone.

[01:11:42](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4302s) And that is understanding and executing on that understanding.

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

[01:11:50](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4310s) success is determined by these two factors.

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

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

[01:12:01](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4321s) that understanding.

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

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

[01:12:13](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4333s) these two things.

[01:12:14](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4334s) It's not for anything else.

[01:12:15](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4335s) And that doesn't have something to do with correctness or something else.

[01:12:17](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4337s) It has to do only with these two things.

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

[01:12:23](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4343s) if you're going to be a software engineer.

[01:12:24](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4344s) There are other understandings to have about software,

[01:12:27](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4347s) if you're going to be a product, if you're going to be in sales.

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

[01:12:31](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4351s) And the first is, what is the behavior of the system?

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

[01:12:38](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4358s) but what is the actual behavior of the system?

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

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

[01:12:52](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4372s) I just tell you what it does.

[01:12:54](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4374s) It prints hello world.

[01:12:55](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4375s) You say, I wanted to say hi world.

[01:12:57](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4377s) I say, okay, I will make it say hi world now.

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

[01:13:04](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4384s) That's all of the understanding that you need.

[01:13:06](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4386s) However, any real software system is enormously complex.

[01:13:10](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4390s) This is a real map of the code base of Chromium,

[01:13:15](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4395s) which is the open source project behind Chrome.

[01:13:18](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4398s) And if you think about all of the different ways

[01:13:21](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4401s) that these components can interact,

[01:13:23](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4403s) they have essentially infinite possible behaviors.

[01:13:26](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4406s) Like, I could not describe to you in words

[01:13:29](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4409s) the behavior of Chromium as a whole, as a system.

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

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

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

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

[01:13:52](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4432s) It figures out all the different parts of the URL.

[01:13:56](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4436s) And this is the whole reason that code exists.

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

[01:14:08](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4448s) What do I mean by that?

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

[01:14:17](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4457s) a Linux machine.

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

[01:14:23](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4463s) It has the identity and structure of Hello World.

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

[01:14:32](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4472s) or understandable identity.

[01:14:33](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4473s) It's not a component.

[01:14:34](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4474s) It's just a bunch of instructions.

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

[01:14:40](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4480s) it would be much harder to grok.

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

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

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

[01:14:55](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4495s) structure.

[01:14:56](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4496s) So it's the structure that actually matters.

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

[01:15:06](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4506s) that we talked about.

[01:15:08](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4508s) All modifications to a system carry two categories of risk.

[01:15:11](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4511s) The first is that you will introduce some sort of problem.

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

[01:15:18](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4518s) Like your project could take much longer than you expect.

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

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

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

[01:15:32](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4532s) And the second is you could make it harder to make future changes.

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

[01:15:39](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4539s) You could increase future risk of the system.

[01:15:42](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4542s) These two things are caused by problems with understanding.

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

[01:15:53](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4553s) And the second is you make the system harder to understand.

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

[01:16:03](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4563s) in one way or another.

[01:16:05](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4565s) The production configuration was too hard to understand.

[01:16:08](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4568s) Somebody made something impossible to understand.

[01:16:09](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4569s) There were emergent properties of the system that were impossible to understand.

[01:16:12](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4572s) Whatever.

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

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

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

[01:16:33](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4593s) where every modification involves some sort of problem.

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

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

[01:16:52](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4612s) of problem.

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

[01:16:56](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4616s) timelines, whatever.

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

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

[01:17:05](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4625s) somehow.

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

[01:17:12](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4632s) interesting right now.

[01:17:13](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4633s) They are creating a new kind of software, a new category of software.

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

[01:17:26](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4646s) than any other form of software, and that is disposable software.

[01:17:32](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4652s) So what is that?

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

[01:17:41](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4661s) or nonexistent.

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

[01:17:47](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4667s) on that piece of software.

[01:17:48](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4668s) Change management, very minimal, non-existent.

[01:17:52](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4672s) Imagine the cost of replacement went to near zero.

[01:17:56](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4676s) You could replace the whole thing in hours or days.

[01:17:58](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4678s) And it had basically no cost of maintenance.

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

[01:18:08](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4688s) Because all of those things we were trying to prevent

[01:18:11](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4691s) about the compounding risks over time don't exist.

[01:18:17](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4697s) Traditionally, we've always built durable software.

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

[01:18:26](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4706s) of failure, potentially business catastrophic consequences of failure, and it requires enormous

[01:18:31](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4711s) maintenance.

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

[01:18:36](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4716s) giant durable systems.

[01:18:38](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4718s) I expect this to continue to exist.

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

[01:18:46](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4726s) Durable systems will continue to probably be the most important systems in the world.

[01:18:54](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4734s) And there will be probably more of them.

[01:18:56](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4736s) But the most numerous systems will be disposable software.

[01:19:02](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4742s) They will be replaceable in hours.

[01:19:04](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4744s) They will be depended on by a few.

[01:19:06](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4746s) Or change management just won't matter.

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

[01:19:11](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4751s) They'll make a version of it themselves.

[01:19:14](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4754s) Maintenance will be unimportant or nearly free.

[01:19:16](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4756s) Don't like the calculator on your OS?

[01:19:18](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4758s) Make your own.

[01:19:19](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4759s) Want to plan a party for your kids?

[01:19:21](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4761s) Write a party planner software just for that one party.

[01:19:26](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4766s) Throw it away.

[01:19:27](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4767s) Code quality doesn't matter.

[01:19:27](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4767s) Nobody cares.

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

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

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

[01:19:47](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4787s) matter greatly.

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

[01:19:54](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4794s) about.

[01:19:55](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4795s) Consequences, cost of replacement, dependencies, and cost of maintenance.

[01:19:58](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4798s) If they're all low, it's

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

[01:20:03](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4803s) 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.

[01:20:12](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4812s) 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?

[01:20:22](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4822s) Well, come up with better isolated environments.

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

[01:20:30](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4830s) No customer data, no personally identifiable information, whatever.

[01:20:34](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4834s) You can enforce independence.

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

[01:20:42](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4842s) system in this environment.

[01:20:43](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4843s) And so everything deployed to that environment is disposable.

[01:20:47](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4847s) Redundancy.

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

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

[01:20:55](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4855s) you let them vibe code their own more efficient front ends

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

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

[01:21:04](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4864s) Which it will fail. That's fine. But it doesn't matter if it fails.

[01:21:08](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4868s) And you can limit scope, just like I talked about.

[01:21:10](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4870s) It's just a calculator for this one person.

[01:21:13](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4873s) It just plans this one party.

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

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

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

[01:21:32](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4892s) systems and how do we encourage disposability or allow more disposability, allow people

[01:21:37](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4897s) to throw these things away.

[01:21:38](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4898s) Interesting thought.

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

[01:21:46](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4906s) is the biggest confusion that I see on social media today.

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

[01:21:54](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4914s) because AI coding tools make it easier and easier to make more durable software.

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

[01:22:06](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4926s) and white.

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

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

[01:22:16](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4936s) Okay?

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

[01:22:20](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4940s) for software.

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

[01:22:27](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4947s) the cost of effort.

[01:22:30](https://www.youtube.com/watch?v=akEqiXFo3GM&t=4950s) Reducing the cost of rigor.

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

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

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

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

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

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

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

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

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

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

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

[01:23:28](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5008s) Well, no.

[01:23:30](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5010s) We do standardization because it removes possibilities.

[01:23:34](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5014s) If you don't have any PHP in your system,

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

[01:23:40](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5020s) what are all the practices, what are all the security holes I have to fix.

[01:23:43](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5023s) You just eliminate possibilities through standardization,

[01:23:46](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5026s) and it just reduces the cost of rigor.

[01:23:50](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5030s) Same thing with frameworks.

[01:23:51](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5031s) Why don't you want to have every front-end framework

[01:23:53](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5033s) or every back-end framework in existence?

[01:23:55](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5035s) because it makes rigor more expensive.

[01:23:58](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5038s) Like, yes, rigor is still possible.

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

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

[01:24:03](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5043s) You know, protocols,

[01:24:05](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5045s) why do you want to have standardized RPC protocols?

[01:24:07](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5047s) All the same thing.

[01:24:08](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5048s) Standards are all for this reason.

[01:24:10](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5050s) Okay?

[01:24:11](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5051s) What I call in-workflow tooling.

[01:24:13](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5053s) So in-workflow tooling is tooling that just occurs.

[01:24:15](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5055s) The programmer doesn't have to choose to run it.

[01:24:16](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5056s) They don't have to understand how it runs.

[01:24:18](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5058s) It just happens.

[01:24:19](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5059s) If it's there, it feels and seems free,

[01:24:22](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5062s) and it is reliable.

[01:24:24](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5064s) Reliability is very, very important.

[01:24:26](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5066s) It doesn't have a ton of false positives.

[01:24:28](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5068s) It's fast. It just happens.

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

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

[01:24:37](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5077s) Making testing easier.

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

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

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

[01:24:50](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5090s) without anybody having to be a deep expert in testing?

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

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

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

[01:25:07](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5107s) fake versions of their services.

[01:25:09](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5109s) Guess what?

[01:25:09](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5109s) The coding agent can do that.

[01:25:11](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5111s) So you can just do that now.

[01:25:12](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5112s) But you have to choose to do it and make it available to everybody.

[01:25:16](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5116s) And another thing is, look, maximum strictness.

[01:25:19](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5119s) You just turn the strictness up everywhere.

[01:25:21](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5121s) You set all your lint rules to maximum.

[01:25:23](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5123s) You never compromise on anything.

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

[01:25:28](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5128s) It eliminates a ton of conversations.

[01:25:30](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5130s) Sometimes the linter is wrong.

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

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

[01:25:39](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5139s) issues that you don't have to deal with.

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

[01:25:45](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5145s) line code base.

[01:25:45](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5145s) And they're like, oh, wow.

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

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

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

[01:25:57](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5157s) ten hours.

[01:25:58](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5158s) There is much, much more you can do here.

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

[01:26:04](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5164s) you can apply on the other axis.

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

[01:26:13](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5173s) So does code quality even matter?

[01:26:16](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5176s) For disposable software, no.

[01:26:20](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5180s) For durable software, yes.

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

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

[01:26:29](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5189s) No.

[01:26:31](https://www.youtube.com/watch?v=akEqiXFo3GM&t=5191s) Thank you very much.