Programming is dead, and keyboards are overgrown with grass. The father of Claude Code has a conversation with Karpathy, dropping bombshell quotes throughout.
Andrej Karpathy and Boris Cherny, the head of Claude Code, had an ultimate conversation about the future of programming. Facing the current situation where AI takes over 100% of code writing, Karpathy admitted that humans are at a crossroads between "brain atrophy" and ability evolution.
This article deeply analyzes the paradigm shift from Software 2.0 to Agentic Coding, revealing how programmers can evolve from "bricklayers" to "commanders" with the support of powerful models like Opus 4.5. It also warns that we should not only face the leap in efficiency but also be vigilant about the hidden worry of the "Slopacolypse".
At the beginning of 2026, the tech circle was detonated by a profound conversation about "the essence of programming".
The two parties in this conversation are Andrej Karpathy, the former AI director of Tesla and a founding member of OpenAI. He is the proposer of the concept of "Software 2.0" and has always been at the forefront of the programming paradigm shift. The other is Boris Cherny, the creator of Claude Code and a core figure at Anthropic. He is creating a tool to end traditional programming with his own hands.
Their discussion is not just about the iteration of tools but more like a philosophical speculation about the boundaries of human skills.
When code is no longer typed out character by character by humans, are we evolving or degenerating?
This conversation reveals a cruel but exciting fact:
We are at the singularity of a complete transformation from "imperative programming" to "declarative intent".
"I haven't written a single line of code by hand for two months", from assistance to takeover
The shocking opening remarks came from Boris Cherny, the head of Claude Code.
"Sending out 49 PRs in two days!" This is the current normal work state of Boris's team.
He revealed that the current development work of the Claude Code team is almost 100% completed by Claude Code in combination with Opus 4.5.
"For me personally, this situation has lasted for more than two months, and I don't even make any minor fine - tuning manually anymore." There is a kind of confidence that spans the era in Boris's words.
Whether it is on the CLI command line or on the iOS mobile phone, the entire process of code generation, testing, and submission is taken over by AI.
This is not just a story of efficiency improvement but a story of workflow reconstruction.
Boris shared his extremely hardcore "AI - native" workflow: he usually runs 5 Claude instances simultaneously in the terminal and even opens 5 - 10 more on the web side.
He is no longer the craftsman who types code line by line but a commander who commands an AI army. He uses the "Plan Mode" to let the AI think about strategies first and then switch to the execution mode after establishing a plan. This "parallel development" ability enables one person's output to match that of a traditional small - scale development team.
And Karpathy's experience also confirms this.
He sighed in a long article:
"In November 2025, I was still 80% manual + 20% AI; by December, it directly became 80% AI + 20% manual."
"I'm programming in English."
Karpathy admitted with a bit of self - mockery but also great honesty, "It's a bit of a blow to the ego. Telling the AI what to write is like directing an intern. But once you get used to the 'code operation' ability to control software on a large scale, you can never go back."
In - depth analysis, from Software 2.0 to Agentic Coding
To understand Karpathy's shock, we must trace back to the "Software 2.0" concept he proposed in 2017.
At that time, Software 2.0 referred to replacing the manually written logic (Software 1.0) with neural network weights. The role of programmers changed from "writing rules" to "organizing data".
Today, we are entering the era of Software 3.0 or Agentic Coding.
At this stage, only the "intent" is provided by humans, and the implementation details are completely controlled by AI.
Karpathy acutely pointed out that this transformation marks the ultimate leap of the programming paradigm from "imperative" to "declarative".
In the past: You needed to tell the computer "what to do in the first step, what to do in the second step, and what to do if there is an error".
Now: You only need to define "what the success criteria are".
As practiced by Boris's team, by using the powerful long - range reasoning ability of Claude Opus 4.5 and memory files like CLAUDE.md, AI can understand the overall architecture context of the project.
The dominance shown by Opus 4.5 in benchmark tests such as CodeClash.ai proves that it is not just a code completion tool but an "engineer" with logical reasoning and self - correction abilities.
It can not only write code but also manage dependencies, refactor architectures, and even write test cases to verify its own code.
This "looping verification" ability is the core of Agentic Coding.
AI no longer forgets after writing code. It will run tests, read error messages, and modify code in a closed loop until the tests pass.
This is exactly the moment of "Feel the AGI" that Karpathy mentioned - watching the AI tirelessly try dozens of solutions in 30 minutes and finally solve a difficult problem, humans feel an unprecedented "leverage effect".
Redefinition of the 10x engineer, the victory of generalists
As AI takes over the specific coding work, the definition of the "programmer" profession is being rewritten drastically.
Boris said bluntly: "We now tend to recruit 'generalists'."
In the era when LLMs can automatically complete all technical details, the memorized APIs and specific language tricks of the past are no longer a moat.
You don't need to remember the specific parameters of a Python library function because the AI definitely remembers them better than you.
The real "10x engineers" still exist, but their ability models have been reorganized.
Future top - level engineers will be those with a macroscopic vision - they must be all - rounders who can span product and design, business, and even the underlying architecture.
They are product managers: able to clearly define requirements and identify false requirements.
They are architects: able to design highly available system structures and direct AI to fill in modules.
They are testers: able to keenly detect loopholes in AI logic and set strict acceptance criteria.
Karpathy also raised a profound question: "With the help of LLMs, will generalists completely crush specialists?"
The answer seems to be yes. AI is good at filling in micro - details, while humans need to be responsible for macro - strategies. Future programming is more like playing "Factorio" or "StarCraft" - you are commanding thousands of troops instead of digging every ore yourself. Junior programmers who only focus on "translating requirements into code" will face the most severe survival crisis.
"Disuse atrophy" and "Slopacolypse", the shadow behind the prosperity
However, this revolution is not without shadows. Karpathy's deepest concern is "atrophy".
"I've noticed that my ability to write code manually is slowly degenerating."
Karpathy described this feeling.
In the brain's cognitive functions, generation and discrimination are two completely different abilities.
Previously, programmers strengthened their logic through a large amount of "generation" training (writing code); now, we rely more and more on "discrimination" ability (reviewing code).
This is like how the popularization of calculators has made us lose our mental arithmetic ability.
Although we can still read code (review), the "muscle memory" of building a system from scratch and being familiar with every line of code is disappearing. When you no longer handle memory management yourself and no longer debug concurrent deadlocks yourself, will your understanding of the underlying computer system also become superficial?
What's even more terrifying is the 2026 "Slopacolypse" predicted by Karpathy.
With the proliferation of AI - generated content, the Internet and code repositories may be filled with a large amount of low - quality "garbage" that seems correct but is actually full of hidden dangers.
GitHub may be filled with "shit mountains" generated by AI that no one can maintain.
Karpathy warned: Current AI still makes mistakes, not simple syntax errors, but the subtle conceptual errors that only a "careless junior programmer" would make.
They will over - abstract, pile up dead code, and blindly follow your wrong assumptions. If not controlled, the entropy of software engineering will increase sharply.
In response, Boris holds a "technological optimism" attitude. He believes that the "Slopacolypse" will not come, and the reason is AI reviews AI.
"At Anthropic, for each PR, we open a new context window and let Claude review the code written by Claude."
This "lifting oneself by one's bootstraps" spiral upward is regarded as the antidote by Boris.
As the model's capabilities (especially Opus 4.5 and its subsequent versions) improve, the ability of AI to clean up and refactor garbage code will exceed its speed of creating garbage.
Future IDEs may not only be code editors but also fully automatic garbage recycling stations that clean up the redundancy generated by AI in real - time.
Sublimation: The year of phase shift
Karpathy defined 2026 as "a crucial year for the industry to metabolize new capabilities and undergo a phase shift".
This is not just an improvement in efficiency but the evolution of the species.
We are experiencing a drastic change from "handicraftsmen" to "industrial production".
In this new era, the role of humans has changed from "construction workers" to "architects". What we lose is the feeling of moving bricks, and what we gain is the vision to build skyscrapers. Programming is no longer a painstaking practice of "grammar" and "algorithms" but a release of "imagination" and "logic".
But as Karpathy said, watching the AI tirelessly solve a difficult problem that only human experts could solve in 30 minutes, that "Feel the AGI" moment is both exciting and makes one feel a bit lonely as a carbon - based being.
Programming is dead, long live programming. What is dead is the programmer as a "typist", and what survives is us as "creators".
When you no longer need to be frustrated by syntax errors, the only things that limit you are your imagination and your understanding of the essence of the world.
References:
https://x.com/bcherny/status/2015979257038831967?s=20
This article is from the WeChat official account "New Intelligence Yuan", author: New Intelligence Yuan. Republished by 36Kr with permission.