Suddenly, There's More

That feeling of encountering a ton of code all at once.

A new project

Think back on the days when humans wrote code. Did you ever get hired onto a new team or moved onto a new project that was already under way? When you showed up, there was already a corpus of code to read, digest, understand and learn how to act within.

This all came suddenly. You showed up, but you weren't immediately effective. The larger the codebase, the more likely that you took longer to become effective. But understanding was the goal in order to facilitate your full contribution. Onboarding efforts were made. Time was allowed. It was always a challenge.

Machine code generation

Now we have gen AI tools that can create code faster than any human. A short, natural language prompt that expresses sufficient ambition in output, and wham-o -- suddenly, we have a bunch more code.

Human code understanding

Recently, tools have advanced to be able to produce often-coherent code (that you might keep around) in large quantities. Have we as programmers equivalently advanced so that we can read, understand and act on code at this increased pace? No. If the code generation speed is inhumanly fast, the human understanding and ownership of such will necessarily lag behind.

There is suddenly more: more to learn, more to digest, grok and get comfortable with.

As the distance between code generated and code understood increases, the space for problems grows. This means there are serious trade-offs to quickly generating a lot of code.

Matched growth

Historically, programmers have grown the code around themselves and have grown up with the code. We have had time to simmer with the code. We understood the code before we committed it. As we expanded our minds and skills, we applied it by shaping and re-shaping to the code.

Fast code

Now, instead, we have the possibility of suddenly having more code appear in the codebase. Encountering a wall of unfamiliar code can be jarring. At the least, it takes time to digest, if we try at all. Will programmers give themselves time and be encouraged to take the time to digest something that appeared more or less immediately and for free?

Or, as they say, "easy come, easy go." Have we entered an era of "fast code", like fashion, where cheap and flimsy programs are simply thrown away when they don't work? Supply a new prompt, deploy the new artifact, hope for the best. In such a world, programmers and companies would have little incentive to invest any time understanding a program.

But it doesn't seem that we are to the point where "fast code" is very healthy. Barring positive developments here, we'll have programs that stick around and on which we will rely over time. That means that we'll need to understand them so that we can update, append to and maintain them.

Worship of fast

If speed of code generation becomes our highest value and measure of a good programmer, we will see a lot more code being generated. You get more of what you reward. There's a lot of talk about productivity increases through AI use. What better showcase than a largely-generated app that you deployed asap? Wow! That will be what programmers report on in status updates. That will be what leaders showcase in company meetings.

Code gen will lead to more code gen. With the increasing pace, the code size vs human understanding gap will likely increase.

Suddenly

So when someone says, "look how much AI generated for me", you can bet that they didn't read it all and understand it. The bigger the code gen, the greater the likelihood this is accurate. Walls of code are intimidating even (especially?) for the prompter.

Immediate code. Immediate functionality. Immediate production usage. Immediate user base. Immediate liability.

Suddenly, there was more. If there were no humans in this mix, fine. Computer making computers. But while humans are still programmers, this is jarring for humans.

Remember the humans

Avoid the new AI style of the same false heroics of outpacing your team. Think twice before introduce giant swaths of code. Be honest about your own understanding. Consider your future self and other collaborators.

In all our getting, we need to get understanding. Continue to seek it. Remember that understanding takes time. Be patient with yourself and others.

Prepare yourself and your team to own code for the long term. This is still needful and healthy. Don't build on something that will fall down under the first pressure. Don't tack onto a Frankenstein that you don't understand.

Use the same class of AI tools to help you increase your understanding. And don't forget to work with, ask and help those lovely, uniquely-creative human beings around you.