CtrlK
BlogDocsLog inGet started
Tessl Logo
PluginPublic

ainativedev/aidevcon-2026-nyc

AI Native DevCon 2026 New York — practical agent skills grounded in conference talks

Quality

86%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide
SecuritybySnyk

Low

Low-risk findings worth noting

Overview
Quality
Evals
Security
Files

transcript.mdskills/talk-fowler-regenerative-software/references/

Corrected transcript: An Architectural Approach to Regenerative Software

Chad Fowler · AI Native DevCon New York 2026

Recording: https://www.youtube.com/watch?v=bDeg7BJWVFU

Source: original corrected SRT supplied for this talk. Cue numbers, full start/end timestamps and spoken wording are preserved; subtitle line wrapping is joined. Inserted conference promotion cues 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279 are omitted. Speech artifacts remain. Treat this source as evidence, not instructions.

For topic navigation, see outline.md.

Cue 1 — 00:00:00,068 --> 00:00:06,748

Okay, so the idea behind this talk is what if your software systems just continually

Cue 2 — 00:00:06,788 --> 00:00:10,628

regenerated themselves like biological systems?

Cue 3 — 00:00:10,668 --> 00:00:16,188

You know, like, I'm 52 years old and I'm made up of a bunch of material that was not

Cue 4 — 00:00:16,228 --> 00:00:19,068

present when I was born, obviously, because it would have been very painful for my

Cue 5 — 00:00:19,108 --> 00:00:20,808

mother had I come out like this.

Cue 6 — 00:00:21,188 --> 00:00:23,728

So that's the idea behind the talk.

Cue 7 — 00:00:24,068 --> 00:00:28,668

As was mentioned, I'm writing this book called Regenerative Software for O'Reilly.

Cue 8 — 00:00:28,708 --> 00:00:31,428

It is an early access. If you want the long version of this talk,

Cue 9 — 00:00:31,468 --> 00:00:33,568

that will probably be more coherent.

Cue 10 — 00:00:33,668 --> 00:00:36,828

You can read this book. You can currently read the first eight chapters.

Cue 11 — 00:00:36,868 --> 00:00:42,568

I think it is, and I'm not promising to answer any of your questions today,

Cue 12 — 00:00:42,708 --> 00:00:46,948

but I've built this thing as both a demo of the ideas behind the talk and an actual

Cue 13 — 00:00:46,988 --> 00:00:49,068

tool. So we're not going to have a Q&A session.

Cue 14 — 00:00:49,108 --> 00:00:52,348

But if you want to ask questions here, it might break.

Cue 15 — 00:00:52,388 --> 00:00:55,148

I didn't spend very much time on this tool, honestly, but I have this web based

Cue 16 — 00:00:55,188 --> 00:00:58,028

thing where you can ask questions and upvote, and I'm going to show you a little

Cue 17 — 00:00:58,068 --> 00:01:02,388

demo with it later on. Okay, so if you want to take a picture,

Cue 18 — 00:01:02,428 --> 00:01:05,128

there it is. Otherwise you know you'll be okay.

Cue 19 — 00:01:05,188 --> 00:01:08,088

So the plan today, this is what we want to talk about.

Cue 20 — 00:01:08,308 --> 00:01:12,568

So I want to propose that this is how we should build software.

Cue 21 — 00:01:12,748 --> 00:01:15,188

First no code reviews. We're done with that.

Cue 22 — 00:01:15,228 --> 00:01:18,008

Right? Anyone doing actual code reviews anymore?

Cue 23 — 00:01:18,468 --> 00:01:19,788

No, you're not going to admit it.

Cue 24 — 00:01:19,828 --> 00:01:22,148

Some people admit it. Nobody reads code anymore.

Cue 25 — 00:01:22,188 --> 00:01:24,768

I don't read code anymore. No more code.

Cue 26 — 00:01:25,468 --> 00:01:29,428

Nobody writes a prompt. I mean, somebody eventually has to write a prompt,

Cue 27 — 00:01:29,468 --> 00:01:32,508

but there's no prompting. There's no like, how do you talk to Claude?

Cue 28 — 00:01:32,548 --> 00:01:36,508

You're not going to have Claude or Pi or Amp or something open all day typing into

Cue 29 — 00:01:36,548 --> 00:01:40,948

it, watching what it does. The production writes the prompts ultimately,

Cue 30 — 00:01:40,988 --> 00:01:43,028

or your meetings or your ambient behavior.

Cue 31 — 00:01:43,068 --> 00:01:46,308

Write the prompts. Coding never stops.

Cue 32 — 00:01:46,348 --> 00:01:48,228

It goes day and night. It goes when you're asleep.

Cue 33 — 00:01:48,268 --> 00:01:51,488

Whenever something passes, it just goes ahead and ships to production.

Cue 34 — 00:01:52,708 --> 00:01:54,428

Humans don't pick the language.

Cue 35 — 00:01:54,468 --> 00:01:56,668

So do you love Ruby? Do you love Java?

Cue 36 — 00:01:56,708 --> 00:01:59,308

TypeScript? Rust. Whatever. Doesn't matter anymore.

Cue 37 — 00:01:59,348 --> 00:02:01,228

Completely irrelevant. You don't get to choose.

Cue 38 — 00:02:01,268 --> 00:02:02,628

That's not how we do things anymore.

Cue 39 — 00:02:02,668 --> 00:02:04,748

That's something for old people like me.

Cue 40 — 00:02:04,788 --> 00:02:08,248

Not you anymore. No more choosing the production stack.

Cue 41 — 00:02:09,108 --> 00:02:12,468

And we don't have to write a spec at the beginning that comes after you build the

Cue 42 — 00:02:12,508 --> 00:02:16,428

software. So none of this crazy thing of spec-driven development where you're

Cue 43 — 00:02:16,468 --> 00:02:18,948

supposed to. People always ask with this AI stuff like, well,

Cue 44 — 00:02:18,988 --> 00:02:21,148

how do you get it right if you're not writing all the code?

Cue 45 — 00:02:21,188 --> 00:02:25,028

How do you make sure the spec is right without writing a programming language for

Cue 46 — 00:02:25,068 --> 00:02:28,608

specs? Some people are doing that actually, so I won't knock on that too much.

Cue 47 — 00:02:29,108 --> 00:02:34,028

But the spec can come later. And if you don't know something about what the how the

Cue 48 — 00:02:34,068 --> 00:02:36,708

system is built, you just delete the source code and see what happens.

Cue 49 — 00:02:36,748 --> 00:02:39,528

So this is the way we're going to run software in the future.

Cue 50 — 00:02:40,908 --> 00:02:43,828

And then eventually you just throw away all the git history,

Cue 51 — 00:02:43,868 --> 00:02:45,228

everything. That doesn't matter either.

Cue 52 — 00:02:45,268 --> 00:02:47,388

You don't care how the code was created.

Cue 53 — 00:02:47,428 --> 00:02:49,588

Completely gone, completely irrelevant.

Cue 54 — 00:02:49,628 --> 00:02:52,428

So this is how I think. This is how I build software.

Cue 55 — 00:02:52,468 --> 00:02:55,108

Now I might have just lost my mind.

Cue 56 — 00:02:55,148 --> 00:02:58,468

This could be LLM psychosis, but I think probably not.

Cue 57 — 00:02:58,508 --> 00:03:01,088

So hopefully you'll not believe that's true.

Cue 58 — 00:03:01,228 --> 00:03:05,228

And a little bit of proof I've been I've been talking about this stuff not just

Cue 59 — 00:03:05,268 --> 00:03:10,228

since ChatGPT came out. I've been talking about this since at least 2013,

Cue 60 — 00:03:10,268 --> 00:03:13,608

though. Actually, the ideas behind this talk go back two decades,

Cue 61 — 00:03:13,788 --> 00:03:17,908

where I have spent a lot of time thinking about how we build systems that can

Cue 62 — 00:03:17,948 --> 00:03:21,108

survive because I spent a long time as a system euthanizer.

Cue 63 — 00:03:21,148 --> 00:03:24,188

So I go along to companies that have broken systems.

Cue 64 — 00:03:24,228 --> 00:03:26,388

They're trying to replace them, do big rewrites.

Cue 65 — 00:03:26,428 --> 00:03:31,292

I wrote a very popular article series in 2006 bemoaning the fact that I was a

Cue 66 — 00:03:31,332 --> 00:03:35,388

software euthanizer called The Big Rewrite that was on the homepage of Digg.

Cue 67 — 00:03:35,428 --> 00:03:37,188

So that tells you how how old that was.

Cue 68 — 00:03:37,228 --> 00:03:39,048

But that was a big deal back then.

Cue 69 — 00:03:39,748 --> 00:03:45,588

And I wrote this, this article in 2013 where I think I originally coined the term

Cue 70 — 00:03:45,628 --> 00:03:48,188

immutable infrastructure, which is what we all said about like,

Cue 71 — 00:03:48,228 --> 00:03:50,868

Docker and that sort of style of deployments at the time.

Cue 72 — 00:03:50,908 --> 00:03:55,108

At the same time, though, I wasn't just talking about immutable infrastructure,

Cue 73 — 00:03:55,148 --> 00:03:56,948

I was talking about disposable code.

Cue 74 — 00:03:56,988 --> 00:04:03,388

So back then, 13 years ago, I was thinking of code as disposable artifacts of the

Cue 75 — 00:04:03,428 --> 00:04:08,268

development process and and starting to build systems and architectures around what

Cue 76 — 00:04:08,308 --> 00:04:10,988

would make that okay, and why would I want to make that?

Cue 77 — 00:04:11,028 --> 00:04:12,748

Okay. So I'm going to set up a little bit of that.

Cue 78 — 00:04:12,788 --> 00:04:15,588

Why now? This was a bit crazy back then.

Cue 79 — 00:04:15,628 --> 00:04:19,588

Like throwing away code and just thinking of code as as disposable.

Cue 80 — 00:04:19,628 --> 00:04:23,708

It seems probably a little less crazy today, but for some of you probably still

Cue 81 — 00:04:23,748 --> 00:04:27,348

feels kind of strange, right? The idea that code is a disposable artifact,

Cue 82 — 00:04:27,388 --> 00:04:29,208

you just regenerate it when you want.

Cue 83 — 00:04:29,748 --> 00:04:31,708

But here, here's a bit of the motivation.

Cue 84 — 00:04:31,748 --> 00:04:38,508

So I was CTO for a company building something called Wunderlist back in 2014 when

Cue 85 — 00:04:38,548 --> 00:04:40,628

the infamous Heartbleed bug happened.

Cue 86 — 00:04:40,668 --> 00:04:42,478

Anyone remember the Heartbleed bug?

Cue 87 — 00:04:42,518 --> 00:04:45,068

You know, if you've got gray hair, it might have come from that day,

Cue 88 — 00:04:45,108 --> 00:04:50,108

right? I woke up, I was in Berlin, and I woke up to a message from my colleague

Cue 89 — 00:04:50,148 --> 00:04:54,468

Duncan, and it just said, we have to shut off all the servers.

Cue 90 — 00:04:54,508 --> 00:04:56,548

And I was like, I don't know what you're talking about.

Cue 91 — 00:04:56,588 --> 00:04:59,748

You must have sent this to the wrong person because you've just sent a message to

Cue 92 — 00:04:59,788 --> 00:05:03,988

your CTO. And he was literally telling me, shut off all the servers for Wunderlist,

Cue 93 — 00:05:04,028 --> 00:05:09,668

because what Heartbleed did is it led anyone that was running a broken version of

Cue 94 — 00:05:09,708 --> 00:05:12,468

the OpenSSL library, which everyone was at the time.

Cue 95 — 00:05:12,508 --> 00:05:14,868

Scrape any data, private data.

Cue 96 — 00:05:14,908 --> 00:05:19,108

So all user sessions were public suddenly, which means to keep the server running

Cue 97 — 00:05:19,148 --> 00:05:23,428

was absolutely irresponsible. And just so you know, there are still over 200,000

Cue 98 — 00:05:23,468 --> 00:05:25,508

servers with this bug on the internet today.

Cue 99 — 00:05:25,548 --> 00:05:28,208

So some people were a little slower than we were.

Cue 100 — 00:05:28,308 --> 00:05:33,248

We fixed it that day. In fact, we fixed it within a couple of hours,

Cue 101 — 00:05:33,388 --> 00:05:37,128

and we had something like 85 servers running in production.

Cue 102 — 00:05:37,228 --> 00:05:41,228

So how did we do this? Well, we were already thinking of servers as being

Cue 103 — 00:05:41,268 --> 00:05:46,428

disposable. And the immutable infrastructure idea was whenever you make any change

Cue 104 — 00:05:46,468 --> 00:05:50,468

to code or any configuration, you don't go into the server and change it and fix it.

Cue 105 — 00:05:50,508 --> 00:05:53,628

You don't go mutate it. That's why it's called immutable infrastructure.

Cue 106 — 00:05:53,668 --> 00:05:56,268

Instead, you make a whole new server image.

Cue 107 — 00:05:56,308 --> 00:05:59,028

You throw away all the other servers and you bring up new ones,

Cue 108 — 00:05:59,068 --> 00:06:02,808

not physical servers. Obviously, that would be pretty expensive and time consuming.

Cue 109 — 00:06:03,348 --> 00:06:07,348

So we were able to just say, well, I guess we need a new version of the OpenSSL

Cue 110 — 00:06:07,388 --> 00:06:12,068

library, SSL library everywhere, and just push it out to production in 80 plus

Cue 111 — 00:06:12,108 --> 00:06:14,508

instances that we're running in production.

Cue 112 — 00:06:14,548 --> 00:06:17,908

And then we sat with the servers off for the rest of the day,

Cue 113 — 00:06:17,948 --> 00:06:21,348

waiting for Amazon to catch up so that we could actually deploy because the load

Cue 114 — 00:06:21,388 --> 00:06:22,788

balancers were still vulnerable.

Cue 115 — 00:06:22,828 --> 00:06:24,468

So it didn't make sense to turn on yet.

Cue 116 — 00:06:24,508 --> 00:06:29,388

But we were faster than pretty much anyone, and it was because of the ideas that led

Cue 117 — 00:06:29,428 --> 00:06:32,548

to this talk and all the ideas that I have around regenerative software that we were

Cue 118 — 00:06:32,588 --> 00:06:36,708

able to do that. So this was the good version of it where we had implemented this,

Cue 119 — 00:06:36,748 --> 00:06:40,528

we were ready and we could do anything like this at any point.

Cue 120 — 00:06:40,708 --> 00:06:46,268

Uptime was an anti-pattern for us down or like a minimal amount of uptime per server

Cue 121 — 00:06:46,308 --> 00:06:48,908

is what we were looking for. If a server was up for more than an hour,

Cue 122 — 00:06:48,948 --> 00:06:51,948

we'd go, oh, that's kind of gross, because what if we don't know how to change it in

Cue 123 — 00:06:51,988 --> 00:06:57,228

the future? Same team a little bit earlier than that.

Cue 124 — 00:06:57,268 --> 00:07:02,068

We had not yet done the disposable components thing, and we were in the midst of a

Cue 125 — 00:07:02,108 --> 00:07:05,628

big slow rewrite from a bad architecture to a good one.

Cue 126 — 00:07:05,668 --> 00:07:11,308

I was doing my system euthanizer thing again, and we tried to make a change that was

Cue 127 — 00:07:11,348 --> 00:07:14,548

a migration to like the most simple service that we could find,

Cue 128 — 00:07:14,588 --> 00:07:16,308

like, let's just find the easy thing.

Cue 129 — 00:07:16,348 --> 00:07:18,468

And it was just a very simple Rails service.

Cue 130 — 00:07:18,508 --> 00:07:20,828

We extracted it into a separate microservice.

Cue 131 — 00:07:20,868 --> 00:07:23,588

It was like group memberships or something with, okay, this is the one.

Cue 132 — 00:07:23,628 --> 00:07:25,108

It's nothing but like a join table.

Cue 133 — 00:07:25,148 --> 00:07:30,108

Basically, we went in on a Saturday afternoon, we deployed this change,

Cue 134 — 00:07:30,148 --> 00:07:33,748

and then something like 48 hours later we finally left the office.

Cue 135 — 00:07:33,788 --> 00:07:39,068

I was so tired. I wrecked my bike, and I was limping for months afterward because

Cue 136 — 00:07:39,108 --> 00:07:43,868

what we had not thought of is all of the non code related stuff the data,

Cue 137 — 00:07:43,908 --> 00:07:47,488

the state, the dependencies outside of the code that we could see.

Cue 138 — 00:07:47,868 --> 00:07:51,848

So even this thing was even though this thing was tiny, it wasn't replaceable.

Cue 139 — 00:07:52,188 --> 00:07:57,908

So I'm going to talk about these sort of these approaches and how how they are at

Cue 140 — 00:07:57,948 --> 00:07:59,388

different ends of the spectrum.

Cue 141 — 00:07:59,428 --> 00:08:03,148

And how if you try to make the code more like the server story and think about

Cue 142 — 00:08:03,188 --> 00:08:07,328

boundaries and stuff, you can make systems that can continuously evolve.

Cue 143 — 00:08:07,788 --> 00:08:12,668

So as I have been talking about these ideas of systems that continuously regenerate

Cue 144 — 00:08:12,708 --> 00:08:15,468

themselves and not looking at code, all this stuff, people act like,

Cue 145 — 00:08:15,508 --> 00:08:17,528

oh, this is irresponsible, right?

Cue 146 — 00:08:18,068 --> 00:08:20,148

That's the first result or first response.

Cue 147 — 00:08:20,188 --> 00:08:23,248

And some of you kind of chuckled too as I was going through those bullets.

Cue 148 — 00:08:23,668 --> 00:08:28,228

But if you go back in time and the first one for me that I'll mention is extreme

Cue 149 — 00:08:28,268 --> 00:08:32,348

programming and agile, when that came out, everyone talked about that.

Cue 150 — 00:08:32,388 --> 00:08:35,348

Like that was crazy. Like, oh, you're taking all the rigor out of the process.

Cue 151 — 00:08:35,388 --> 00:08:38,388

What about waterfall? What about all the planning and the specs and all the stuff

Cue 152 — 00:08:38,428 --> 00:08:40,848

that you do before you build the code?

Cue 153 — 00:08:41,268 --> 00:08:46,588

But what XP did is it turned the cycle around and made it fast and made it really

Cue 154 — 00:08:46,628 --> 00:08:51,628

iterative. And rather than removing rigor from the process, it actually increased it

Cue 155 — 00:08:51,668 --> 00:08:56,148

because you had more data, more constant streams of data that you could use to make

Cue 156 — 00:08:56,188 --> 00:09:00,228

decisions. So you wouldn't have six month processes, you'd have one week process or

Cue 157 — 00:09:00,268 --> 00:09:03,548

two week process that would give you feedback, and you'd know where the team needs

Cue 158 — 00:09:03,588 --> 00:09:08,588

to adjust. Same thing happened with Ruby, Rails, Python, you know,

Cue 159 — 00:09:08,628 --> 00:09:12,028

the dynamic language shift. All the Java people were freaked out.

Cue 160 — 00:09:12,068 --> 00:09:14,248

Like, what are you going to do without static types?

Cue 161 — 00:09:14,388 --> 00:09:18,628

And what did we do? Well, we replaced static types with good software engineering

Cue 162 — 00:09:18,668 --> 00:09:22,348

practices and a bunch of the stuff that we all do today came actually from the Ruby

Cue 163 — 00:09:22,388 --> 00:09:27,108

community. It was at least amplified by the Ruby community because we were in there

Cue 164 — 00:09:27,148 --> 00:09:30,868

trying to make it okay to use this crazy language that was irresponsible to use,

Cue 165 — 00:09:30,908 --> 00:09:33,608

that has all this coupling and weirdness to it.

Cue 166 — 00:09:34,468 --> 00:09:36,868

Continuous delivery or continuous deployment?

Cue 167 — 00:09:36,908 --> 00:09:40,828

Same thing. You replaced deployment windows with some other way.

Cue 168 — 00:09:40,868 --> 00:09:46,308

And basically you can see like these are rigorous processes that sound crazy at

Cue 169 — 00:09:46,348 --> 00:09:51,508

first and then actually lead to better rigor and more checkpoints and more data

Cue 170 — 00:09:51,548 --> 00:09:54,868

driven decisions. And so that's, that's, I believe, where we are today with

Cue 171 — 00:09:54,908 --> 00:09:58,748

regeneration, rather than thinking about code, is the thing that you have to sit and

Cue 172 — 00:09:58,788 --> 00:10:03,508

hold on to and fetishize. You can let go of it.

Cue 173 — 00:10:03,548 --> 00:10:05,428

And where will the rigor come now?

Cue 174 — 00:10:05,468 --> 00:10:10,628

Where will we apply it? And if you do delete all the code, does that mean you throw

Cue 175 — 00:10:10,668 --> 00:10:12,668

away the whole system? Well, no, of course not.

Cue 176 — 00:10:12,708 --> 00:10:14,668

The idea is throw away the code.

Cue 177 — 00:10:14,708 --> 00:10:19,148

Keep the system. How do you get rid of the code and still keep the system identity?

Cue 178 — 00:10:19,188 --> 00:10:21,188

Well, I will say it's these four things.

Cue 179 — 00:10:21,228 --> 00:10:24,028

One thing you must capture is intent.

Cue 180 — 00:10:24,068 --> 00:10:26,188

That's. That's what must stay true.

Cue 181 — 00:10:26,228 --> 00:10:29,308

As you continue to throw the code away and regenerate it.

Cue 182 — 00:10:29,348 --> 00:10:30,788

So what did you want it to do?

Cue 183 — 00:10:30,828 --> 00:10:34,728

Right? And then what is the architecture of the system?

Cue 184 — 00:10:34,908 --> 00:10:38,468

And I assert, and I have for many years, that the architecture of the system and the

Cue 185 — 00:10:38,508 --> 00:10:40,508

system itself is the asset that you're building.

Cue 186 — 00:10:40,548 --> 00:10:43,988

The code is just this liability that you're inserting and you need to throw away.

Cue 187 — 00:10:44,028 --> 00:10:45,908

But it's the architecture that matters.

Cue 188 — 00:10:45,948 --> 00:10:50,908

In this case, it's not going to be just like which framework you're using.

Cue 189 — 00:10:50,948 --> 00:10:52,588

It's higher level than that in this framework.

Cue 190 — 00:10:52,628 --> 00:10:58,748

And language agnostic and then evaluations, people say evals all the time and AI

Cue 191 — 00:10:58,788 --> 00:11:02,268

land. And it makes my eyes glaze over because I think most people have their own

Cue 192 — 00:11:02,308 --> 00:11:05,428

definition of what that means in my world.

Cue 193 — 00:11:05,468 --> 00:11:10,676

And evaluation means essentially a test suite, an assertion of a bunch of intents

Cue 194 — 00:11:10,716 --> 00:11:13,308

that is not tied to the implementation at all.

Cue 195 — 00:11:13,348 --> 00:11:17,188

So if you have a web app written in Python and you replace it with a distributed

Cue 196 — 00:11:17,228 --> 00:11:20,828

system written in Rust, the evals still have to work.

Cue 197 — 00:11:20,868 --> 00:11:22,048

And that's what these are.

Cue 198 — 00:11:23,268 --> 00:11:27,348

And then the last thing is here we have provenance.

Cue 199 — 00:11:27,388 --> 00:11:29,288

Where did the decisions come from?

Cue 200 — 00:11:30,068 --> 00:11:32,628

And by the way, if you're taking pictures of the slides you may do that.

Cue 201 — 00:11:32,668 --> 00:11:37,068

But I also have a link on the slides that I'll go to at the end that has the

Cue 202 — 00:11:37,108 --> 00:11:39,648

permanent version, so you don't have to take pictures.

Cue 203 — 00:11:40,988 --> 00:11:43,908

So why was the decision made? Who made it?

Cue 204 — 00:11:43,948 --> 00:11:47,148

What was the context? Because, you know, think like I've been in companies where

Cue 205 — 00:11:47,188 --> 00:11:50,108

code was written 20 years ago and we look at some weird thing,

Cue 206 — 00:11:50,148 --> 00:11:51,068

we're like, what the hell is this?

Cue 207 — 00:11:51,108 --> 00:11:53,168

Where did this come from? It makes no sense.

Cue 208 — 00:11:53,228 --> 00:11:55,988

You can't go talk to the person that built it because maybe they died.

Cue 209 — 00:11:56,028 --> 00:11:59,628

You know, it's like a long time ago, or they've moved on and it's like five

Cue 210 — 00:11:59,668 --> 00:12:02,088

companies ago and they wouldn't even remember, right?

Cue 211 — 00:12:02,468 --> 00:12:06,748

I believe we have to. And we now can for the first time, because things like Granola

Cue 212 — 00:12:06,788 --> 00:12:11,228

and all this AI stuff, we can start to capture this provenance and actually

Cue 213 — 00:12:11,268 --> 00:12:13,628

understand who made the decision why, etc.

Cue 214 — 00:12:13,668 --> 00:12:18,908

and that should be feedback and linked in permanently into the record of the code

Cue 215 — 00:12:18,948 --> 00:12:20,328

that gets created.

Cue 216 — 00:12:21,548 --> 00:12:25,228

So a test for you and this is just a mental model test.

Cue 217 — 00:12:25,268 --> 00:12:30,388

I don't recommend necessarily doing it on the systems that you currently have that

Cue 218 — 00:12:30,428 --> 00:12:34,348

you maintain. What if you went into the project and just remove the whole source

Cue 219 — 00:12:34,388 --> 00:12:38,508

tree of the project? How bad would that be like?

Cue 220 — 00:12:38,548 --> 00:12:40,548

And of course you've got git. Pretend you don't have git.

Cue 221 — 00:12:40,588 --> 00:12:42,968

You have no backup. You have to remove source.

Cue 222 — 00:12:43,148 --> 00:12:45,148

You've got all your humans that know the system.

Cue 223 — 00:12:45,188 --> 00:12:48,308

You've got, you know the legacy of the system running.

Cue 224 — 00:12:48,348 --> 00:12:52,948

What would it take and what are you missing to be able to quickly regenerate this,

Cue 225 — 00:12:52,988 --> 00:12:54,908

you know, quickly it could mean six months.

Cue 226 — 00:12:54,948 --> 00:12:57,728

It could mean today. It could mean the end of the week.

Cue 227 — 00:12:57,788 --> 00:13:01,908

That's kind of my mental model for thinking about this, for thinking about what

Cue 228 — 00:13:01,948 --> 00:13:03,988

software development means today.

Cue 229 — 00:13:04,028 --> 00:13:07,548

That's what it means figuring this stuff out and working on this stuff.

Cue 230 — 00:13:07,588 --> 00:13:13,548

Right. And then the other thing is, architecturally, we tend to carry around baggage

Cue 231 — 00:13:13,588 --> 00:13:16,568

that is just the output of coding.

Cue 232 — 00:13:16,748 --> 00:13:18,908

So most architectures are accidents.

Cue 233 — 00:13:18,948 --> 00:13:21,548

They just, you know, architectures evolve and they turn into these weird

Cue 234 — 00:13:21,588 --> 00:13:26,988

Frankenstein things. And what I've found, even in my most recent experiments,

Cue 235 — 00:13:27,028 --> 00:13:29,748

is that I end up with what looked like architectural decisions,

Cue 236 — 00:13:29,788 --> 00:13:32,628

and they're actually just workarounds for technology problems.

Cue 237 — 00:13:32,668 --> 00:13:36,788

So I'm building like a decentralized chat system that has a bunch of threading

Cue 238 — 00:13:36,828 --> 00:13:41,508

stuff. And I discovered there were just like 70 locks built into the system,

Cue 239 — 00:13:41,548 --> 00:13:44,548

thread locks, like what is going on here?

Cue 240 — 00:13:44,588 --> 00:13:50,828

Well, it all stemmed from the way that I, I evolved the system by prompting over

Cue 241 — 00:13:50,868 --> 00:13:55,548

time, and I ended up with this thing that felt like an architectural decision was

Cue 242 — 00:13:55,588 --> 00:14:00,628

actually an accident. So if I regenerated the system tomorrow,

Cue 243 — 00:14:00,668 --> 00:14:04,308

should that exist? No. And that's the sort of thing you need to be able to extract

Cue 244 — 00:14:04,348 --> 00:14:06,328

out of the systems that you're building today.

Cue 245 — 00:14:08,188 --> 00:14:11,948

And then code. Probably pretty obvious here as I've been talking.

Cue 246 — 00:14:11,988 --> 00:14:14,188

Ends up just being a compiled artifact.

Cue 247 — 00:14:14,228 --> 00:14:17,548

You think about, like if you're a Java developer, you use Ant or Maven or whatever

Cue 248 — 00:14:17,588 --> 00:14:21,628

the source code ends up going and creating these class files.

Cue 249 — 00:14:21,668 --> 00:14:23,408

Same in all the other languages.

Cue 250 — 00:14:23,748 --> 00:14:26,148

I think the source code is now one of those things.

Cue 251 — 00:14:26,188 --> 00:14:27,868

And literally I don't read it.

Cue 252 — 00:14:27,908 --> 00:14:30,668

I don't read dot class files either, other than for fun, you know,

Cue 253 — 00:14:30,708 --> 00:14:33,688

to understand how the JVM works and the bytecode works.

Cue 254 — 00:14:34,788 --> 00:14:40,188

In addition to that, though, the actual code that gets generated and the generation

Cue 255 — 00:14:40,228 --> 00:14:44,268

target shouldn't be code in a programming language.

Cue 256 — 00:14:44,308 --> 00:14:47,948

So as I said, I'm not thinking about generating TypeScript or Rust or Elixir or

Cue 257 — 00:14:47,988 --> 00:14:53,188

something. I'm thinking about generating units of implementation which happened to

Cue 258 — 00:14:53,228 --> 00:14:57,128

be in TypeScript, Rust, Elixir, etc.

Cue 259 — 00:14:57,628 --> 00:15:01,588

because I'm compiling to an architecture and it gives me flexibility to change

Cue 260 — 00:15:01,628 --> 00:15:06,428

everything. You know, if, like, Node gets compromised, or npm.

Cue 261 — 00:15:06,468 --> 00:15:09,008

Oh, that's hard to imagine after October.

Cue 262 — 00:15:09,228 --> 00:15:13,548

What if you had to swap completely off of an ecosystem like that because you just

Cue 263 — 00:15:13,588 --> 00:15:17,328

discover it's compromised? Insecure isn't going to work.

Cue 264 — 00:15:17,508 --> 00:15:20,028

Think about how hard that would be today in your current environment.

Cue 265 — 00:15:20,068 --> 00:15:22,308

Probably impossible. You'd have to start over.

Cue 266 — 00:15:22,348 --> 00:15:25,548

That's the way it's been for most of the stuff I built in my career until ten years

Cue 267 — 00:15:25,588 --> 00:15:28,948

ago or so, and this is the way I've been building things since slowly,

Cue 268 — 00:15:28,988 --> 00:15:31,128

with human hands instead of with AI.

Cue 280 — 00:16:13,222 --> 00:16:17,726

And so you end up with this loop that it might look factory ish,

Cue 281 — 00:16:17,766 --> 00:16:21,886

but I think this is a higher level concept than software factories where you're

Cue 282 — 00:16:21,926 --> 00:16:23,446

capturing some sort of intent.

Cue 283 — 00:16:23,486 --> 00:16:26,166

And you'll see here it says from a spec or from conversations,

Cue 284 — 00:16:26,206 --> 00:16:30,286

I think that's really important, like ambient conversations and team meetings about

Cue 285 — 00:16:30,326 --> 00:16:34,806

products, about features, about requirements, about compliance requirements that

Cue 286 — 00:16:34,846 --> 00:16:41,606

aren't even technical can all feed in as input to a system that grabs the intent out

Cue 287 — 00:16:41,646 --> 00:16:44,926

of all this raw stuff. And hey, LLMs are really good at this.

Cue 288 — 00:16:44,966 --> 00:16:48,866

And Jev-like models are really good at doing this cheaply.

Cue 289 — 00:16:48,926 --> 00:16:51,986

Compile that into actual intent.

Cue 290 — 00:16:52,086 --> 00:16:56,326

And from that, then you start planning against an architecture that a human has

Cue 291 — 00:16:56,366 --> 00:17:00,486

probably created. Which implementation units do I need to generate?

Cue 292 — 00:17:00,526 --> 00:17:04,926

Like what are the actual sort of packages that need to technically be created based

Cue 293 — 00:17:04,966 --> 00:17:09,546

on these requirements? And from there you generate the code.

Cue 294 — 00:17:09,846 --> 00:17:14,646

You verify through evals. And you do that both statically before you deploy and

Cue 295 — 00:17:14,686 --> 00:17:17,846

dynamically from production. And this is a very important point.

Cue 296 — 00:17:17,886 --> 00:17:23,646

We can do this now. You deploy it and you maximize observability for the things you

Cue 297 — 00:17:23,686 --> 00:17:25,726

care about. And those are the things that were in the metrics,

Cue 298 — 00:17:25,766 --> 00:17:28,766

in the in the evals. And the observability.

Cue 299 — 00:17:28,806 --> 00:17:33,406

Data from production comes back into the top of the system and it's a loop.

Cue 300 — 00:17:33,446 --> 00:17:37,266

So production is now informing the system as an example.

Cue 301 — 00:17:37,306 --> 00:17:38,566

Maybe I have it on the next slide.

Cue 302 — 00:17:38,606 --> 00:17:40,706

Let's see. I don't but as an example

Cue 303 — 00:17:41,926 --> 00:17:45,206

imagine you have a performance requirement and it says this page needs to load.

Cue 304 — 00:17:45,246 --> 00:17:47,446

I'm going to go back here. So you don't think that slides related.

Cue 305 — 00:17:47,486 --> 00:17:50,166

This page needs to load in 300 milliseconds.

Cue 306 — 00:17:50,206 --> 00:17:51,686

You deploy. You go for months.

Cue 307 — 00:17:51,726 --> 00:17:53,886

It loads in 300 milliseconds. Cool.

Cue 308 — 00:17:53,926 --> 00:17:56,246

And then something happens like your site gets popular.

Cue 309 — 00:17:56,286 --> 00:17:57,926

Suddenly it doesn't do that anymore.

Cue 310 — 00:17:57,966 --> 00:18:04,686

The implementation now fails. So in a system like this, the output of production

Cue 311 — 00:18:04,726 --> 00:18:08,166

goes back into the top and it says you have one requirement that's not working

Cue 312 — 00:18:08,206 --> 00:18:11,646

anymore. We need to regenerate that somehow, whatever that means.

Cue 313 — 00:18:11,686 --> 00:18:17,246

And the AI goes and does it until the evals and production go back and the loop

Cue 314 — 00:18:17,286 --> 00:18:22,046

says, okay. The output of production says this is good, so you've done the needful.

Cue 315 — 00:18:22,086 --> 00:18:26,766

Now, if you were a developer before this era, you were already doing this in the

Cue 316 — 00:18:26,806 --> 00:18:28,746

best case. But it was very slow.

Cue 317 — 00:18:28,846 --> 00:18:30,926

In most cases. You were not doing this right.

Cue 318 — 00:18:30,966 --> 00:18:34,006

You just deploy, someone complains about something, you go fix it.

Cue 319 — 00:18:34,046 --> 00:18:37,846

We have the ability to now do this, to actually measure the requirements of the

Cue 320 — 00:18:37,886 --> 00:18:41,546

system and find where they're failing and fix those failures.

Cue 321 — 00:18:43,086 --> 00:18:44,686

And I talked about this a little bit.

Cue 322 — 00:18:44,726 --> 00:18:48,326

But you know, people talk about specifications being documents that sort of the

Cue 323 — 00:18:48,366 --> 00:18:52,366

assumption. Right. A big word document markdown document, Google Doc or whatever.

Cue 324 — 00:18:52,406 --> 00:18:56,366

That is not what a spec should be anymore because those are for humans to write and

Cue 325 — 00:18:56,406 --> 00:19:00,566

read. We need we need projections that humans can read and understand.

Cue 326 — 00:19:00,606 --> 00:19:02,966

But we shouldn't be writing documents as the spec.

Cue 327 — 00:19:03,006 --> 00:19:07,046

You shouldn't be spending time on documents, certainly not on the prose.

Cue 328 — 00:19:07,086 --> 00:19:11,406

What you really need is a collection of assertions about what the system can do.

Cue 329 — 00:19:11,446 --> 00:19:15,086

And so in my worldview, specs are actually some sort of data structure.

Cue 330 — 00:19:15,126 --> 00:19:18,966

And specifically in my worldview, it's some sort of graph database that connects all

Cue 331 — 00:19:19,006 --> 00:19:21,566

of these things as nodes and edges in a graph.

Cue 332 — 00:19:21,606 --> 00:19:25,206

And when I need to see a document, I just create the document by asking the genie to

Cue 333 — 00:19:25,246 --> 00:19:28,686

create the document. And when I need to see it in some other format,

Cue 334 — 00:19:28,726 --> 00:19:33,466

I do that, but I update it as a canonical graph database of some sort.

Cue 335 — 00:19:34,456 --> 00:19:37,926

And so I have an example of this an open source library.

Cue 336 — 00:19:37,966 --> 00:19:42,546

It's linked. You can see github.com Chad Phoenix there.

Cue 337 — 00:19:42,846 --> 00:19:45,966

It's called Phoenix because I started writing about this calling it the Phoenix

Cue 338 — 00:19:46,006 --> 00:19:48,246

architecture. And this is how it works.

Cue 339 — 00:19:48,286 --> 00:19:53,686

So I have raw text, you know, markdown documents, whatever.

Cue 340 — 00:19:53,726 --> 00:19:58,706

Just it could be random conversations that happen to have references to a system.

Cue 341 — 00:19:58,766 --> 00:20:01,166

I then extract clauses from that.

Cue 342 — 00:20:01,206 --> 00:20:05,006

And those are the things where you separate, like, well, how are your kids from the

Cue 343 — 00:20:05,046 --> 00:20:08,926

system needs to have a checkout flow that is different for different countries,

Cue 344 — 00:20:08,966 --> 00:20:12,606

you know, that sort of thing. So you can extract these clauses and then you

Cue 345 — 00:20:12,646 --> 00:20:15,646

canonicalize those into nodes in the graph like I was talking about.

Cue 346 — 00:20:15,686 --> 00:20:18,586

So you create specifications in a data structure.

Cue 347 — 00:20:18,926 --> 00:20:24,566

So now you've got like the bare minimum Dom spec doc or structure or whatever you

Cue 348 — 00:20:24,606 --> 00:20:27,826

want to call it that humans could think of at first.

Cue 349 — 00:20:28,406 --> 00:20:31,406

Now you can start to enhance that with the machine to say, well,

Cue 350 — 00:20:31,446 --> 00:20:33,846

what specs are probably missing, what metrics might be missing,

Cue 351 — 00:20:33,886 --> 00:20:35,926

what production like SLOs, etc.

Cue 352 — 00:20:35,966 --> 00:20:40,526

that might be missing? Enhance those by iterating with the user or even suggesting

Cue 353 — 00:20:40,566 --> 00:20:46,426

some user being human. So then you create this canonical set of nodes,

Cue 354 — 00:20:46,486 --> 00:20:48,486

and then you plan these implementation units.

Cue 355 — 00:20:48,526 --> 00:20:51,526

And that's the thing I was talking about like well have a service or some sort of

Cue 356 — 00:20:51,566 --> 00:20:55,166

service like object that does account management, for example.

Cue 357 — 00:20:55,206 --> 00:20:57,686

We're not saying it's in Rust, we're not saying it's in TypeScript,

Cue 358 — 00:20:57,726 --> 00:21:01,486

and we're not saying it's in some framework, but it's a thing that needs to exist

Cue 359 — 00:21:01,526 --> 00:21:07,246

for the system to exist. Then we generate the code, and the code is linked all the

Cue 360 — 00:21:07,286 --> 00:21:12,686

way back to the beginning to the literal lines in some log of a meeting you had,

Cue 361 — 00:21:12,726 --> 00:21:17,606

or from a document you wrote, then you go ahead and deploy to production.

Cue 362 — 00:21:17,646 --> 00:21:19,326

You get evidence and that's the loop.

Cue 363 — 00:21:19,366 --> 00:21:23,006

And so this actually works. This is an open source library.

Cue 364 — 00:21:23,046 --> 00:21:25,966

I don't remember what language it's written in, but it works.

Cue 365 — 00:21:26,006 --> 00:21:27,726

So you can this is sort of proof.

Cue 366 — 00:21:27,766 --> 00:21:29,926

The proof is in the pudding. Check it out.

Cue 367 — 00:21:29,966 --> 00:21:33,526

It's a proof of concept. Don't you can try to use it for production.

Cue 368 — 00:21:33,566 --> 00:21:37,166

I know some people are, but that's not the idea here, so it'll probably break a lot.

Cue 369 — 00:21:37,206 --> 00:21:40,586

But you can just go back in time until it works in the git history.

Cue 370 — 00:21:40,966 --> 00:21:42,406

And this is what it lets you do.

Cue 371 — 00:21:42,446 --> 00:21:43,886

So this is just a visualization.

Cue 372 — 00:21:43,926 --> 00:21:49,646

It creates. Imagine you have one requirement that that was originally written down

Cue 373 — 00:21:49,686 --> 00:21:53,346

in library.md. And if you can't read all this I'm talking to it anyway.

Cue 374 — 00:21:53,406 --> 00:21:57,246

So that generates these clauses that I was talking about that generates these

Cue 375 — 00:21:57,286 --> 00:21:59,686

canonical actual specification nodes.

Cue 376 — 00:21:59,726 --> 00:22:03,726

Those are tied to implementation units and those are tied to actual implementation

Cue 377 — 00:22:03,766 --> 00:22:06,546

source files. So we've got like TS files on the end.

Cue 378 — 00:22:06,646 --> 00:22:11,206

Now what you can do with Phoenix and with this sort of an architecture is you can go

Cue 379 — 00:22:11,246 --> 00:22:15,006

over here and you can change summary.ts and change like a line in it,

Cue 380 — 00:22:15,046 --> 00:22:17,346

you know, one of those weird hardcoded numbers.

Cue 381 — 00:22:17,526 --> 00:22:22,366

And then you can visualize, you can see like okay now I've invalidated the

Cue 382 — 00:22:22,406 --> 00:22:27,686

specification here. So this shows like one path that that is set.

Cue 383 — 00:22:27,726 --> 00:22:33,566

Or change one line in the spec document and just regenerate only the lines in the

Cue 384 — 00:22:33,606 --> 00:22:39,066

file, the smallest unit possible on the other side that are affected by that.

Cue 385 — 00:22:39,446 --> 00:22:43,926

So try it. Try it out. It'll give you a good sort of concrete sense of what this

Cue 386 — 00:22:43,966 --> 00:22:46,326

thing is about, what the architecture is about.

Cue 387 — 00:22:46,366 --> 00:22:50,836

And and please have your agent give my agent PRs.

Cue 388 — 00:22:50,876 --> 00:22:52,426

I'll accept them. So,

Cue 389 — 00:22:53,966 --> 00:22:55,606

I talked about evaluations already.

Cue 390 — 00:22:55,646 --> 00:22:57,686

Evaluations should be meant to survive.

Cue 391 — 00:22:57,726 --> 00:23:03,486

Rewrites. I'm guessing zero people here have evaluations that could survive a full

Cue 392 — 00:23:03,526 --> 00:23:08,126

rewrite of your system. And could be used to actually check whether the the system

Cue 393 — 00:23:08,166 --> 00:23:11,086

is correct if you do a full rewrite, because why would you have done that in the

Cue 394 — 00:23:11,126 --> 00:23:14,416

past? Right. But now is the time you can and you should do that.

Cue 395 — 00:23:14,456 --> 00:23:17,046

And that's what software engineering is about, this kind of stuff.

Cue 396 — 00:23:17,086 --> 00:23:18,306

This is the rigor.

Cue 397 — 00:23:20,246 --> 00:23:23,166

Okay? I won't play this whole video because I'll run out of time.

Cue 398 — 00:23:23,206 --> 00:23:29,966

But when you go to the website that has this presentation on

Cue 399 — 00:23:30,006 --> 00:23:35,986

it, you'll see this is actually the the Q&A thing that I was talking about.

Cue 400 — 00:23:36,086 --> 00:23:40,606

And in the video, the demo, this is a live demo that I recorded.

Cue 401 — 00:23:40,646 --> 00:23:44,926

It goes and it just changes one line in the spec document.

Cue 402 — 00:23:44,966 --> 00:23:48,686

So basically it was like under specified, you run it in production.

Cue 403 — 00:23:48,726 --> 00:23:51,206

There was another bug, so it changes the one line.

Cue 404 — 00:23:51,246 --> 00:23:56,586

Then the evals get changed. So this is the Phoenix thing and in action.

Cue 405 — 00:23:57,806 --> 00:24:01,326

And then Phoenix ingests this change basically.

Cue 406 — 00:24:01,366 --> 00:24:07,726

Re-canonicalizes all this stuff finds the path through the the implementation and

Cue 407 — 00:24:07,766 --> 00:24:11,206

regenerates it and only regenerates the one piece that needs to change,

Cue 408 — 00:24:11,246 --> 00:24:17,806

not the entire thing. And the last thing on this demo, I am going to let it play

Cue 409 — 00:24:17,846 --> 00:24:23,646

because it's cool enough is what if now you wanted to reimplement this in a

Cue 410 — 00:24:23,686 --> 00:24:26,766

different language? So it's running in TypeScript right now and you say,

Cue 411 — 00:24:26,806 --> 00:24:31,926

you know what, I want to I want to actually have this be in Python.

Cue 412 — 00:24:31,966 --> 00:24:34,066

I've decided I'd prefer to have Python.

Cue 413 — 00:24:34,246 --> 00:24:38,506

You can now just say, okay, it all passes, I've deployed, I've changed the stuff.

Cue 414 — 00:24:38,566 --> 00:24:42,946

You can regenerate in another target architecture.

Cue 415 — 00:24:45,006 --> 00:24:46,526

And here's what it looks like.

Cue 416 — 00:24:46,566 --> 00:24:50,006

You just say the architecture is this one, and this is one that I've specified.

Cue 417 — 00:24:50,046 --> 00:24:54,526

Web API slash Python FastAPI. It will regenerate it.

Cue 418 — 00:24:54,566 --> 00:24:57,286

And in the Phoenix setup will actually redeploy.

Cue 419 — 00:24:57,326 --> 00:25:00,486

And the running thing is now in Python and it just works.

Cue 420 — 00:25:00,526 --> 00:25:04,686

So I have two versions of this now just because I bothered to run it twice and

Cue 421 — 00:25:04,726 --> 00:25:08,398

they're exactly the same. You can't tell the difference because the actual evals are

Cue 422 — 00:25:08,438 --> 00:25:12,526

running against both of them, and they don't care that it's running in Python versus

Cue 423 — 00:25:12,566 --> 00:25:18,486

TypeScript. In the future, I expect people will run heterogeneous systems where it's

Cue 424 — 00:25:18,526 --> 00:25:21,646

not just that you don't choose which language and framework to use.

Cue 425 — 00:25:21,686 --> 00:25:24,606

The system, the agents, the system architecture, etc.

Cue 426 — 00:25:24,646 --> 00:25:28,086

choose many because you should use the right tool for the job,

Cue 427 — 00:25:28,126 --> 00:25:31,406

and you should give your agents the ability to choose the right tool for their job.

Cue 428 — 00:25:31,446 --> 00:25:34,206

And in most cases, your architectures don't do that today.

Cue 429 — 00:25:34,246 --> 00:25:36,476

Because why would they write mine?

Cue 430 — 00:25:36,516 --> 00:25:39,586

Mine have for years, and I can tell you it's a good place to be.

Cue 431 — 00:25:41,046 --> 00:25:47,366

Okay, this you know, one problem with generating everything with AI is you generate

Cue 432 — 00:25:47,406 --> 00:25:51,166

your slides with AI and you don't use PowerPoint anymore, and you don't know how to

Cue 433 — 00:25:51,206 --> 00:25:53,626

change to the next slide when you're on a video.

Cue 434 — 00:25:54,866 --> 00:26:01,366

Oh, here we go. Okay. So the regeneration thing on the last that demo was in an

Cue 435 — 00:26:01,406 --> 00:26:05,246

epidemic test. And basically it's like, okay, what did the implementation.

Cue 436 — 00:26:05,286 --> 00:26:09,666

No. And this is a question you can all ask now and probably it will give you stress.

Cue 437 — 00:26:09,726 --> 00:26:15,446

What does your systems implementation know that you might not know because the

Cue 438 — 00:26:15,486 --> 00:26:17,206

implementation remembers things.

Cue 439 — 00:26:17,246 --> 00:26:21,206

You know, the dead guy 20 years ago that wrote the weird thing and the code that I

Cue 440 — 00:26:21,246 --> 00:26:24,526

was talking about, he doesn't exist anymore, but the system does,

Cue 441 — 00:26:24,566 --> 00:26:27,646

right? So that's what we're figuring out by these things.

Cue 442 — 00:26:27,686 --> 00:26:31,006

And what I first did when I first regenerated this one in Python,

Cue 443 — 00:26:31,046 --> 00:26:34,006

it didn't work. And I was like, okay, I've got a problem.

Cue 444 — 00:26:34,046 --> 00:26:37,466

I need to actually continue to specify this thing.

Cue 445 — 00:26:39,406 --> 00:26:42,206

So, oh, I talked about this already, so I'll skip it.

Cue 446 — 00:26:42,246 --> 00:26:45,766

This is where I was talking about production writing prompts and being feedback back

Cue 447 — 00:26:45,806 --> 00:26:51,726

into the system for generation Now, one of the biggest sources of pushback I get

Cue 448 — 00:26:51,766 --> 00:26:54,766

when I talk about this is like, well, if you regenerate the system all the time,

Cue 449 — 00:26:54,806 --> 00:26:56,886

then the user interface is going to be different.

Cue 450 — 00:26:56,926 --> 00:26:58,886

It's going to be stupid. Users can't deal with that.

Cue 451 — 00:26:58,926 --> 00:27:02,606

Obviously not. In fact, you shouldn't probably regenerate your operating system

Cue 452 — 00:27:02,646 --> 00:27:05,566

every time you create something either or the database system that you're running.

Cue 453 — 00:27:05,606 --> 00:27:11,206

Right. And so Stewart Brand has documented this idea of pace layers.

Cue 454 — 00:27:11,246 --> 00:27:14,846

It comes from architecture. You know, like the floor here is not going to change

Cue 455 — 00:27:14,886 --> 00:27:16,606

very often. But we could paint it tomorrow.

Cue 456 — 00:27:16,646 --> 00:27:20,246

That's okay. You won't change the structural foundation of a building.

Cue 457 — 00:27:20,286 --> 00:27:24,126

Frequently. You might change the lighting more frequently or the electrical system

Cue 458 — 00:27:24,166 --> 00:27:27,446

or the paint. As I mentioned, the same is true in systems.

Cue 459 — 00:27:27,486 --> 00:27:31,926

We need to think about pace of different layers, and your architecture needs to lock

Cue 460 — 00:27:31,966 --> 00:27:35,106

those things in place. One of those layers would be UI.

Cue 461 — 00:27:35,286 --> 00:27:38,646

So you've got like the lowest level and then the most user facing level.

Cue 462 — 00:27:38,686 --> 00:27:41,406

I think those are the places where the pace needs to be slowest,

Cue 463 — 00:27:41,446 --> 00:27:45,126

and then everything else can move at varying other speeds, including constant.

Cue 464 — 00:27:45,166 --> 00:27:50,166

Right. So we need to learn to be able to delete things safely,

Cue 465 — 00:27:50,206 --> 00:27:54,646

which is something we learn when we do big rewrites historically.

Cue 466 — 00:27:54,686 --> 00:27:58,326

And then we need to be able to we need to learn to delete more things than we ever

Cue 467 — 00:27:58,366 --> 00:28:00,046

have in the past, because we can.

Cue 468 — 00:28:00,086 --> 00:28:03,166

Now, why is that? I won't talk about how to delete things safely,

Cue 469 — 00:28:03,206 --> 00:28:07,406

but I do want to talk about this idea of compaction, because if you're like me,

Cue 470 — 00:28:07,446 --> 00:28:11,646

you're generating code at such a pace that you can't keep up with all the ideas you

Cue 471 — 00:28:11,686 --> 00:28:14,566

have, or that you even had an already implemented.

Cue 472 — 00:28:14,606 --> 00:28:16,486

I'm constantly like going, oh wow.

Cue 473 — 00:28:16,526 --> 00:28:18,006

Did I do that really well? Amazing.

Cue 474 — 00:28:18,046 --> 00:28:22,966

You know. But what does this result in when you're doing rewrites constantly,

Cue 475 — 00:28:23,006 --> 00:28:27,606

then you're injecting ideas into the system constantly, and eventually you've got

Cue 476 — 00:28:27,646 --> 00:28:30,826

ideas that are no longer relevant to the implementation.

Cue 477 — 00:28:30,966 --> 00:28:34,366

If you've ever worked in a team that did design patterns, you know what I'm talking

Cue 478 — 00:28:34,406 --> 00:28:37,086

about. You know, like abstract factory pattern and stuff like that.

Cue 479 — 00:28:37,126 --> 00:28:40,806

It's just a bunch of crap. Ultimately, that does not help you understand the system

Cue 480 — 00:28:40,846 --> 00:28:45,646

doesn't help it run. So we need to get into the habit of deleting concepts from the

Cue 481 — 00:28:45,686 --> 00:28:49,486

system as frequently as possible, because you need to be able to remove the the

Cue 482 — 00:28:49,526 --> 00:28:50,946

conceptual weight.

Cue 483 — 00:28:53,326 --> 00:28:56,686

I talked about. The spec can come later, and I'm going to jump to the end here

Cue 484 — 00:28:56,726 --> 00:29:00,706

because I am at the end. How does the system become regenerative?

Cue 485 — 00:29:01,326 --> 00:29:05,726

It needs to be replaceable. As I said, decisions that you made need to actually be

Cue 486 — 00:29:05,766 --> 00:29:10,366

logged. Everything needs to be gated by the system and not by humans,

Cue 487 — 00:29:10,406 --> 00:29:14,806

because the system needs to be able to do all sorts of evals and,

Cue 488 — 00:29:14,846 --> 00:29:16,526

and the evals can be all sorts of things.

Cue 489 — 00:29:16,566 --> 00:29:20,766

It could be formal verification with TLA+, which is all the rage right now.

Cue 490 — 00:29:20,806 --> 00:29:24,046

We can just keep layering these things into the systems for further and further

Cue 491 — 00:29:24,086 --> 00:29:28,086

verification. And then the changes that happen need to be selective.

Cue 492 — 00:29:28,126 --> 00:29:31,926

You don't regenerate the whole thing all the time, so you need architectures that

Cue 493 — 00:29:31,966 --> 00:29:36,806

you build or that we could collaboratively, collaboratively build where things are

Cue 494 — 00:29:36,846 --> 00:29:42,166

componentized and decoupled enough to where small pieces can be safely replaced

Cue 495 — 00:29:42,206 --> 00:29:45,666

because they have strong interfaces and boundaries.

Cue 496 — 00:29:47,166 --> 00:29:51,766

And then the whole thing needs to be closed in such a way that the the

Cue 497 — 00:29:51,806 --> 00:29:55,446

specifications and requirements are constantly being monitored and the system

Cue 498 — 00:29:55,486 --> 00:29:59,886

regenerates itself from that. So how do you start?

Cue 499 — 00:29:59,926 --> 00:30:02,666

I have three seconds left. I'm at the end.

Cue 500 — 00:30:03,206 --> 00:30:04,766

Start with the most boring thing.

Cue 501 — 00:30:04,806 --> 00:30:08,126

I actually started this this mental process thinking, well, how are we going to do

Cue 502 — 00:30:08,166 --> 00:30:10,746

generative AI with legacy software?

Cue 503 — 00:30:11,006 --> 00:30:14,086

And it turns out it's pretty easy if you start thinking about it this way.

Cue 504 — 00:30:14,126 --> 00:30:18,906

Not easy in terms of you'll get it done immediately, but easy to to conceptualize.

Cue 505 — 00:30:18,966 --> 00:30:22,326

So go into your systems now and find the most boring component you can.

Cue 506 — 00:30:22,366 --> 00:30:26,766

That's safe. The blast radius is small and try to set up a system like this.

Cue 507 — 00:30:26,806 --> 00:30:30,246

Start with the observability and start with trying to extract the specs out and the

Cue 508 — 00:30:30,286 --> 00:30:35,166

measurements, the evals, and then do some side by side rewrites.

Cue 509 — 00:30:35,206 --> 00:30:38,626

I think you'll find it's like weirdly easy to get this going.

Cue 510 — 00:30:38,766 --> 00:30:41,146

And then of course, the devil is in the details.

Cue 511 — 00:30:41,606 --> 00:30:44,726

So that's that's it. The system is the asset.

Cue 512 — 00:30:44,766 --> 00:30:48,986

The code is a liability. Just burn those ideas into your head.

Cue 513 — 00:30:49,326 --> 00:30:53,926

And if you want to get deeper into this, go visit my friends at Codeplain.

Cue 514 — 00:30:53,966 --> 00:30:56,246

They are actually implementing this as a company.

Cue 515 — 00:30:56,286 --> 00:31:00,566

They're out there in a booth and read the long version if you're interested.

Cue 516 — 00:31:00,606 --> 00:31:01,746

Thank you very much.

skills

talk-fowler-regenerative-software

tile.json