跪拜 Guibai
← Back to the summary

Code Readability Dies When AI Becomes the Only Maintainer

If you ask a programmer:

What is good code?

Almost everyone will answer with a classic line:

Code is written first for people to read, and only second for machines to execute.

Over the past few decades, the entire software industry has largely revolved around this idea.

Variable names have gotten longer, functions more semantic, and coding standards stricter.

Various Design Patterns, Clean Code, DDD... essentially all solve the same problem:

Making code easier for people to understand.

But recently, a question suddenly occurred to me.

What if, in the future, the main role of writing and maintaining code is no longer performed by humans, but by AI?

Does this whole set of principles still hold up?

1. Why is code becoming more and more like natural language?

Many young programmers might think that code has always been this way.

Actually, it hasn't. The earliest programs were not written for people to read at all. At first, people wrote machine code directly, then assembly, then high-level languages emerged, followed by object-oriented programming, various frameworks, DSLs...

The entire development process essentially moved in one direction:

Making it easier and easier for people to understand code.

Why?

Because the truly expensive part has never been writing code, but maintaining it. A system might run for over a decade, and the people who actually read it are often not the original authors, but those who take over later. So, programmers have been continuously improving "readability."

Some even say:

Programs are primarily written for people to read, and only incidentally for computers to execute.

Over the past few decades, this statement has almost become an industry consensus.

Insert image description here

2. But AI has changed one thing

Previously, only humans maintained code, so code had to be understandable to humans.

Now, things are starting to change. More and more companies are no longer following the pattern: Human writes code → Human maintains code. Instead, it's becoming: Product proposes requirements → AI writes code → AI modifies code → AI refactors code.

The human's role is increasingly becoming that of a reviewer, or even just clicking "Accept."

When AI can understand the entire project, all the context, the relationships between hundreds of thousands of files, and all historical commits, does it really still need "readability"?

The answer might be no.

3. Readability is actually a "human-machine communication cost"

Many people mistakenly think:

Code readability is a technical pursuit.

Actually, it's not.

It's more like a compromise, because the machine doesn't care at all: whether a variable is called user, u, x, or abc123. A machine won't run faster just because a function is written beautifully. The ones who truly need these things are humans.

So: indentation, comments, naming, module division, design patterns—none of these are needed by the computer. They all exist solely to reduce the cost of human understanding.

In other words:

Code is getting closer to natural language not because the machine needs it, but because humans need it.

4. What if AI maintains the code?

Here arises a very interesting question.

If, in the future, 90% of code maintenance work is done by AI.

Will the optimization goals for code change?

Today we pursue:

In the future, these might become:

Note.

"Comprehension" here is no longer human comprehension, but AI comprehension.

By then, code might not be natural language at all.

It might not even adhere to any of today's coding standards.

5. Why AI might not continue writing "human code"

Many people think:

Doesn't AI just write code according to our standards?

Currently, that is indeed the case.

Because today, there are still humans reviewing, debugging, and maintaining, so AI must accommodate humans.

But what if, in the future:

AI generates it itself. AI modifies it itself. AI tests it itself. AI deploys it itself. AI locates bugs itself.

Then why would it still write code for humans to read?

Human language itself is an inefficient form of information encoding.

For AI.

It could completely adopt a higher-density expression that is easier to reason about and associate context with.

This form of expression might be completely incomprehensible to humans.

But AI's comprehension speed would be faster.

Insert image description here

6. Going further, there might not even be "source code"

This is what I find most interesting.

Why do we need source code today? Because humans need to modify, read, debug, and manage versions.

If all these tasks are done by AI in the future.

Then:

Is source code still necessary?

Theoretically, AI could completely:

Requirement → Binary.

Or:

Requirement → Intermediate Representation (IR) → Executable file.

Throughout the entire process, a human might not even see the source code.

Today, we believe languages like Java, Go, Python, Rust... are essential.

In the future, they might just be intermediate languages internal to AI.

What actually runs might directly be the form easiest for the machine to execute.

This sounds crazy.

But think about it carefully:

High-level languages were originally created to make programming easier for humans.

If programmers participate less and less in the implementation process, the importance of high-level languages will also be redefined.

7. The real problem is not technology, but trust

Many people will say:

"Can AI really reach this level?"

I think this is not the most critical question.

What truly determines the future is not whether AI can.

But:

To what extent are humans willing to trust AI.

More precisely:

To what extent is capital willing to trust AI.

If an internet company believes:

AI modifying code is more stable than engineers, AI review is more accurate than manual review, AI troubleshooting is faster than experts, and AI deployments cause fewer incidents.

Then, it has no reason to continue paying the cost for "human readability."

The business world never preserves a technology for sentimentality.

Only for efficiency.

So, who code is written for in the future is not a technical question, but an economic one.

Conclusion

Looking back at the history of computer development, an interesting cycle emerges.

In the very beginning, code was written for machines to read.

Later, because human maintenance costs were too high, code became increasingly closer to natural language.

And after the emergence of AI, we might be walking back down another path.

Code, once again, is starting to be written for machines.

Only this time, the "machine" is no longer just the CPU.

It is an AI capable of understanding, generating, modifying, and maintaining entire software systems.

Perhaps many years from now, human programmers looking at AI-generated code will feel like we do today looking at machine code.

It is still efficient, still correct.

Just, no longer written for us to read!