I Thought I Was Keeping Up

Less than two months ago, I was wondering if AI was starting to slow down.

That concern has aged poorly.

At the time, I had some substantial worries about subsidized intelligence. These models were incredible, but they were also obviously expensive to operate. I wondered what would happen if we all built our workflows around them and eventually somebody decided the economics no longer made sense.

What happens when the rug gets pulled?

Apparently, before answering that question, everyone decided to make the models dramatically better and cheaper instead.

AI has gone from “fancy autocomplete” to “this is going to pull off three months worth of research, source diving, and implementation in the next two hours, and it will take me 20 times longer to review what it did than it took to write it.”

That feels like a different thing.

Models are being released left and right that are incredibly capable without being particularly expensive. GPT Luna, at least while I am writing this, is kind of ridiculous for the price.

By the time you read this, it will probably already be obsolete.

And it is not just that the chat box got smarter.

Give one of these models a web browser or a terminal and things get considerably more interesting.

I have yet to unleash one on anything that is not a new device or a VM I am completely willing to blow away, because I am impressed, not insane.

But watching them work is incredible.

With a good prompt and the right harness, they can inspect a machine, investigate a problem, read documentation, configure things, try something, notice that it failed, change direction, and keep going.

The important part is the keeping going.

A very smart model sitting in a chat window is useful. A very smart model that can actually interact with the thing it is reasoning about is something else entirely.

Some of those experiences deserve their own stories.

This one is mostly about what happens afterward.

Because now I have a review problem.

For a long time, the rule was simple. If AI wrote code that mattered, you read the code.

The models were useful, but they were also extremely capable of confidently inventing nonsense. Reviewing every line felt less like good practice and more like basic self-preservation.

I still read code, especially anywhere near the hot path.

Reluctantly.

The strange part is that I rarely find anything actually wrong or dangerous anymore.

Usually I find something written in a way I would not have written it.

So I change it.

Because I have opinions.

I am increasingly unsure whether having opinions is always helping.

There is a peculiar moment when you look at perfectly reasonable code, realize there is nothing meaningfully wrong with it, and still feel an urge to rearrange the furniture because this is not where you would have put the couch.

The most egregious problem I still see is scope creep. Give a model a little too much freedom and it may enthusiastically solve the problem you asked about, two problems next to it, and something it noticed while passing through.

That is still annoying.

But even there, I am starting to think a lot of it is a prompting and harness problem. The better I get at defining boundaries, the less often it happens.

Which leaves an uncomfortable question.

How much longer am I going to read every line?

I am already rarely the first reviewer.

Other models usually get there before I do. They review the implementation, look for regressions, compare it against the plan, run tests, and complain about things they do not like.

Sometimes another model reviews that review.

By the time I get involved, I may be the third pass.

They are faster than I am.

They do not get tired.

And, if I am being fair, they are often better at finding problems than I am.

This does not mean I think code review is becoming unnecessary. I think the thing I call “review” may be changing.

Reading every generated line yourself might eventually be the wrong abstraction.

Maybe the important parts become the architecture, the boundaries, the tests, the behavior, the security assumptions, and whether the system actually does what you intended.

That is already how we deal with plenty of software we did not personally write.

Still, there is something about crossing that line in my own projects that feels different.

I still feel firmly in control of what I am building. I know what the system is supposed to do. I know why it is designed the way it is. I know where the dangerous edges are, and I know when something smells wrong.

But I can see where this is going.

At some point, control becomes detached from understanding.

Not completely. I do not mean pushing a button and hoping the magic box built the right thing.

I mean understanding the system without necessarily understanding every implementation detail inside it.

Knowing what it does.

Knowing its boundaries.

Knowing how to tell when it has gone wrong.

But not necessarily knowing exactly how every piece works anymore.

Maybe that is perfectly fine.

We already build an enormous amount of software that way.

I am just not ready to get there quite yet.