For years I watched the same scene play out. Someone with a real gift for systems, the kind of person who can hold an entire business process in their head and point at the three places it will break, gets curious about software. They open a programming tutorial. They hit the syntax wall within a week. And they quietly conclude the field is not for them.
Most of them never came back.
That wall was never measuring what we pretended it measured.
This question, who is an engineer, has become urgent because AI coding and agentic engineering are rewriting the job in front of us. Some people look at the tools and conclude engineering itself is ending. I look at them and conclude the opposite, and the rest of this article is the argument for why.
The language was a barrier, not the measure
Is knowing a programming language a skill? Absolutely, and a demanding one. I have nothing but respect for the years it takes to master one. But for decades we let it do a job it was never suited for: acting as the entry barrier to engineering itself. You could not even apply your judgment to a software problem until you had paid the syntax toll first. Master the language, and maybe, years later, you would get to do the actual engineering.
The actual engineering is something else. What should this system do, and just as importantly, what should it refuse to do? Where will it fail first? What does that failure cost, and who eats the cost? What is good enough to ship, and what is unsafe to ship? How do you take a fuzzy, messy, human problem and translate it into something a machine can do reliably? Two developers can produce equally correct code and one of them builds something that falls over the first time a real customer touches it. The difference between them was never the language. It was the thinking.
Picture someone who ran vehicle logistics for a transport company. Dispatch, fuel, maintenance schedules, driver rotas, all of it in his head and in tangled spreadsheets. He could not write a line of code, but he understood that system better than any developer who ever interviewed for the role, because he understood what breaks. That is an engineering mind. The barrier had no door for him, so he stayed on his side of the wall and the software stayed worse.
The translation moment
Watch what live translation is doing to spoken languages. Two people who share no common tongue can now sit across a table and negotiate a deal, with a device turning each sentence as it is spoken. That technology did not make either of them a diplomat. It settled an old confusion: speaking Japanese was never the same as having something worth saying.
AI coding settles the mirror-image confusion in software. The programming language stood between people and the machine the way the language barrier stood between the two negotiators. You needed the language to even be heard. Now the translation layer handles the syntax, and the question that remains is the one that always separated real engineers from everyone else: do you know what to build, what will break, and what it will cost when it does?
The people who had that judgment all along but no syntax just got a door. And the industry is about to find out how many of them there were.
This is not the first time the barrier fell
If AI coding feels like a rupture, it helps to know the history. The barrier between human intent and working software has been falling for as long as programming has existed, in roughly four eras, and each drop came with the same announcement that engineering itself was about to become obsolete.
- Machine code. In the beginning you spoke to the computer in its own language: raw binary, ones and zeros, entered by hand. Only a tiny priesthood could do it, and the entire human-to-machine conversation happened at that altitude.
- Assembly. Then came shorthand: mnemonics that stood in for the binary, one small step up. The priesthood called it cheating. It worked, and the barrier dropped.
- High-level languages. Then Fortran, COBOL, C, Python. Describe the logic in something close to human terms and let a compiler translate. Every hand-coder who survived that transition will tell you the same thing: the engineers did not disappear. They stopped writing ones and zeros and started doing more engineering with the hours they got back.
- Natural language. And now the latest era: plain English, or Sinhala, or Japanese, describing what the system should do while agentic coding tools write the code. The barrier is not just lower. It is all but gone.
Look at the sequence and a pattern appears. Each era automated the layer below it. Each time, the daily labor that defined an engineer's work became the machine's job, and the engineer moved up to the layer above. Machine code became the machine's job. Assembly became the machine's job. Syntax is now becoming the machine's job. The latest change with AI coding is not unheard of in the history of this field. It is the fourth verse of the same song, and every earlier verse ended the same way: the tool absorbed the toil, and the engineering escalated.
So the question was never whether the barrier would fall. It was what would be left standing once it did. The answer, every time, has been the engineering.
A subscription is not an engineer
This is where the argument usually gets abused, so let me be blunt about the other side.
Anyone with an AI subscription can now generate code that looks finished. Prompt, get an app, deploy it, screenshot it. That part is real, and it is genuinely new. But a subscription buys you generation. It does not buy you judgment, and production-quality software is mostly judgment.
Production asks questions the demo never does. What happens when ten times the expected users show up? What does this cost to run every month, and does that survive contact with the actual invoice? Where does it leak data, and whose data? What happens when the tidy sample answers meet the messy reality of your records? Who can fix it at 2am when the person who prompted it into existence is asleep? The gap between a demo and a system that survives real users is exactly where engineering lives, and no amount of prompting closes it by itself.
Code that compiles, demos beautifully, and has no answer for any of the questions above is everywhere right now, because prompting has never been the hard part. Meanwhile some of the sturdiest small systems I have come across came from people who could not have passed a syntax quiz three years ago. The variable was never the tool or the subscription. It was whether the person steering had the judgment to know what they were steering into.
The job market is already sorting people this way. Stanford's Digital Economy Lab found that software developers aged 22 to 25, the cohort doing the most routine coding work, lost nearly 20 percent of employment from its late 2022 peak, while developers over 30 in the same AI-exposed category grew 6 to 12 percent. Then Indeed Hiring Lab's July 2026 analysis found the turn: US software development postings have grown almost 15 percent since agentic coding tools took off in early 2025, even as overall job postings fell 7 percent. The rebound is not spread evenly either. Senior roles accounted for 71 percent of the net increase and AI-related titles for 37 percent. If you are worried about engineering jobs in the AI era, that is the pattern to read. It is not engineering disappearing. It is the fluency-only version of the job shrinking while the judgment-heavy version grows, which is exactly what this article predicts: the language layer got automated, so the market stopped paying for the language layer alone.
This is also why my own workflow with AI agents looks the way it does: I describe the outcome, then I build against a frozen copy, and independent checks plus a fixed approval gate judge the result before anything ships. The AI writes a lot of the code. The engineering decides whether it survives. I walked through that full loop in my AI agent workflow, from problem to shipped software, and the approval gate alone has its own story in why your automation needs a human approval gate.
The language barrier was a toll booth. AI coding removed the booth. The road test remains, and it always will.
Yes, the bar went up. The door opened too.
At this point the objection writes itself: if real engineering knowledge is now the requirement, didn't the barrier to entry just get higher? How can I call this a door opening?
Both things are true at once, and the resolution is simple. The entry criteria changed.
Before, the entry criteria was the programming language. If you had the engineering mind but not the coding skill, you were out, no matter how good your judgment was. The industry measured the toll first and the talent later, if at all.
Now the entry criteria is the engineering itself. Problem solving. Turning a messy real-world problem into a practical implementation. The creativity to see a better way the client never asked for. The strategic sense to know what to build now and what to leave for later. The discipline to expect failure and plan for it.
That sounds harder, and it is, in one sense: there is no shortcut through it. You cannot prompt your way to judgment. But notice what it no longer contains. It no longer contains years of syntax mastery as the price of admission. The person with the engineering mind and no coding background can now walk straight at the real test, instead of being stopped at a gate that tested something else entirely.
The toll booth is gone and the road test got harder. That is exactly how it should work.
The commitment is still real. Real engineering knowledge demands effort, passion, years of learning, and a mind that keeps chewing on problems after everyone else has gone home. That was always the price of the craft. The difference is that now every ounce of that commitment goes into the actual engineering, instead of a large share of it being spent learning to appease a compiler.
What was a differentiator is now the core
Here is the sharpest way to see the shift. There was a time when knowing how to code made you an engineer, and something extra made you a good engineer. The something extra was what this article has been describing: problem solving, practical translation, creativity, strategic thinking, the instinct for where systems break.
AI coding moves that something extra from the differentiator column to the mandatory column. Coding fluency no longer makes you an engineer, because the machine handles the fluency. What makes you an engineer is the part that used to separate the good ones from the rest.
That is an elevation, not a demolition. The title did not get cheaper. It got more honest. Not everyone has this capability, and everyone always claimed they did; now the claim gets tested directly instead of being proxied by a language.
What changes now for engineers in the AI era
- More real engineers appear. People who spent twenty years carrying engineering-grade judgment in industries far from software can now build the thing they always saw in their head. That is a larger talent pool, not a diluted one.
- Fluency-only practitioners get exposed. If someone's whole value was translating requirements into syntax, that translation is now largely automated, the same way live translation automated the interpreter's typing. The judgment was always supposed to be the job. Now it visibly is.
- The test changes. Hiring for fluency made sense when fluency was the scarce part. It is not scarce anymore. What stays scarce, and now decisive, is the ability to look at a half-built system and name where it fails first.
None of this cheapens engineering. It finally prices it correctly, and the price is higher than the industry ever admitted out loud.
If you hire software, or buy it
This is the part that matters if you run a business and none of this feels like your problem yet.
When you evaluate someone to build your automation, your internal tools, your customer-facing product, do not ask which languages or AI tools they use. That question now filters for almost nothing. Ask them where the system they last built will fail first, what that failure costs, and what they did about it before shipping. Ask what they deliberately left out and why.
A person who can answer that has the engineering DNA, whether or not they can write a for-loop from memory. A person who cannot will demo you something beautiful and hand you a liability.
The tools will keep changing under all of us. That was always true; AI just made it obvious. What does not change is the mind that expects things to break and plans for it. If you want that mind working on your workflows, book a call and we will stress-test one of your processes together.
Agentic coding, AI coding, vibe coding, agentic engineering: the names will keep changing faster than any of us can update our LinkedIn banners. The substance underneath them is settled. The measure of an engineer is no longer coding ability. It is problem solving, the translation of messy reality into practical implementations, creativity, and strategic judgment. That was always what separated engineers from good engineers. In the AI era, it is what being an engineer means at all.
