---
Title: "From machine code to skills"
Url: "https://devrev.ai/blog/from-machine-code-to-skills"
Published: "2026-05-09"
Last Updated: "2026-05-09"
Author: "Arth Gajjar"
Category: "Blog, Computer"
Excerpt: "Andrej Karpathy called English the hottest new programming language. Two years later, skills running on Computer Memory turn that thesis into production reality."
Reading Time: 6
---

# 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](https://x.com/karpathy/status/1617979122625712128). 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](https://devrev.ai/meet-computer) 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 →](https://devrev.ai/request-a-demo)





## FAQ

### What did Andrej Karpathy mean by “English is the hottest new programming language”?

Karpathy’s January 2023 tweet captured a shift already underway: large language models let people describe what they want in plain English instead of writing code. It went from a clever observation to a defining thesis for the AI era.

### How is a skill different from a prompt?

A prompt is one-shot – you type, the model responds, and the context window closes. A skill is a persistent capability written in natural language that an agent executes repeatedly, across systems, with memory and permissions intact.

### Does this mean developers are no longer needed?

No. The abstraction layer changed, not the need for critical thinking. Developers shift from writing implementation code to designing skills, tuning agent behavior, and building the infrastructure (like Computer Memory) that makes natural-language programming reliable at enterprise scale.

### How is this different from no-code platforms?

No-code tools still require computational thinking – you design flowcharts, map conditions, and handle branching logic visually. Skills describe outcomes in English. The agent reasons over a knowledge graph to handle edge cases, precedent, and cross-system context without requiring you to anticipate every path.

### What is the “runtime” for English as a programming language?

At DevRev, the runtime is Computer Memory – a patented, permission-aware knowledge graph – combined with AirSync, a two-way sync engine connected to 50+ enterprise systems. Skills execute against this runtime, giving agents the context and permissions they need to act.