Manual Coding Is the Assembly of the AI Era

The short version

Writing code by hand today is like writing assembly. Some people still do it. It still matters in a few places. But it's not where most of the work happens anymore.

The job of a software engineer changed. It used to be typing code, across the whole stack, all day. Now I give that part to agents. They write the code. They run the commands. They fix what breaks. What's left for me is the high-level work: the architecture, the product, security, and the memory of where everything is going.

To see why I call it assembly, it helps to look at the whole road.

Before software

Telling a machine what to do is older than software.

In 1804, the Jacquard loom wove patterns from punched cards. Change the cards, change the pattern. No electricity, but it was a program.

In the 1830s, Charles Babbage designed the Analytical Engine, a mechanical computer that was never finished. Ada Lovelace wrote what many call the first program for it.

In 1890, Herman Hollerith's punched-card machines counted the US census. For decades after, computing meant cards, gears and relays. Rooms of people, called computers, did the math by hand.

A program back then was a physical thing. You could hold it. If it had a bug, you punched a new card.

Assembly

The first stored-program computers came in the late 1940s. The program now lived in memory, next to the data. That was the real start of software.

At first people wrote raw numbers: machine code. Then came assembly. Short words like MOV and ADD stood for those numbers, and a program called an assembler turned them back into numbers.

Assembly was a big step up. But you still thought like the machine. Which register holds what. Where each byte lives. A simple loop took many lines. A small program took weeks.

C

In 1972, Dennis Ritchie made C at Bell Labs. Unix was rewritten in it.

C let you say what you meant, a bit more like a person. Variables with names. Functions. A loop in one line. The compiler wrote the assembly for you. And the same code could run on different machines.

Not everyone liked it. The compiler's output was slower than what a good person wrote by hand. Some said real programmers write assembly. They were right about speed, for a while. They were wrong about where the work was going. Compilers got better, machines got faster, and the person's time became the expensive part.

That pattern repeats in every step after this one.

The long line of better languages

After C, it's a long line of steps. Each one took more work off the person.

• C++ (1985) added classes and ways to organize big programs.
• Interpreted languages, like Python (1991), and JavaScript and PHP (1995), dropped the compile step and the manual memory. You write it, you run it.
• Java (1995), and later C#, ran on a virtual machine and cleaned up memory for you.
• Modern languages, like Go (2009) and Rust (1.0 in 2015), kept the speed and added safety. Rust's compiler catches whole kinds of bugs before the program ever runs.

Each step had the same shape. More of the mechanical work went to the machine. The person moved up a level. And each time, some people said the old way was the real way.

Through all of it, one thing stayed the same. A person typed the code. Every line.

The AI era

This is the part that changed the most, and the fastest. Look at the first chart again. More than two hundred years of history, and the AI era is the thin slice at the end. Almost everything in this section happened in the last five years.

Autocomplete and correction

For a long time, editors helped a little. They finished the name of a function. They underlined a typo. They told you a type was wrong before you ran the code. Around 2018, tools like TabNine and IntelliCode started to use machine learning to guess the next word better.

Useful, but small. You still wrote everything.

Copilot predicts the line

In 2021, GitHub Copilot came out. It didn't finish a word. It finished the line. Sometimes the whole function.

That felt strange at first. You typed a comment, and the code showed up in gray. Often it was wrong. But when it was right, it saved real time. For the first time, the machine guessed what you meant, not only what you typed.

Chats

At the end of 2022, ChatGPT came out. Now you could ask. "Write a function that does this." "Why does this break?" "What does this error mean?"

But it was still copy and paste. You asked in one window and pasted into another. You ran it, it failed, you pasted the error back. The person was still the glue between the AI and the code.

Agents

Then came agents. An agent doesn't only answer. It reads the project, edits the files, runs the commands, reads the errors and tries again.

The first ones were dumb. They got lost in big projects. They broke one thing while fixing another. They said "done" when nothing worked. You spent more time checking them than they saved.

That changed fast. Today agents are extremely capable. They work for an hour without me. They write the code, run the formatters, the linters, the type checks and the tests, and keep going until all of them pass. Many of them work at the same time on the same project.

I build all my apps this way now. I don't write most of the code anymore. I almost never type a command into a terminal myself.

Typing code is the new assembly

So here's the parallel.

From assembly to C, the person stopped writing registers and started writing logic. The compiler did the rest.

From C to agents, the person stops writing code and starts writing intent. The agent does the rest.

Writing code by hand today is like writing assembly in the 1980s. It still works. Some people are very good at it. There are places where it still makes sense. But it's no longer how most software gets made, and that grows every month.

What the engineer does now

If the agents do the typing, what's the job?

It moved up, to the parts no agent holds well yet.

• The architecture. An agent works on one task at a time. Someone has to keep the whole picture: which part does what, how the parts connect, what goes where. And steer it, so the project doesn't turn into a pile of pieces that each work alone.
• The product and the business. An agent builds what you ask. It doesn't know if it's the right thing. Someone has to make sure the product matches what the business and its users need.
• Security. This one matters a lot. Agents write code fast, and fast code can open doors. Who can reach what. Where the secrets live. What's public and what isn't. A mistake here costs money, data or trust. A person has to own it.
• Seeing outside the box. Agents are good at the task in front of them. They're bad at asking whether the task should exist at all. Or whether a different idea would make three problems go away.
• The long-term memory. Agents forget. Each one starts fresh. Someone has to remember why things are the way they are, what was tried before, and where everything is going.

None of this is typing. All of it is judgment.

Software is close to the plateau

In How Artificial Intelligence Will Transform 100 Occupations, I split AI into three stages. First AI that thinks. Then AI that works a computer on its own. Then AI that works in the physical world.

Software is an odd case there. It's made of text, and it lives on a computer. So it's the job that took stage one the furthest, and the earliest. Coding agents are already an early, narrow piece of stage two. They work a terminal and files, not any screen.

So what do the next stages still add to software?

Stage two still helps some, I think. An agent that can really see and use any app could test what users see. It could click through every page and notice when something looks wrong. That could make building great UIs much better. Today it's one of the weak spots.

Stage three adds almost nothing. Robots matter where software touches hardware. For most software, there's nothing physical to do.

That's why I think software is already near the plateau. Not the plateau of AI. The plateau of what's left for people in this job. The mechanical part is mostly gone. What's left is taste, direction and alignment. Deciding what to build, whether it's good, and whether it's safe.

Other jobs will get there later, when stage two and stage three arrive for them. Software got there first.

We don't know what comes next

I don't know the next step.

Maybe agents keep getting better at the same speed. Maybe they're reaching a plateau. Some of the latest gains feel smaller than the jump from chats to agents.

Every past step looked final from inside it. People writing assembly didn't see C coming. People writing C didn't see Python. I didn't see agents five years ago.

What I'm fairly sure of is the direction. Each step takes more mechanical work from the person, and leaves more of the deciding.

I wrote about where that goes, past software, in What Comes After AI Can Do Everything. Software is just the first place it happens.

The part that stays

Assembly didn't die. It moved under everything. Every program still runs as machine code. People just don't write it by hand.

Code goes the same way. It will still be there, under everything. It just won't be typed by people.

What stays with us is knowing what we want, and why.