AI Native DevCon 2026 New York — practical agent skills grounded in conference talks
86%
Does it follow best practices?
Run evals on this skill
Adds up to 20 points to the overall score
Low
Low-risk findings worth noting
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.
.tessl-plugin
skills
talk-arcolano-autonomy-and-trust
talk-aroussi-decision-context
talk-bevin-agent-assisted-instrument-design
talk-boeckeler-context-lifecycles
talk-braun-context-graphs
talk-carmont-evolving-agent-harnesses
talk-chanezon-gordon-agent-experience-evaluation
talk-cox-secure-agentic-workflows
talk-cunniffe-reusable-agent-platform
talk-davis-agent-tool-policies
talk-debois-concurrent-delivery
talk-dzialets-team-automation
talk-fahmy-harness-api-design
talk-finster-continuous-delivery
talk-fowler-regenerative-software
talk-gavrilescu-factory-architecture
talk-graciolli-amin-verification-aware-programming
talk-gruenbaum-reverse-graph-engineering
talk-hassan-agentic-engineering
talk-hossain-enterprise-agent-adoption
talk-huntley-patch-ready-factories
talk-jain-verifying-intent
talk-katsioloudes-montei-agentic-lifecycle
talk-knox-harness-engineering
talk-kovac-deterministic-memory
talk-lee-perkins-code-readiness
talk-lorenc-machine-speed-security
talk-lubken-software-of-one
talk-meijer-software-specialization
talk-meppiel-versioned-agent-contracts
talk-moss-concurrent-agent-risk
talk-myers-understanding-agent-generated-code
talk-ocytko-scaling-agentic-engineering
talk-oza-automating-design-quality
talk-panzica-agentic-sdlc
talk-pari-patel-agent-awareness
talk-podjarny-trustworthy-software-factories
talk-poulter-factory-improvement
talk-pratik-patel-refined-rag-data
talk-re-ferre-development-platforms
talk-sadogursky-factory-of-factories
talk-shah-training-agent-skills
talk-sharma-mohapatra-evolving-intent
talk-singhal-operating-agents-at-scale
talk-stack-incident-dossiers
talk-tyler-team-coding-benchmarks
talk-wotherspoon-agent-execution-environments
talk-yegge-ai-powered-factories
talk-zuber-leadership-through-coding