AI is "Not Real Programming"

Moving up the stack

Someone invented one. Someone else invented zero. For a very long stretch of human history, neither seemed particularly useful. Then electricity arrived, and it turned out that a switch which is either on or off maps cleanly onto a digit which is either one or zero.

Everything after that is the same story repeating: a painful low-level task gets wrapped in an abstraction, purists complain that the new layer is not real engineering, and within a decade nobody works below it anymore. That pattern is worth remembering right now, because AI-assisted coding is simply the newest instance of it.

Voltage, bits and bytes

In 1936, Alan Turing gave a formal definition of what "computable" means. He went on to play a central role in breaking Enigma, and postwar Britain prosecuted him for being gay. The machines that followed ran on vacuum tubes and punch cards, and each individual one or zero became a bit. Group eight of them and you can count to 255. IBM's Werner Buchholz named that group a byte, spelled with a y so nobody would confuse it with a bit in conversation.

Hand-arranging binary was brutal work, so assembly language swapped the raw digits for mnemonics. Better, but still not good. Then Grace Hopper argued that a machine could accept something closer to English, and built the first compiler to prove the point. A compiler is a translator: readable source goes in, machine code comes out, and you never read the output again.

Compilers did not kill programmers. They killed hand-written machine code and moved the job one level up.

The languages that stuck

High-level languages followed quickly, and a surprising number are still in production:

• Fortran for scientists, COBOL for business and government. A large share of global banking still runs on COBOL that nobody wants to touch.

• Lisp, where code is data and data is code, executed by an interpreter rather than compiled ahead of time, and the origin of garbage collection so programmers could stop tracking memory by hand.

• C, from Dennis Ritchie: fast, direct access to memory, and entirely willing to let you destroy your own program with precision. With Ken Thompson he used it to build Unix, whose philosophy of small tools piped together still defines how developers work.

• C++, from Bjarne Stroustrup, which layered classes and inheritance on top of C and started arguments that have never stopped. Games, browsers, databases and engines still run on it.

Along the way, Dijkstra made the case against goto statements and readable structure became doctrine. The 1980s piled on: Turbo Pascal shipped a compiler bundled with a full IDE, while Ada, Erlang, Perl, MATLAB, Objective-C and Smalltalk all appeared. Smalltalk is the one almost nobody used and almost everybody copied.

Three philosophies, one accident

The nineties produced three competing bets. Guido van Rossum designed Python so code would read like thought, with indentation as syntax. James Gosling designed Java for "write once, run anywhere", shipping a virtual machine that executes bytecode instead of native instructions. And Brendan Eich wrote JavaScript in roughly ten days so browser buttons could move.

JavaScript was supposed to be small and temporary. It now runs servers, phones, databases and spacecraft, and the framework arguments it spawned (jQuery, MooTools, Angular, React, Vue, Svelte) show no sign of resolving. The web itself, which experts once compared unfavourably to the fax machine, got built largely in PHP.

The 2000s and 2010s were mostly a cleanup pass: Swift over Objective-C, Kotlin over Java, TypeScript over JavaScript, and Go, Rust and Zig each taking a different swing at C.

What this means for teams building with AI

Then the newest layer landed. Statistical models started as autocomplete, then handled linting and refactors, then whole functions, then working applications. On cue, people announced that programming was finished.

It is not, because typing was never the job. The job is deciding what should exist and judging whether the result is correct. Generating code is now cheap. Being accountable for it is not.

That is the assumption Birdhouse is built on. Agents do the delivery work, and people own direction, review and quality. In practice that means treating generated code as untrusted until a human has reviewed it, giving agents least-privilege access to repositories and secrets, keeping sensitive work on private or local models, and putting a named person behind every merge. The abstraction moved. The responsibility did not.

The takeaway

• Every layer in this history traded control for leverage, and leverage won every time.

• The durable skill across all of them is judgment: architecture, trade-offs, and recognising a wrong answer quickly.

• Teams that treat AI as a new abstraction layer will adapt fine. Teams that treat it as a substitute for thinking will ship things they cannot defend.

Programming is not dead. It just keeps changing the keyboard, and it always will.