The essay nobody re-reads, the prediction everyone is living
In November 2017, Andrej Karpathy published a short essay titled "Software 2.0." At the time he was Director of AI at Tesla and a founding member of OpenAI. The piece argued something that sounded mildly heretical: the act of writing software was about to change kinds. Instead of humans hand-authoring instructions in Python or C, large parts of programs would be specified by datasets and produced by neural networks. Code, in his framing, would be searched for in weight space rather than typed.
Most of us read it, nodded, and went back to writing CRUD endpoints.
Nine years later, in May 2026, that essay reads less like a thesis and more like a roadmap. A new vocabulary, "vibe coding," has gone mainstream. Developers describe what they want in natural language, an AI agent assembles the code, and a working app appears in minutes. It is, almost line for line, the consumer version of Software 2.0. As one widely shared post put it this month, "the line between those two moments is almost perfectly straight."
This article looks at the trajectory, what it actually means for working developers in 2026, and where the line points next.
What "Software 2.0" actually claimed
Karpathy's 2017 piece made three claims that aged unusually well.
1. Specifying a dataset is a form of programming. The "source code" of a Software 2.0 system is the training data, the architecture, and the optimizer. The compiler is gradient descent. The artifact is a weights file.
2. The 2.0 stack will absorb the 1.0 stack from the bottom up. Tasks that humans struggled to specify formally — image recognition, speech, translation, ranking — would flip to neural nets first. The 1.0 stack would survive on the edges: glue code, control flow, business logic.
3. We need new tools and a new craft. Debuggers, IDEs, version control, monitoring — all of these were built for hand-written code. Software 2.0 would need its own version of every one of them, plus disciplines we did not yet have names for.
What he did not predict explicitly was the speed at which natural language would become the interface layer between humans and the 2.0 stack. That part arrived through a different door, large language models, and showed up in everyone's terminal between 2023 and 2026.
Vibe coding is Software 2.0 with a microphone
"Vibe coding," a term Karpathy himself popularized in early 2025, describes the everyday version of this shift. You open a chat box. You say, "build me a small CRM that pulls leads from our website form, scores them, and pushes the hot ones to WhatsApp." A coding agent does the rest: scaffolds the project, writes the schema, wires the integrations, deploys the app, and hands you a URL.
Three things make 2026 different from earlier hype cycles around no-code tools.
- The agent writes real code, not a black box. You get a Next.js project, a Postgres schema, and a CI pipeline you can read, fork, and audit. Software 1.0 lives on as the substrate.
- The loop is fast enough to iterate by feel. Describe, generate, run, watch, adjust. The cycle that used to take a sprint takes an afternoon.
- Cost has collapsed. A capable coding model in 2026 costs cents per task, not dollars. That changes who can afford to build.
This is Software 2.0 wearing a friendly mask. The weights still do most of the heavy lifting. The natural-language layer just lets non-specialists drive.
The straight line from 2017 to 2026
It helps to map the trajectory year by year, because the steps look obvious in hindsight and were anything but at the time.
- 2017: Software 2.0 essay. Neural nets eat perception and ranking. GitHub Copilot is still four years away.
- 2020: GPT-3 demos make people uncomfortable about copywriting. Code generation is still a party trick.
- 2022: Copilot ships. ChatGPT lands in November. Code completion goes from luxury to baseline.
- 2023: First serious "agent" prototypes. Most fail in interesting ways.
- 2024: Coding agents start to ship features, not just snippets. IDEs reshape around them.
- 2025: "Vibe coding" enters the lexicon. Solo builders ship products in days.
- 2026: Coding agents are standard in enterprise dev environments. The question shifts from "should we use AI to code" to "how do we govern fleets of agents."
The arc is consistent: the 2.0 stack keeps expanding from narrow perception tasks into broader software work, and the human role keeps shifting up the stack from typing to specifying.
What it means for working developers, especially in MENA
Across the Noqta network in Tunisia and Saudi Arabia, we see three patterns repeat in teams that adapt well to this shift.
1. Specs become a deliverable, not a memo. When an agent will write the code, the specification is the leverage point. Clear data models, explicit acceptance tests, and an honest list of edge cases now produce dramatically better output than vibes alone. Engineers who could already write a tight spec doc are punching above their weight.
2. Review is the new authoring. Reading and judging code is the bottleneck most teams underestimate. The senior engineers who thrive in 2026 read fast, smell bad code from across the room, and know exactly which questions to ask an agent that handed them a 400-line diff.
3. The unfair advantage is in the integration. Anyone can vibe code a generic CRUD app. Few people can wire that app into TTN El Fatoora, Salla, Zatca, an Arabic-first RTL UI, and the local payment rails. Domain knowledge, regulatory fluency, and language coverage are now the moat. The 2.0 stack commoditizes the generic; it does not commoditize the specific.
For founders in the region, the implication is sharp. The cost of producing a working v1 has collapsed. The cost of producing a product that fits a real local market has not. That is where attention belongs.
What the line points to next
Extending the 2017 to 2026 vector by another five years gives a few honest bets.
- The IDE keeps disappearing. Less typing, more reviewing. The primary surface becomes a conversation log plus a live preview, with the file tree as a debugging aid rather than a daily workspace.
- Fleets, not pairs. "AI pair programming" was a 2024 frame. By 2030 most non-trivial features will be handled by a small team of agents running in parallel, with a human as tech lead.
- Test suites become specs. The artifact that survives reorganizations is the executable specification. Code becomes more disposable.
- New roles appear. Agent ops, eval engineering, prompt and policy review, governance for autonomous changes. These will be normal job titles, the same way "site reliability engineer" was novel in 2010 and standard by 2020.
- The 1.0 stack is not dead. Critical systems, kernels, security primitives, and anything where a wrong answer is catastrophic will stay hand-written, hand-reviewed, and proudly old-fashioned for years.
The honest part of the prediction is the part Karpathy nailed in 2017: the boundary moves, and it keeps moving in one direction.
How to ride the wave, without being flattened by it
A short, opinionated list for builders reading this in 2026.
- Learn to write a spec like your career depends on it, because it does. Acceptance tests, data contracts, edge cases, non-goals.
- Practice reading code under time pressure. Pull a stranger's pull request once a week. Time yourself. Get faster.
- Pick a domain and go deep. Tax, logistics, e-invoicing, healthcare, finance. The agents are generalists. You should not be.
- Treat agents as employees, not magic. Brief them well, review their output, fire the ones that hallucinate, keep the ones that ship.
- Reread Software 2.0. It is a thirty-minute read. It will shape the next decade of your career better than most courses on your shelf.
The 2017 essay closed with a line about the new craft being more empirical, more like training animals than writing proofs. Nine years on, that is exactly the job. The developers who accept it early will spend the next nine years building things their 2017 selves would have called impossible.
Build with Noqta
At Noqta we help teams in Tunisia and Saudi Arabia move from spec to shipped product on the Software 2.0 stack — without losing the rigor of Software 1.0. If you want to talk through where your team sits on this curve, get in touch. It is what we do every day.