For seventy years, software was a wall.
You wanted something from a computer? You learned its language. You memorized syntax. You typed exact commands in exact order. You clicked the exact pixel. You filled the exact form field. One typo and the whole thing collapsed with a stack trace that may as well have been written in Latin.
We called this "using a computer." It was actually translation work. Every human who ever opened a terminal was a translator, converting their messy, ambiguous, human intent into the rigid grammar a machine could parse.
Then, sometime around late 2022, the wall cracked.
The wall, in three acts
Act I: Punch cards. You wrote programs by literally punching holes in paper. Get one hole wrong, your job died at 3 AM and you found out the next morning. The machine had zero tolerance for ambiguity because it had zero capacity for it.
Act II: The command line. Better. Faster. Still a foreign language. grep -rEi "pattern" . | awk '{print $2}' | sort -u is, objectively, magic — but it's also objectively not English. You had to become bilingual.
Act III: The GUI. The big democratization. Pictures, buttons, drag-and-drop. Anyone could use a computer now. But notice what didn't change: you still had to find the right button. You still had to know the menu lived under File > Export > Advanced > As PDF... You weren't speaking to the machine. You were navigating its map.
Every act got friendlier. None of them broke the wall. The human always had to meet the machine on the machine's terms.
What actually changed
The thing that broke isn't "AI got smart." That framing misses it.
What broke is this: for the first time, software can interpret intent.
You can say "find me the bug that's making logins fail on mobile" and a system can reason about what you meant, look at the right files, propose a fix, and explain its reasoning. Not because someone wrote a findBugInMobileLogin() function. Because the interface itself is now negotiable.
That's the shift. The interface used to be a contract — fixed, brittle, take-it-or-leave-it. Now the interface is a conversation. You bring your messy human request. The machine meets you partway. If it misunderstands, you correct it. If you're vague, it asks. If you change your mind, you say so.
This is not a small UX improvement. This is the inversion of seventy years of computing.
What it feels like to build now
I've been writing software for a while. The feeling of building today is genuinely different, and I want to name what changed:
You stop translating. You used to spend half your day converting "I want users to be able to undo their last action" into a state machine, a stack, a serialization format, a UI affordance, a keyboard shortcut, and seventeen edge cases. Now a lot of that translation happens with you, in plain English, and you spend your time on the parts that actually need a human — the taste calls, the product decisions, the architecture trade-offs.
The boundary moves. The interesting line used to be "what's possible in the language." Now it's "what's possible to specify clearly." If you can describe it precisely, you can probably build it. Which means writing — actual prose writing — is suddenly a software engineering skill. The clearest writers are shipping the fastest code.
Reviews matter more, not less. When the machine can produce 500 lines in 30 seconds, the bottleneck moves to judgment. Is this the right abstraction? Does this match how the rest of the system works? Will this be readable in six months? Those questions can't be outsourced. If anything, the premium on engineers who can answer them well just went up.
The thing nobody talks about
Here's what I think the next five years actually look like:
Software stops being something you use and starts being something you talk to. Not in a creepy "Hey Siri" way. In a "the dialog box is a chat" way. The form is a conversation. The settings panel is a request. The error message is a discussion.
This sounds dystopian if you imagine it badly. ("So now I have to small-talk with my spreadsheet?") But imagine it well: every piece of software you use has a knowledgeable colleague sitting inside it, and that colleague speaks your language, knows the docs, has read your code, and never gets tired. The wall is gone. You're not learning the software anymore. The software is learning you.
The implications for accessibility alone are enormous. Anyone who couldn't navigate a GUI — because of vision, motor control, language barrier, age, unfamiliarity — couldn't fully use computers. The CLI was even worse. Now? If you can describe what you want, the machine can probably do it. The set of people who can productively use software just got dramatically larger.
What this means for us
If you build software, the job isn't disappearing. It's changing shape.
The parts that were drudgery — the boilerplate, the glue code, the syntax-wrangling, the "I know what I want, I just don't remember the exact API call" — those parts are getting compressed. Good. They were never the interesting part anyway.
The parts that are getting bigger: figuring out what to build, why, for whom, and how it should feel. Taste. Judgment. Architecture. The ability to look at a working prototype and say "this is wrong, here's why, here's what would be right." That work is more valuable now, not less. Because anyone can produce code now. Producing the right code still requires a person who has thought hard about the problem.
The wall between humans and machines didn't fall because machines got more powerful. It fell because they finally got humble enough to meet us where we are.
That's the part that took seventy years.
That's the part that's worth paying attention to.
If this resonated, I'd love to hear what shifted for you. The first time the wall actually felt gone — what were you doing? What did it feel like?
