No human will ever write code better then LLMs
Viraj Nikam
My conviction about the future of coding, and why understanding the problem, judging the result, and owning the outcome matter more than typing every line.
- llms
- ai
- software-development
- coding
Note
I believe we are moving toward a point where no human will write code better than LLMs. Once that gap becomes wide enough, I do not expect humans to take the lead again by typing faster or memorizing more syntax.
That is the conviction behind this title. I am talking about the direction I expect software development to take, rather than claiming that every model already beats every engineer on every task today.
For me, better code solves the right problem, behaves correctly, is understandable, and holds up when requirements change. Producing more lines in less time is useful only if those lines deserve to exist. A model does not get extra credit for generating a thousand lines when twenty would do. Neither should a human.
The competition I do not want to enter
I do not want to build my identity around manually producing something a machine can produce more effectively. If an LLM can implement a feature well, I want to use it. I do not need to type every line to take ownership of the work.
The difficult part is deciding what should happen. What does the user actually need? Which existing behavior must remain intact? Where does the data belong? What happens when a request fails halfway through? What evidence would convince me that the change is correct?
Those questions give the implementation its purpose. A vague request can produce a polished solution to the wrong problem.
Generating code does not settle whether it works
My confidence in LLMs does not mean I should trust an implementation because it looks convincing. A generated solution can miss an edge case, misunderstand a business rule, or introduce an abstraction that makes a small change harder to maintain.
I still need to read the changes, trace important behavior, and check the result. A passing test matters only when it tests the requirement I actually care about. A working screen matters only when the underlying operation is also correct.
If I cannot explain why the solution works, I have more work to do. Accepting generated code without understanding it leaves me responsible for a system I cannot confidently change.
I still need to learn the fundamentals
Databases, networking, security, architecture, and debugging remain worth learning. They help me recognize when a plausible answer is a bad fit.
Knowing how transactions work helps me question a partial update. Understanding browser security helps me spot unsafe assumptions. Understanding the existing architecture helps me keep a convenient change from becoming a maintenance problem.
The stronger my understanding, the more precise my instructions and reviews can become. I want better judgment, including the judgment to recognize when the model has found a better approach than mine.
What accepting this changes for me
I want to spend less energy defending manual coding as a measure of skill. I want to spend more energy describing problems clearly, providing useful context, questioning assumptions, and verifying what gets delivered.
I also want to stay open to models improving at planning, reviewing, and debugging. I do not want to declare those activities permanently human just because they are harder to automate well today.
My position is simple: I expect LLMs to become better at writing code than any individual human. My response is to learn how to build well with them and remain accountable for what I ship.
The question I care about is whether I can turn a real need into reliable software. That is the work I want to get better at.




