How it will happen

code is ... going

Something is happening to the world of code that is hidden from most people, but shouldn’t be, because it is going to happen to more than just code, soon.

It’s easy to get complacent or numb to progress in AI. It’s confusing, first of all - there are huge steps forward in capabilities, but persistent problems too. The capabilities are easier to see, sometimes, than the slow solving of the problems. And all of this is sitting on an exponential curve, which is hard for anyone to understand well.

So, looking back is useful, and comparing to what’s going on now is a good way to get oriented. In code, at the start of 2025, few people were using AI models to write much code. It was a useful tool, but not much more than a better autocomplete - humans were still writing, debugging, and reading the code. As recently as 5 or 6 months ago, this was largely true.

Then we passed some tipping points. Models got better at code, but also better at longer thinking. Somewhere in there, the combination of skill and length of task crossed over a point where the return was positive, and then strongly positive. Early teams started to make heavier use of the tools. Coding assistants and other scaffolding like Claude Code, Codex, which had been working only so-so before, suddenly became much more effective. The models became capable of doing more debugging and analysis, so that meant they could help improve their own scaffolding, and as that process continued, it accelerated.

Suddenly, advanced teams started talking about (and practicing) not reading the code at all. This is beyond vibe coding, which mostly didn’t work. New best practices are emerging around these coding toolkits that make them much more robust and reliable. Not everyone has the skills to use them well yet (which is why there are lots of folks still saying they don’t work), but those that shift to the new tools and understand them are now many times more effective than before. Folks who were good coders got to be incredible. Folks who weren’t even coders at all suddenly could make software happen.

Engineers who are close to the front of this are tired, overwhelmed, and excited at the same time. It’s hard to keep up with it all, and there are great tools to play with - not enough time, or tokens, in the day. And that last is interesting: at least right now, there doesn’t seem to be a limit in sight for the number of tokens a programmer can consume - the limit is largely how much you can pay attention to, and many folks are working on “meta orchestration” to increase the amount of machine work per unit of human attention.

So…that’s how it’s going in code. Who cares, right? Except that this pattern is likely to repeat across many domains:

• At first, the models will be ok but not great at something. They can do some work, but the payoff is small.

• A combination of model improvement, tooling, and best practices will emerge for a specific domain. Eventually this will start to be more strongly positive for early adopters.

• Since those early adopters are getting positive return, they will have both incentive and time to invest in improving the tools (and the increasing ease with which software can now be built will help).

• To the degree that “everything is software”, this domain will accelerate as ideas from the coding world leak back, now that they’re proven to be worthwhile. The early adopters will accelerate, getting more stressed out but much more productive,

• What hasn’t happened to code yet, but what will eventually, is that the tools will go from curiosity, to hobby, to early adopter, to mandatory, and anyone who can’t make that transition will fail out. If you see the above pattern happening in your domain, this is the destination - what is interesting but only a little effective today, will become mandatory to be effective quickly.

The coding realm is shining a light on these broader patterns. It’s already evident that a LOT more software is being created, just like the internet allowed a LOT more media to be created (and, like the internet and media, individual pieces of software will become less valuable, along a power law, the collective value of software will likely massively increase, and business models will change radically).

It’s also evident that as the tools get better at the task, there is more to do, not less, at least if you have imagination. Demand seems to increase as the tools get better. All of this still very much feels like the internet to me - where we slowly at first but then increasingly quickly understood both how to build and what to build, and there was an absolute explosion of value.

What is happening in code now seems a lot like that. And it seems like a pattern that will repeat elsewhere before long.