Think of it as Yoga for the brain, we are going to stretch a bit.
AI – Are we about to replace the whole dev ladder with three job titles and a token bill?
"This is not the end of Software Engineering, this is the beginning of new stage" --YNOT!
When did “Junior Programmer” turn into “AI babysitter,” and why does the CIO suddenly need a bigger credit card?
Back in the day, software had a whole caste system. Junior Programmer. Programmer. Senior Programmer. Analyst. Lead Analyst. Systems Analyst. Then the CIO at the top, pretending budgets were optional.
Now it’s starting to look like the org chart got put in the dryer and came out… smaller.
The new three-role company (whether we like it or not)
1) The Programmer (now starring: The Machine)
The programmer’s job used to be writing code.
Now it’s increasingly feeding the machine: prompts, context, repo access, guardrails, retries, and the quiet dignity of admitting, “Yes, it runs, but no, we don’t know if it’s right.”
2) The System Analyst (the adult in the room)
This is the person who writes the specs, defines the behavior, designs the tests, coordinates training, and—most importantly—keeps the team from confusing “it compiled” with “it’s correct.”
In the AI era, the SA becomes the truth-police. Because machines don’t “understand” your business. They approximate it confidently.
3) The CIO (chief investor in invisible fuel)
Here’s the cruel joke: writing code is cheaper, but building software can get more expensive, because you end up redesigning workflows, security, pipelines, QA, governance, and half the company’s expectations.
So the CIO has to keep raising money for tokens, infra, and new architecture—while selling a moonshot to people who still think “the cloud” is weather.
And that’s the tidy version. The devil, as usual, is living in the details—and charging by the token.
The big contradiction: the frontier is “lights-out”… and most teams get slower
On one side, you’ve got teams running what amounts to a lights-out software factory: humans write specs, machines generate the code, run validations, iterate, and ship.
On the other side, you’ve got a weird reality check: a rigorous METR randomized controlled trial found that experienced open-source developers using AI tools took ~19% longer to complete tasks—while believing AI made them faster. (metr.org)
That gap—between “AI can do everything” and “why did my day just get harder?”—is where the future of software actually lives.
Because the truth is: bolting AI onto an old workflow is like dropping a jet engine into a shopping cart. You will move fast. You just won’t steer.
The five levels of “vibe coding” (and why most people are stuck in the middle)
Dan Shapiro laid out a clean framework: five levels, from “autocomplete” to “dark factory.” (danshapiro.com)
Level 0: “Spicy autocomplete.” Faster typing. Same human process.
Level 1: “Coding intern.” AI does small tasks; humans review everything.
Level 2: “Junior dev.” Multi-file changes; humans still read the code.
Level 3: “Manager.” Humans steer and approve PRs; AI implements.
Level 4: “Product manager.” Humans write specs + evals; code becomes a black box.
Level 5: “Dark factory.” Specs go in. Working software comes out. No human writes code. No human reviews code.
Most companies think they’re living at Level 4.
Most are actually stuck around Level 2–3, juggling AI output, code review pain, security concerns, and that nagging feeling that the model is “almost right” in the same way a toddler is “almost right” with scissors.
What Level 5 looks like in real life: StrongDM’s “Software Factory”
StrongDM publicly described a system built around two rules:
The clever part isn’t “agents writing code.” Everybody can do that.
The clever part is how they validate:
“Scenarios” instead of normal tests
Traditional tests live inside the repo—so the agent can “teach to the test.”
StrongDM uses behavioral scenarios stored outside the codebase, functioning like a holdout set in machine learning—so the system can’t easily game the grading rubric. (Simon Willison’s Weblog)
A “Digital Twin Universe”
They build simulated versions of external systems (Okta, Jira, Slack, Google tools, etc.) so agents can run full integration behaviors safely, without touching production. (StrongDM)
This is why your earlier point about the System Analyst matters so much:
In a dark factory world, the SA isn’t “writing documentation.”
They’re writing the laws of physics the factory must obey.
The self-referential loop: tools building tools
This gets even stranger: OpenAI has said its GPT-5.3-Codex was “instrumental in creating itself,” helping with parts of the development process—meaning the loop is tightening. (OpenAI)
Meanwhile, Anthropic has publicly leaned into the idea that Claude Code is doing an enormous share of coding work, and they’ve even touted Claude Code hitting a $1B run-rate milestone within months. (Fortune)
So yes: some teams are effectively running factories.
And yes: many normal teams are still stuck in the J-curve dip—slower, but convinced they’re faster. (metr.org)
That’s not a tooling gap. That’s a workflow + culture + honesty gap.
The part nobody wants to say out loud: legacy systems are the speed bump
Dark factories are easiest when you build greenfield.
But most businesses aren’t greenfield. They’re brownfield:
15-year-old code, half-documented logic, tribal knowledge, and the one guy who knows why Canadian invoices do that weird thing on leap years.
For those companies, the first job isn’t “deploy agents.”
It’s extract the real specification from the running system—and that’s deeply human work.
So ironically, AI doesn’t delete “systems thinking.”
It makes systems thinking the entrance exam.
The new career ladder (and why juniors are sweating)
If entry-level work gets automated, the old apprenticeship model breaks. And the data and commentary around junior hiring pressures has been increasingly loud. (The Register)
Which means the “new junior” is less “CRUD endpoint builder” and more:
scenario writer
spec clarifier
systems mapper
integration thinker
edge-case hunter
human-who-can-smell-bad-assumptions
In plain language: the junior has to think like yesterday’s mid-level.
Unfair? Yep.
True? Also yep.
The punchline (and the warning)
So your three-role model is basically right:
Programmer: steers the machine
System Analyst: defines reality precisely
CIO: funds the transition and sells the story
But here’s the twist:
If the “System Analyst” can’t tell the truth about what the system actually does… the factory will manufacture lies at industrial scale.
And the scariest bugs won’t crash.
They’ll politely work… while doing the wrong thing, flawlessly.
BTW - We are in February 2026 - if you are thinking like December 2025 - You are obsolete
