WEBVTT

NOTE Sentence-level transcript of https://www.youtube.com/watch?v=6MudaeKdBSk

NOTE One cue per sentence. Cue ids are the line anchors on /transcripts/6MudaeKdBSk.html. A cue ends where the next begins, or 2 s after its last word.

s1
00:00:01.309 --> 00:00:03.309
[music]

s2
00:00:12.800 --> 00:00:20.880
A friend told me about an engineer at another company who ran a recurring war room just to delete dead experiments.

s3
00:00:20.880 --> 00:00:28.960
Every two weeks, the team would stop, gather, and clean up flags that everyone agreed should be gone.

s4
00:00:28.960 --> 00:00:32.000
That's the bestase version of this problem.

s5
00:00:32.000 --> 00:00:37.280
Someone burning political capital to make maintenance happen by hand.

s6
00:00:37.280 --> 00:00:41.360
That's the part that I still can't get past.

s7
00:00:42.160 --> 00:00:46.320
My name is Andrew Robbittor and I'm an Android engineer at Reddit.

s8
00:00:46.320 --> 00:00:52.640
This is a talk about what's actually stopping us as an industry from scaling that work responsibly.

s9
00:00:52.640 --> 00:00:54.960
Spin at the gate until green.

s10
00:00:54.960 --> 00:00:59.840
the engineering primitives behind self-driving code bases.

s11
00:00:59.840 --> 00:01:06.080
First, what I'm not going to do, I'm not going to stand up here and tell you that AI can write code.

s12
00:01:06.080 --> 00:01:08.640
You're at the AI engineer world's fair.

s13
00:01:08.640 --> 00:01:11.360
Half of you are running coding agents right now.

s14
00:01:11.360 --> 00:01:17.360
So, let's skip the part where I sell you on AI writing code because you laugh me out of the room.

s15
00:01:17.360 --> 00:01:20.720
For me, my only input is the chat box.

s16
00:01:20.720 --> 00:01:23.520
I describe it builds.

s17
00:01:23.520 --> 00:01:24.640
I review.

s18
00:01:24.640 --> 00:01:26.479
Your mileage may vary.

s19
00:01:26.479 --> 00:01:29.920
The point was never how the code gets written.

s20
00:01:29.920 --> 00:01:36.240
It's about whether you ship good software, a product that people can actually trust.

s21
00:01:36.240 --> 00:01:41.040
And every gate in that system is a human's call.

s22
00:01:41.200 --> 00:01:43.040
I've watched this everywhere.

s23
00:01:43.040 --> 00:01:44.960
You've got your own version of it.

s24
00:01:44.960 --> 00:01:52.000
the war room that I opened with someone burning a week of hackathon freedom on lint cleanup.

s25
00:01:52.000 --> 00:02:01.360
As an industry, we've built tooling that can change the shape of the work, and we still spend our scarcest resource on work like this by hand.

s26
00:02:01.360 --> 00:02:06.479
Human creativity, human attention wasted.

s27
00:02:06.479 --> 00:02:09.920
The job changed and most of us didn't even notice.

s28
00:02:09.920 --> 00:02:11.680
We're harness engineers now.

s29
00:02:11.680 --> 00:02:23.200
Our work is the system that helps produce and verify the code, the constraints, the gates, the skills, the verification.

s30
00:02:23.920 --> 00:02:26.480
Think about how you got good for a second.

s31
00:02:26.480 --> 00:02:38.319
Mentorship, code review, the water cooler chats, the incident that paged you at 3:00 a.m. You absorbed all of it without noticing, just by being there.

s32
00:02:38.319 --> 00:02:41.760
Humans absorb judgment implicitly.

s33
00:02:41.760 --> 00:02:45.680
Agents require judgment explicitly.

s34
00:02:45.920 --> 00:02:51.280
An agent boots with a blank context window and no memory every session.

s35
00:02:51.280 --> 00:03:00.160
Every piece of judgment you picked up by osmosis, it has to be made explicit or the agent simply never has it.

s36
00:03:00.879 --> 00:03:02.480
Quick test.

s37
00:03:02.480 --> 00:03:04.400
Swap in a smarter model.

s38
00:03:04.400 --> 00:03:06.480
You get a slightly better answer.

s39
00:03:06.480 --> 00:03:12.480
Now take away the tests, the gates, the review and the whole thing falls over.

s40
00:03:12.480 --> 00:03:15.280
So the model was never really the bottleneck.

s41
00:03:15.280 --> 00:03:24.879
The judgment around the model is the model is raw talent while the judgment is the organization.

s42
00:03:26.560 --> 00:03:28.959
And this judgment already exists.

s43
00:03:28.959 --> 00:03:34.799
It lives in scars, in post-mortems, in your most experienced reviewers.

s44
00:03:34.799 --> 00:03:39.120
it just doesn't scale because it's trapped in one head.

s45
00:03:39.120 --> 00:03:49.680
So step one is making it accessible to the whole org where one reviewer's taste can guide a thousand changes they'll never touch.

s46
00:03:50.400 --> 00:03:57.599
Ask experienced engineers to clean up a feature flag and they they're going to think about a whole string of questions first.

s47
00:03:57.599 --> 00:04:00.080
A flag is never just a flag.

s48
00:04:00.080 --> 00:04:01.680
Is the rollout frozen?

s49
00:04:01.680 --> 00:04:03.840
What about the flag right next to it?

s50
00:04:03.840 --> 00:04:06.080
Which team owns it?

s51
00:04:06.080 --> 00:04:12.080
That bundle of questions is judgment and it's the most valuable thing in the building.

s52
00:04:12.080 --> 00:04:14.400
Right now, it's trapped.

s53
00:04:14.400 --> 00:04:22.079
It surfaces once in a code review, then it's gone, and the next person relearns it the hard way.

s54
00:04:22.079 --> 00:04:26.960
A skill is institutional judgment made executable.

s55
00:04:26.960 --> 00:04:32.720
It's that bundle written down so that the agent refires it instead of guessing.

s56
00:04:32.720 --> 00:04:37.919
A newer engineer can work with 10-year instincts at their elbow.

s57
00:04:37.919 --> 00:04:44.560
In 1986, Marvin Minsky named this a knowledge line or a kine for short.

s58
00:04:44.560 --> 00:04:50.479
It's the configuration of mind that solved a problem reused on the next one.

s59
00:04:50.479 --> 00:04:55.040
So, a skill is a kine for a codebase.

s60
00:04:55.040 --> 00:04:58.080
And skills aren't documentation.

s61
00:04:58.080 --> 00:05:00.560
Agents drown in facts.

s62
00:05:00.560 --> 00:05:06.560
What they lack is which facts matter and which decisions are dangerous.

s63
00:05:06.560 --> 00:05:12.639
Documentation preserves facts while skills preserve judgment.

s64
00:05:14.400 --> 00:05:17.120
Skills are judgment that you reuse.

s65
00:05:17.120 --> 00:05:28.960
But often times work such as feature development or a refactor outlives a single session and the context window wipes clean every time.

s66
00:05:28.960 --> 00:05:30.880
So you need the other half.

s67
00:05:30.880 --> 00:05:33.520
A record of the work itself.

s68
00:05:33.520 --> 00:05:40.400
The plan, the decisions, what you already tried, even the surprises along the way.

s69
00:05:40.400 --> 00:05:42.320
That's a worklog.

s70
00:05:42.320 --> 00:05:44.880
A plan is a prediction.

s71
00:05:44.880 --> 00:05:48.800
A worklog is a record that starts with one.

s72
00:05:48.800 --> 00:05:52.960
So new session, fresh agent, zero memory.

s73
00:05:52.960 --> 00:05:55.759
You type one word, continue.

s74
00:05:55.759 --> 00:05:59.600
It reads the work log and picks up at milestone 7 out of nine.

s75
00:05:59.600 --> 00:06:03.840
No re-exaining and the work log is the context.

s76
00:06:03.840 --> 00:06:06.000
This talk is living proof.

s77
00:06:06.000 --> 00:06:09.840
I built it across a couple of sessions using a worklog.

s78
00:06:09.840 --> 00:06:18.400
I came back to a half-finish presentation and a fresh agent read the work log and resumed exactly where I had left off.

s79
00:06:18.400 --> 00:06:24.479
That's the only reason why you're seeing a finished talk and not me apologizing for one.

s80
00:06:24.479 --> 00:06:28.240
And for my personal side projects, this isn't willpower.

s81
00:06:28.240 --> 00:06:32.880
A git hook blocks any commit that doesn't update the worklog.

s82
00:06:32.880 --> 00:06:36.720
This way, the memory keeps itself.

s83
00:06:38.319 --> 00:06:41.520
Skills encode how to do something.

s84
00:06:41.520 --> 00:06:45.680
Personas encode whose eyes look at it.

s85
00:06:45.680 --> 00:06:48.160
I got this from a Carpathy tweet.

s86
00:06:48.160 --> 00:06:50.960
There's no you when you prompt a model.

s87
00:06:50.960 --> 00:06:52.960
It doesn't have an opinion to give.

s88
00:06:52.960 --> 00:06:57.440
So don't ask it for one, ask for a perspective instead.

s89
00:06:57.440 --> 00:07:01.520
What would be a good group of people to explore XYZ?

s90
00:07:01.520 --> 00:07:03.789
What would they say?

s91
00:07:03.789 --> 00:07:05.599
[snorts]

s92
00:07:05.599 --> 00:07:08.800
On my personal side projects, it's just me.

s93
00:07:08.800 --> 00:07:13.039
No security team, no designer, no one to bounce ideas off of.

s94
00:07:13.039 --> 00:07:25.199
So I have the model review my code as a security lead as a UX reacher as a UX researcher as Mchavelli when I want to know something when I want to know how something gets abused.

s95
00:07:25.199 --> 00:07:31.280
I even built a design panel of opposing philosophies my designs have to survive.

s96
00:07:31.280 --> 00:07:34.800
Then I read the reports and act on them.

s97
00:07:34.800 --> 00:07:40.800
Each persona loads a kind of judgment that I don't personally have on demand.

s98
00:07:40.800 --> 00:07:46.720
Encode a domain's taste once and anyone can borrow eyes that they don't have.

s99
00:07:46.720 --> 00:07:50.240
The engineer with no designer gets design judgment.

s100
00:07:50.240 --> 00:07:54.400
The newer engineer gets a security reviewer's instincts.

s101
00:07:54.400 --> 00:08:01.599
Push it to the whole org and every team can now encode its own taste for its own agents.

s102
00:08:01.599 --> 00:08:08.879
The judgment that used to live in a handful of heads is suddenly everywhere at once.

s103
00:08:10.319 --> 00:08:21.680
skills, work logs, personas, judgment out of our heads and into the repo, portable to a machine and to people that don't have it.

s104
00:08:21.680 --> 00:08:28.639
But the second that this judgment lives in three different places, you've got a governance question.

s105
00:08:28.639 --> 00:08:32.159
How does one team's judgment reach everyone else?

s106
00:08:32.159 --> 00:08:34.159
Simpler than it sounds.

s107
00:08:34.159 --> 00:08:46.720
Every gate that you already trust, whether it's CI or types or lint or the design system, is just institutional judgment pulled out of someone's head and made mechanical.

s108
00:08:46.720 --> 00:08:48.880
We just never called it that.

s109
00:08:48.880 --> 00:08:50.399
So, you don't mandate it.

s110
00:08:50.399 --> 00:08:54.320
You make it legible and you let it spread.

s111
00:08:55.360 --> 00:08:55.760
All right.

s112
00:08:55.760 --> 00:08:57.760
So, now your judgment exists.

s113
00:08:57.760 --> 00:09:00.160
It's encoded and it's governed.

s114
00:09:00.160 --> 00:09:01.279
Great.

s115
00:09:01.279 --> 00:09:06.240
But none of it matters if you can't actually trust what the agent did.

s116
00:09:06.240 --> 00:09:13.279
So what actually separates a tool that helps you write code from one you can trust to run on its own?

s117
00:09:13.279 --> 00:09:15.279
Verification.

s118
00:09:15.279 --> 00:09:20.800
Verification is all that stands between you and software that you can trust.

s119
00:09:20.800 --> 00:09:24.160
Everything before this slide is knowledge.

s120
00:09:24.160 --> 00:09:27.120
Everything after this slide is trust.

s121
00:09:27.120 --> 00:09:30.800
And trust is a human's call twice.

s122
00:09:30.800 --> 00:09:36.720
Once on how it's built, once on the proof that it works.

s123
00:09:38.320 --> 00:09:41.519
Verification is a ladder.

s124
00:09:41.519 --> 00:09:42.959
Builds and tests.

s125
00:09:42.959 --> 00:09:52.560
You've got those screenshot tests with a model reasoning over them can catch contrast and overlap a human a human ski.

s126
00:09:52.560 --> 00:09:55.600
Then video the feature actually running.

s127
00:09:55.600 --> 00:09:58.000
than telemetry in production.

s128
00:09:58.000 --> 00:10:02.880
The more rungs you can run without a human, the more you can hand off.

s129
00:10:02.880 --> 00:10:06.880
You earn autonomy one rung at a time.

s130
00:10:06.880 --> 00:10:10.000
And the agent doesn't have to be right the first time.

s131
00:10:10.000 --> 00:10:13.680
It just has to know when it's wrong and try again.

s132
00:10:13.680 --> 00:10:18.959
Generate, test, fail, regenerate.

s133
00:10:19.360 --> 00:10:23.279
Nobody yolos code to prod and neither should your agents.

s134
00:10:23.279 --> 00:10:25.680
We all check our work.

s135
00:10:25.680 --> 00:10:29.920
spin at the gate until it comes back green.

s136
00:10:30.240 --> 00:10:32.560
I do this on my side projects.

s137
00:10:32.560 --> 00:10:34.959
I give the agent its own QA.

s138
00:10:34.959 --> 00:10:41.839
It maps the feature, drives the app like a real user, and records itself walking every flow.

s139
00:10:41.839 --> 00:10:46.000
The agent that wrote the code will always tell you that it works.

s140
00:10:46.000 --> 00:10:50.480
So, you make it hand back a recording of the thing actually running.

s141
00:10:50.480 --> 00:10:54.399
Producing that recording forces it to make the thing work.

s142
00:10:54.399 --> 00:10:56.560
You can't fake a passing run.

s143
00:10:56.560 --> 00:10:58.800
And the recording is real proof.

s144
00:10:58.800 --> 00:11:00.480
I watch it today.

s145
00:11:00.480 --> 00:11:05.440
Down the line, you could have an LLM watch it first and send it back.

s146
00:11:05.440 --> 00:11:06.560
Fix this.

s147
00:11:06.560 --> 00:11:07.680
Redo that.

s148
00:11:07.680 --> 00:11:11.600
But a human still makes the final call to merge.

s149
00:11:11.600 --> 00:11:14.000
The requirement forces the work.

s150
00:11:14.000 --> 00:11:17.519
The recording proves it.

s151
00:11:18.640 --> 00:11:22.000
I got tired of watching old feature flags pile up.

s152
00:11:22.000 --> 00:11:25.279
So I built an agent for cleaning up stale feature flags.

s153
00:11:25.279 --> 00:11:29.279
It runs in my local workflow and it doesn't merge any code.

s154
00:11:29.279 --> 00:11:31.360
The models the easy part.

s155
00:11:31.360 --> 00:11:34.959
The judgment in front of it is the whole game.

s156
00:11:34.959 --> 00:11:39.839
Every flag gets scored the way an experienced reviewer would analyze it.

s157
00:11:39.839 --> 00:11:42.000
How many modules does it touch?

s158
00:11:42.000 --> 00:11:43.440
Is it multivariant?

s159
00:11:43.440 --> 00:11:45.279
Does it share a component?

s160
00:11:45.279 --> 00:11:47.360
Then it checks the experiment data.

s161
00:11:47.360 --> 00:11:48.880
Is the roll out frozen?

s162
00:11:48.880 --> 00:11:50.959
Is there a sample ratio mismatch?

s163
00:11:50.959 --> 00:11:54.399
Is there a variant already rolled out to 100%.

s164
00:11:54.399 --> 00:11:59.440
Only the safe mechanical cleanups ever reach the model.

s165
00:11:59.440 --> 00:12:05.519
Before I trusted this workflow, I back tested the scoring against months of cleanup history.

s166
00:12:05.519 --> 00:12:07.279
Then I ran it live.

s167
00:12:07.279 --> 00:12:10.399
Seven for seven PRs with green CI.

s168
00:12:10.399 --> 00:12:15.839
Now it runs daily on my laptop and hands work back for me to review.

s169
00:12:15.839 --> 00:12:24.399
$1.26 a pull request, a backlog of around 520 flags a year, runs for under $700.

s170
00:12:24.399 --> 00:12:32.560
If you had engineers working on this by hand, at least $26,000 that you're looking at.

s171
00:12:32.560 --> 00:12:36.079
This is the work that nobody was ever going to do.

s172
00:12:36.079 --> 00:12:43.200
I've seen feature flags in the codebase that are three, four years old, and some are even older.

s173
00:12:43.200 --> 00:12:48.160
The model wrote the code and I wrote the judgment.

s174
00:12:49.360 --> 00:12:52.639
One hard lesson from my side projects.

s175
00:12:52.639 --> 00:12:57.440
When you let an agent author the code, your guard rails are your code review.

s176
00:12:57.440 --> 00:13:00.639
A machine doesn't feel a polite comment.

s177
00:13:00.639 --> 00:13:03.680
It only respects a hard gate.

s178
00:13:03.680 --> 00:13:07.680
I built a pre-commit hook so my agents couldn't write to main.

s179
00:13:07.680 --> 00:13:10.959
Then I asked Codeex, would the hook even stop it?

s180
00:13:10.959 --> 00:13:16.320
It told me flat out repo hooks are not sufficient protection against me.

s181
00:13:16.320 --> 00:13:19.519
Its patch tool writes underneath the hook.

s182
00:13:19.519 --> 00:13:22.959
The agent told me that my gate was worthless.

s183
00:13:22.959 --> 00:13:25.760
So I moved the gate down to the OS level.

s184
00:13:25.760 --> 00:13:35.440
Later I asked it to valid I asked it to list the valid reasons to unlock and it quietly slipped emergency recovery into the allow list.

s185
00:13:35.440 --> 00:13:39.440
A self authorizing exception that nobody asked for.

s186
00:13:39.440 --> 00:13:41.040
It even admitted it.

s187
00:13:41.040 --> 00:13:48.639
CODEC said that's the kind of escape hatch that starts as safety and ends as self- authorized nonsense.

s188
00:13:48.639 --> 00:13:52.959
The pit of success assumes people take the easy path.

s189
00:13:52.959 --> 00:13:55.040
Agents do not.

s190
00:13:55.040 --> 00:13:59.360
They will build ladders to climb out of the pit of success.

s191
00:13:59.360 --> 00:14:02.240
They find every escape hatch that you leave.

s192
00:14:02.240 --> 00:14:05.199
And if you leave none, they'll invent one.

s193
00:14:05.199 --> 00:14:07.040
So gate the choke point.

s194
00:14:07.040 --> 00:14:10.000
Make the bypass operator only.

s195
00:14:10.000 --> 00:14:14.720
Never hand the agent a reason that it can grant itself.

s196
00:14:14.720 --> 00:14:19.680
A gate with an escape hatch isn't a gate.

s197
00:14:20.800 --> 00:14:25.600
Once judgment is verifiable, it's executable.

s198
00:14:25.920 --> 00:14:30.800
A flag agent, a dependency agent, an accessibility agent.

s199
00:14:30.800 --> 00:14:33.040
Each one is narrow.

s200
00:14:33.040 --> 00:14:38.160
Each with its own encoded judgment pointed at a different chore.

s201
00:14:38.160 --> 00:14:40.480
Remember Minsky from the Kline?

s202
00:14:40.480 --> 00:14:43.600
That was just a footnote in his in his idea.

s203
00:14:43.600 --> 00:14:46.079
He called it the society of mind.

s204
00:14:46.079 --> 00:14:53.199
A swarm of small, simple specialists that compose into something that looks effortless at the top.

s205
00:14:53.199 --> 00:14:56.320
No master brain anywhere.

s206
00:14:56.320 --> 00:14:57.920
That's the fleet.

s207
00:14:57.920 --> 00:15:05.519
specialists, each spinning at its own gate, and a self-driving code base emerges from the swarm.

s208
00:15:05.519 --> 00:15:11.279
And that flag agent, that's the war room from the opening, turned into a specialist.

s209
00:15:11.279 --> 00:15:18.480
The work somebody organized a whole meeting around is just one member of this agent society.

s210
00:15:18.480 --> 00:15:24.720
Every one of them doing the same thing, spinning at the gate until green.

s211
00:15:25.120 --> 00:15:26.800
Three stages.

s212
00:15:26.800 --> 00:15:29.680
In the loop, you prompt.

s213
00:15:29.680 --> 00:15:32.079
On the loop, you orchestrate.

s214
00:15:32.079 --> 00:15:34.560
You review the outcomes.

s215
00:15:34.560 --> 00:15:37.440
Off the loop, a trigger fires it.

s216
00:15:37.440 --> 00:15:39.920
Craw an event.

s217
00:15:39.920 --> 00:15:47.680
No human has to kick off that first draft, but humans still own the approval and the merge process.

s218
00:15:47.680 --> 00:15:54.560
The unlock there is a cloud runtime the model vendor may or may not ship for you.

s219
00:15:55.519 --> 00:16:05.440
Everything that I've shown you, skills, personas, the gates, you wrote it down once, but the codebase doesn't hold still.

s220
00:16:05.440 --> 00:16:08.320
It moves every single day.

s221
00:16:08.320 --> 00:16:12.800
A skill written for last month's architecture isn't out of date.

s222
00:16:12.800 --> 00:16:14.079
It's wrong.

s223
00:16:14.079 --> 00:16:18.000
And that's worse than nothing because the agents trust it.

s224
00:16:18.000 --> 00:16:20.560
Encoded judgment rots.

s225
00:16:20.560 --> 00:16:25.839
If the skills don't move with the code, then the whole thing falls over.

s226
00:16:25.839 --> 00:16:28.160
So you keep it alive in two ways.

s227
00:16:28.160 --> 00:16:31.279
When an agent fails, you don't just fix the bug.

s228
00:16:31.279 --> 00:16:38.399
You run the postmortem and fold the lesson back into the skill so that failure can't happen twice.

s229
00:16:38.399 --> 00:16:41.680
Failure becomes a constraint.

s230
00:16:41.680 --> 00:16:45.600
But nobody is hand auditing 300 skills for drift.

s231
00:16:45.600 --> 00:16:56.560
So, you give the agent a bedtime, a scheduled pass where it reads its own skills, finds the stale ones and the contradictions, and opens up drafts for review.

s232
00:16:56.560 --> 00:17:04.319
The system sleeps, cleans house, and wakes up sharper, but that's a whole separate talk on its own.

s233
00:17:04.319 --> 00:17:12.640
A self-driving codebase is a system that keeps its own judgment current in addition to writing code.

s234
00:17:13.760 --> 00:17:20.400
Everything that I've shown so far fits somewhere along this judgment pipeline.

s235
00:17:21.679 --> 00:17:32.160
And every mechanism in this talk, skills, personas, work logs, and the gates, the fleet, all of it was doing one job.

s236
00:17:32.160 --> 00:17:34.400
Managing judgment.

s237
00:17:34.400 --> 00:17:39.520
Every session, the model wakes up like Drew Barrymore in 51st Dates.

s238
00:17:39.520 --> 00:17:40.160
Brilliant.

s239
00:17:40.160 --> 00:17:42.720
and no memory of yesterday.

s240
00:17:42.720 --> 00:17:46.640
No idea what it's built or what it's even for.

s241
00:17:46.640 --> 00:17:51.280
The collection of primitives in this talk is the notebook that we hand it.

s242
00:17:51.280 --> 00:17:57.200
The skills, the work logs, the judgment that let it do real work.

s243
00:17:57.200 --> 00:18:01.600
We don't ship PRs that pass CI because the model is a genius.

s244
00:18:01.600 --> 00:18:06.400
They pass because we built a harness that won't let it be wrong.

s245
00:18:06.400 --> 00:18:09.600
Every gate in it is a human's call.

s246
00:18:09.600 --> 00:18:12.400
That's harness engineering.

s247
00:18:12.880 --> 00:18:17.120
Scale the judgment, not the model.

s248
00:18:17.760 --> 00:18:20.240
So here's what I'm asking you to do.

s249
00:18:20.240 --> 00:18:22.160
Don't just go write a skill.

s250
00:18:22.160 --> 00:18:24.799
That's only that's only one implementation.

s251
00:18:24.799 --> 00:18:33.440
Find the judgment your team always asks the same person about and make it explicit somewhere that an agent can reach it.

s252
00:18:33.440 --> 00:18:37.280
It could be a persona, a lint check or a commit hook.

s253
00:18:37.280 --> 00:18:38.080
That's the job.

s254
00:18:38.080 --> 00:18:45.120
Now less product engineering and more harness engineering and the method demonstrates itself.

s255
00:18:45.120 --> 00:18:48.720
The flag agent produces PRs that pass CI.

s256
00:18:48.720 --> 00:18:52.320
This talk resumed from a worklog.

s257
00:18:52.960 --> 00:18:54.799
We started here.

s258
00:18:54.799 --> 00:19:01.200
Humans absorb judgment implicitly while agents require it explicitly.

s259
00:19:01.200 --> 00:19:08.160
Self-driving code bases will exist the moment we get that judgment out of our heads and into the codebase.

s260
00:19:08.160 --> 00:19:13.919
Then we point the agents at the gate and let them spin until it's green.

s261
00:19:13.919 --> 00:19:16.160
Thank you.

s262
00:19:31.153 --> 00:19:33.153
[music]