During the holiday, two talks at Sequoia's AI Ascent 2026 were must-watches. One was by Boris Cherny, the creator of Claude Code. The other was by Karpathy.
Both men approached the same topic from different angles and laid it out clearly. The execution layer of programming has been solved. But the direction layer has actually become harder.
The buzz was huge, so here's a catch-up now that the holiday's over!
Claude Code Creator Boris: How Does He Work Now?
Boris said that in the first five months of 2026, he hasn't written a single line of code.
And he barely sits at a computer anymore. His daily operations happen inside the Claude App on his phone. There's a Code tab on the left, running 5 to 10 sessions simultaneously, with a stack of Agents in each—hundreds online during the day, possibly thousands at night.
He invented a workflow he calls Sloop. The principle is simple: have Claude use Cron to schedule future tasks into loops. Run every minute, every five minutes, or every day.
He now has dozens of loops running. One monitors pull requests, automatically fixing CI or rebasing. One maintains CI health, fixing flaky tests on its own. One scrapes Twitter feedback every 30 minutes, categorizes and summarizes it, and sends it to him.
One day he tried pushing the limit and processed 150 PRs in a single day.
At Anthropic, the internal status has shifted too—the entire company no longer writes code by hand. All SQL, all infrastructure, everything is model-generated. His Claude runs loops in the background and automatically communicates with colleagues' Claudes on Slack, troubleshooting together.
While people sleep, AIs are @-ing each other on Slack, aligning, and debugging.
Some context: Boris noted that when Claude Code was first in internal testing, only 10% of his code was written by it. But after Opus 4 launched last May, Claude Code's growth curve took off—from 4 to 4.5 to 4.6 to 4.7. Each model update was reflected wildly in user growth. He conceded that Claude Code may have been a bet against PMF, but it represents a new pattern: building a harness for a model that doesn't yet exist.
For him personally, the era of programming is over.
Karpathy: Software 3.0
Karpathy's angle was particularly interesting.
He talked about a project he previously built called Menu Gen.
The function was simple: snap a photo of a menu, and AI generates what each dish roughly looks like. He vibe-coded a complete app, deployed it to Vercel, used OCR to recognize dish names, and called an image generation model.
But he soon discovered someone had built a more direct version. They fed the photo to Google Gemini and had Nanobanana render the dish images directly onto the original menu at the pixel level. Input one image, output one image—no traditional application logic in between.
After seeing this, Karpathy realized his entire Menu Gen was already obsolete. That app theoretically shouldn't exist.
He elevated this phenomenon into a larger framework. LLMs are a new kind of computer. Traditional code is Software 1.0. Training neural networks to get weights is Software 2.0. Prompting is Software 3.0. What you stuff into the context window is your programming.
Another very concrete example is the installation method for OpenClaw. In the past, tool installation might involve a shell script, but OpenClaw uses a text description. Throw the documentation at your agent, and the agent reads the environment, makes judgments, debugs itself in a loop, and eventually installs it.
Now we need to think about which piece of text to give the agent.
People shouldn't only focus on "programming got faster." The more critical change is that broader information processing is becoming automatable. Previously code handled structured data, but now you can dump a batch of documents in and have the model recompile that information into entirely new knowledge structures. These were things previously impossible.
Jagged Intelligence
Model capabilities are highly uneven, like a jagged edge. In domains like code and math—highly verifiable areas—they're better than nearly all humans. But step outside that range, and they can look stupid.
There are two layers of reasons. First, training methodology: the most advanced large models are tuned with reinforcement learning—points for correct answers. Code just happens to be the easiest thing to verify. Second, what the labs themselves prioritize: tasks with high economic value get shoved into the distribution, and code is the most typical example.
Karpathy also cited a telling detail: from GPT-3.5 to GPT-4, the model suddenly got much better at playing chess. Many assumed it was a side effect of general intelligence improvement. But the more likely reason was that a large volume of chess records was added to the pre-training data. Whatever the labs decide to put in determines what capability distribution you get.
Karpathy says models aren't animals; they're ghosts. Animals have internal motivation, curiosity, self-drive. Models are jagged entities shaped by data and reward functions. Yelling at them won't make them try harder. Encouraging them won't make them more motivated. They're statistical simulation circuits.
And only by understanding this can you use them accurately.
What Do Humans Do in This System?
Boris said his role has turned into orchestration. He cares about how loops run, how dependencies between agents auto-resolve, how CI maintains itself. Execution is fully handed off.
Karpathy said humans must handle specification and planning. He said he doesn't particularly like the so-called plan modes. He thinks what matters more is designing a very detailed spec together with the agent, then having the agent fill in the implementation. Humans handle the big structure and constraints; agents handle the blanks.
He gave a concrete example. In Menu Gen, the agent used Stripe payment emails to match Google login emails for credit allocation. But a person could completely use different emails on both sides. The design judgment that "email is not user ID" is something the agent cannot make.
But specific execution details can be handed off. In PyTorch, whether it's keepdims or keepdim, dim or axis—these don't need to be memorized anymore.
However, human understanding of underlying principles can't be discarded. How tensor storage and views work, when you're pointlessly copying memory—these you need to know yourself.
Karpathy also quoted something he thinks of every couple of days: "You can outsource thinking, but you cannot outsource understanding."
Interviews, Moats, and Startup Opportunities
Both mentioned that interview methods need to change.
If you're still having candidates grind algorithm problems and solve puzzles, you're filtering for the last generation of engineering capability. Karpathy gave a specific case: have a candidate build a full-featured, secure Twitter clone, then attack their deployed site with ten Codex or Claude instances and see if they can breach it. Whoever holds up in that environment is this era's engineer...
Boris noted a change that's already happening from a team perspective. On the Claude Code team, engineering managers, product managers, designers, data scientists, finance people, user researchers—everyone is writing code. Not because they're all programmers, but because writing code no longer requires professional programmers.
When the cost of writing code drops 100x, switching costs are nothing against AI—models can easily migrate data from one platform to another. Process efficiency is also devalued; models excel at streamlining workflows. But network effects, economies of scale, and monopolistic resources still hold. His prediction: startups that can disrupt existing markets will increase 10x over the next 10 years.
Karpathy's advice to founders is more specific. Don't chase the escape velocity of large models; build your own RL environment. Verifiability determines which domains will be cracked first, and many extremely valuable RL environments remain unexploited. If you can build a sufficiently good reinforcement learning environment and dataset in a vertical domain, you can capture enormous leveraged returns.
But he laughed when he said this: "It's not convenient for me to spell out the answer directly."
Closing Thoughts
Boris drew a historical parallel. In the 1400s, only 10% of Europeans were literate. Fifty years after the printing press was invented, published literature exceeded the total of the previous millennium. The cost of books dropped 100-fold. Eventually global literacy rose to 70%. But the profession of writer still exists.
Programming is going through the same thing. In the future everyone will program, just as everyone can read and write now. But this doesn't mean engineers disappear. It means the core competency of this role shifts from "writing code" to "knowing what to tell AI to write, and what conditions absolutely cannot be skipped."
The ceiling of the execution layer has already been punched through by models. But because of models' jagged intelligence, humans still can't let go in many places.
This is the complete map of programming in 2026.
Execution goes to the model. Direction stays with humans.
Boris original video: https://www.youtube.com/watch?v=SlGRN8jh2RI
Karpathy original video: https://www.youtube.com/watch?v=96jN2OCOfLs