From machine code to skills

In January 2023, Andrej Karpathy – former head of AI at Tesla, co-founder of OpenAI – posted six words that rewired how an entire industry thinks about software:

The hottest new programming language is English

Andrej Karpathy

Researcher

It was a tweet. It read like a punchline. But two years later, it’s the most accurate prediction anyone made about where software development was heading.

We’ve spent the last two years at DevRev building on that exact thesis. Not as a slogan – as an architecture. And watching the progression from where computing started to where we are now, the pattern is unmistakable.

From Binary Instructions to Natural Language

In the 1940s, programmers fed binary instructions into machines by flipping physical switches. Machine code – raw 1s and 0s – was the only language hardware understood. Writing software meant thinking like a circuit.

Assembly language arrived in the 1950s and gave those 1s and 0s human-readable mnemonics: MOV, ADD, JMP. You still had to think like the machine, but at least you could read what you wrote. Grace Hopper, who built the first compiler in 1952, was told by colleagues that computers could only do arithmetic – they couldn’t understand English. She proved them wrong, and the distance between human intent and machine execution started to shrink.

Then came high-level languages. FORTRAN (1957), COBOL (1959), C (1972), Python (1991). Each generation traded machine efficiency for human expressiveness. You stopped telling the computer how to move memory and started telling it what you wanted. A sorting algorithm went from 200 lines of assembly to list.sort().

By the 2000s, frameworks abstracted away even more. Rails, React, Terraform – you described the outcome, and the framework handled the plumbing. Infrastructure as Code meant you could provision a fleet of servers with a YAML file.

Then, in November 2022, ChatGPT arrived. And suddenly, Karpathy’s tweet made sense to everyone – not just the ML community. You could describe what you wanted in plain English, and working code came back. Prompts replaced syntax. Intent replaced implementation.

But here’s the thing about prompts: they’re still one-shot. You type, the model responds, the context window closes. Every new conversation starts from zero. A prompt is a powerful instruction – but it’s not a program. It doesn’t persist. It doesn’t learn. It doesn’t compound.

That’s why prompts were just the intermediate step.

The real shift: from prompts to skills

At DevRev, we watched this progression and asked the obvious question: if English is the programming language, what’s the runtime?

Prompts give you a single response. Skills give you a persistent capability.

A skill is a natural-language definition of what an AI agent can do – complete with the context it needs, the systems it connects to, the permissions it respects, and the memory it draws from. You don’t write a skill in Python or JavaScript. You write it in English. You describe the goal, the constraints, the workflow. The agent handles execution.

Here’s what that looks like, concretely. A support team doesn’t write code to auto-resolve billing tickets. They describe the skill: “When a customer asks about a charge, check their subscription status in Salesforce, cross-reference with the last three invoices, and draft a response explaining the line item. If the charge was an error, issue a credit and notify the account manager.” That’s a skill. Written in English. Running in production.

This is the leap Karpathy’s tweet anticipated but didn’t fully articulate. English isn’t just the language you use to talk to a model. It’s the language you use to program a persistent, context-aware, permission-respecting agent that operates across your entire business.

Why this is different from “no-code”

We’ve heard the “no-code” promise before. Drag-and-drop workflow builders. Visual programming. They moved the abstraction up a level but still required you to think in flows, conditions, and branches – still computational thinking dressed in a friendlier interface.

Skills are different because the runtime changed. The agent doesn’t execute a flowchart. It reasons over a knowledge graph, Computer Memory that contains the full context of your business: customers, products, tickets, code changes, approval chains, escalation patterns, and every relationship between them. It doesn’t need you to map every edge case because it can read the precedent from the graph.

Grace Hopper fought for compilers because she believed humans shouldn’t have to think like machines. Seventy years later, they finally don’t have to.

The stack, rewritten

Here’s the timeline in one frame:

1940s – Machine code: Tell the hardware exactly what to do, bit by bit.

1950s – Assembly: Human-readable mnemonics, still hardware-bound.

1970s-90s – High-level languages: Describe logic, compiler handles the machine.

2000s-10s – Frameworks and IaC: Describe the outcome, framework handles the logic.

2022-23 – Prompts: Describe intent in English, model generates a response.

2024+ – Skills: Describe a persistent capability in English, agent executes across systems with memory.

Each jump didn’t just add convenience. It expanded who could build software and what they could build. Machine code was for electrical engineers. Assembly was for computer scientists. High-level languages were for developers. Frameworks were for product engineers. Prompts were for everyone.

Skills are for teams. Not just the person writing the prompt – but the organization whose context, permissions, and memory the agent draws from every time it runs.

What comes next

Karpathy was right. English is the programming language. But the real breakthrough isn’t the language – it’s the runtime: a persistent memory, a two-way connection to every system your company runs on, and agents that don’t just respond but act, with the full context of every decision your organization has ever made.

The distance between human intent and machine execution has been shrinking for 80 years. With skills running on Computer Memory, it finally hit zero.

Computer, by DevRev, turns natural-language skills into persistent, context-aware agents backed by Computer Memory – a patented, permission-aware knowledge graph – and AirSync, our two-way sync engine across 50+ enterprise systems. The hottest new programming language is English. The runtime is Computer.

See the Computer Skills in production →