A follow-up to "Hiring AI-assisted Junior Developers," December 2022.

In December 2022, two weeks after ChatGPT launched, I published an article saying your next hire would probably be an "AI Prompter" — someone whose value wasn't coding skill but the ability to formulate the right question. I wrote that the Junior position, per se, was falling off, that some external contractors would become unnecessary, and that paying per token was incomparably cheaper than paying per head.

That article got the reaction you'd expect at the time: some agreement, some polite eye-rolling, and a fair amount of "the tech is impressive but it won't replace real developers."

Nearly four years later, it's time to grade my own homework. Some of it aged embarrassingly well. Some of it aged the way milk does. And the most interesting parts are the things I didn't see coming at all.

What I got right

The Junior position, as it existed, is gone. Not "under pressure" — gone. Employment for software developers aged 22–25 dropped roughly 20% between late 2022 and mid-2025, according to Stanford's Digital Economy Lab analysis of ADP payroll data. New graduates now make up a small fraction of Big Tech hires — around half the pre-pandemic share. Meanwhile computer science graduates face unemployment rates above the national average, which would have sounded like satire in 2019 when we were all fighting over the same bootcamp graduates.

The role I said would disappear was the person hired to do the work AI does trivially: boilerplate CRUD, glue code, test scaffolding, the tickets nobody senior wanted. That work didn't move offshore this time. It moved into the machine.

The contractor math. Paying per token instead of per invoice turned out exactly as predicted, except more so. In 2022 I was comparing an AI subscription against a junior contractor's day rate. Today a single developer with an agent harness running overnight produces what used to be a small outsourced team's sprint. Entire categories of outsourced work — maintenance patches, migrations, test coverage, internationalization — simply stopped being things you contract out.

Common sense and character over coding skills. This was the hiring criterion I proposed in 2022, and it's the one line from that article I wouldn't change a word of. More on this below, because it turned out to be more important than I understood at the time.

What I got wrong

The "AI Prompter" as a job. I was right that a new skill was emerging and wrong about it becoming a position. For about eighteen months it looked like I'd nailed it — "prompt engineer" became a real job title with salaries north of $300K, companies posted for it, LinkedIn filled up with certificates. And then the title died. Not because the skill stopped mattering, but because it dissolved into everyone's job, the way "computer literacy" stopped being a line on a CV. The models also got better at interpreting sloppy instructions, which quietly deleted most of the craft. What survived wasn't prompting — it was something bigger: deciding what context the machine sees, what tools it can touch, and what "done" means. The industry eventually named it context engineering, and then even that started to look too narrow.

The unit of work. In 2022 I thought the human's job was asking good questions and the AI's job was answering them. Question in, code out, human in the middle of every exchange. That model lasted about two years. Today the unit of work isn't the prompt — it's the delegated task. You describe an outcome, the agent plans, writes, runs, tests, fails, retries, and comes back with a pull request. The conversation I was so impressed by in 2022 is now the fallback mode, what you drop into when the delegation didn't work.

The pace. I thought I was being aggressive. I described a two-week experiment where a Java/React product that would have taken us months took days. That number now reads as quaint. The same build today is an afternoon, and the human isn't typing during most of it.

The middle of the journey

In July 2024, halfway between then and now, I wrote a piece arguing that Behavior-Driven Development with LLMs was the natural next methodology: natural-language scenarios as the contract, AI generating and refining them, humans reviewing, code generated from approved behavior specs. I predicted developers would become "AI wranglers" — orchestrators who guide and review rather than type.

I bring this up not to pad my scorecard but because of why it turned out to matter. The mechanics I described — Gherkin scenarios, Cucumber, the tooling — aren't the part that survived. The part that survived is the principle: when the machine writes the code, the specification becomes the source code. The industry arrived at the same place under different names — spec-driven development, plans, task files, agent instructions — but it's the same move. The scarce artifact is no longer the implementation. It's the precise, testable description of intended behavior. Every team running agents seriously today maintains exactly that, whether they call it BDD or not.

And "human-in-the-loop," which in 2024 I framed as reviewing what the AI suggested, inverted. The loop is now the agent's; the human is the checkpoint it must pass through. That's not a smaller role. It's a different one, and it's harder.

Where we actually are in 2026

Strip away the hype and the counter-hype, and the picture looks like this.

The overwhelming majority of developers use AI in their daily work — the Stack Overflow survey has it at 84% and climbing, and the real number among working professionals is effectively everyone. The autocomplete era (2021–2023) gave way to the chat era (2023–2024), which gave way to agents (2025–). "Vibe coding" got its name in early 2025, produced a wave of shipped-in-a-weekend products, then a wave of security incidents and unmaintainable codebases, and then — this is the part the doomers missed — the tooling and the practices grew up around it. The lesson wasn't "don't let AI write code." The lesson was that generation was never the bottleneck. Verification is.

Which brings us to the uncomfortable part.

The industry took the advice too literally

I said the Junior position falls off. The industry heard "stop hiring young people" and executed with enthusiasm. Entry-level postings collapsed while senior demand stayed strong. Internships dried up. A generation of graduates is stuck in a loop: every posting demands experience, and the traditional way of acquiring experience — being hired to do the simple work — no longer exists, because the simple work no longer exists.

Here's what I didn't say in 2022, and should have: the junior position and the junior pipeline are two different things. Killing the first without replacing the second is how you get a senior-engineer shortage in 2032. Seniors are not hired, they are grown, and we've collectively stopped planting. Companies that figure out how to grow people under the new conditions — where the growth medium is no longer "write ten thousand lines of CRUD" — will own the next decade's talent market, because everyone else is competing for the same aging cohort of pre-AI seniors.

Who I hire now

In 2022 I closed with a list of skills for the AI-assisted junior developer. It included things like "knowledge of AI technologies" and "proficiency in relevant programming languages." Reasonable at the time; obsolete now. Knowledge of AI tools is table stakes — the twenty-two-year-old has been using them since school. And proficiency in a specific stack matters less every year, because the stack is whatever the agent is fluent in this month.

Here's the 2026 version. When I evaluate someone today, junior or otherwise, I'm looking for:

  • Verification instinct. Can they look at plausible, confident, well-formatted output and ask the question that breaks it? Reading code critically now matters more than writing it fluently. The most expensive person on a team is the one who approves things that merely look right.
  • Specification ability. Can they take a fuzzy business intent and turn it into a description of behavior precise enough that a machine — or another human — cannot misinterpret it? This is the direct descendant of what I called "formulating the query" in 2022, matured into a discipline.
  • Decomposition. Agents fail at big vague tasks and succeed at well-bounded ones. The skill of slicing a problem into independently verifiable pieces is now a daily-use skill, not an architect's luxury.
  • Judgment about failure. Knowing when the machine is confidently wrong, when to stop re-prompting and read the code yourself, when a generated dependency is a supply-chain risk, when the tests passing means nothing because the tests were generated by the same model that wrote the bug.
  • Ownership. The agent produces; the human is accountable. Someone who ships machine-generated work they don't understand hasn't been augmented — they've been replaced and just doesn't know it yet.
  • Common sense and character. Unchanged from 2022. Still the hardest to find, still impossible to generate.

Notice what this list actually is: it's the senior engineer's skill set, demanded at entry level. That's the real transformation, and the real problem. The junior of 2026 isn't cheap labor anymore — they're a supervisor of unlimited cheap labor. We're asking people to start their careers in a management role over a workforce that never sleeps, never pushes back, and lies with total confidence. Some young people are shockingly good at this, better than seniors who can't let go of the keyboard. They grew up with these tools and have no muscle memory to unlearn. Those are the ones I hire.

Embrace the change. Again.

In 2022 the question we set out to answer was whether AI was friend or foe for our business. That question is dead. Nobody runs that experiment anymore, the same way nobody runs an experiment on whether to use version control.

The 2026 question is harder and more personal: when the cost of producing software approaches zero, can you still tell good work from plausible work? Everything I've watched over these four years — the rise and death of the prompt engineer, the vibe-coding hangover, the junior hiring collapse, the quiet victory of specification over implementation — reduces to that single test.

Machines produce. Humans are accountable for what's produced. Hire the people who understand the difference, whatever their age and whatever their CV says. In 2022 that was a prediction. In 2026 it's just how we hire.

Evgenios Skitsanos is the founder of Gedank Rayze, LDA. The original article, "Hiring AI-assisted Junior Developers," was published on LinkedIn in December 2022.