"Developers Will Lose Their Jobs": How You Were All Wrong

I don't write the code of our systems anymore. I write agents that write the code.

And that is exactly why the job panic looks so silly from where I sit.

I run a backend team at a Czech media house. Paywall, subscriptions, OAuth, CRM, mailing. Real systems with real money going through them. Most of my day now goes into rules, permissions, test gates and review steps for agents, not into functions. The work didn't disappear. It moved one layer up, and that layer is harder.

Every new name is a patch on the previous one

Watch the vocabulary of the last four years. Prompt engineering. Context engineering. Harness engineering. Loop engineering. Now graph engineering.

The community treats these like levels of enlightenment. They're not. They're workarounds. Each one exists because the previous one hit a wall.

2022, Prompt. You polish one sentence. "You are an experienced traffic lawyer, what do I do if they clocked me at 150 in a village, asking for a friend." It was a prestigious, well paid job title. Then agents started doing 50 steps in a row and one beautiful sentence stopped mattering.
Weakness: it doesn't scale past a single turn.

2025, Context. agents.md, .clinerules, repo conventions dumped into the window before the model touches anything. Stop guessing, here are the rules of this project.
Weakness: the model knows what to do, but has nothing stopping it from doing something else.

2026, Harness. Sandbox, tests, permissions, logs. The model is just an engine, the harness is the rig around it. There's a number going around that the same model jumps from 52% to 66% on coding tasks purely from a better harness, without anyone touching the weights. I can't verify that number, but the direction matches what I see: most of my quality gains in the last year came from the rig, not the model.
Weakness: you're still the one handing out every task.

Then, Loop. "I don't write prompts anymore, I have loops that assign work to the model." You start it and go get coffee. It watches PRs, fixes CI, picks up feedback.
Weakness: nondeterminism. Run it twice, get two different worlds. Fine for a side project, not fine for a paywall.

Now, Graph. Instead of a loop that improvises, you draw the thing. Code, then ALWAYS review, then merge. No guessing about order. Google reportedly rebuilt their agent dev kit from an agent runner into a graph engine for this reason.
Weakness: unknown so far. There will be one. Probably that the graph itself becomes a codebase nobody wants to maintain.

The skill is spotting the ceiling, not learning the name

Here's what I think people get wrong. They chase the vocabulary. New term drops, half the timeline rewrites their setup that weekend, usually because someone with a big following said so.

The actual skill is different. It's looking at a layer and knowing quickly where its ceiling is, and which lever to pull so the output gets good. Not "which layer is currently correct", but "this one will break on step 30, so I need a gate there".

You don't learn that from a thread. You learn it because you've watched it break a few dozen times. Which is a very old skill wearing a new hat.

What my day actually looks like

• I set the rules, the permissions, the test gates, the review steps.
• The agent works.
• I read diffs and say yes or no.
• When it gets stuck, I finish it by hand.

Less code written. More decisions made. And the decisions are the part that was always hard.

The pattern nobody says out loud

Look at the direction of that chain again. Prompt is a request. Graph is architecture.

Every single layer added since 2022 exists to take freedom away from the model and give control back to a human. Context takes away guessing. Harness takes away access. Loop takes away idle time, and then graph takes away the loop's improvisation.

The better the models get, the more control we take back. Not less.

That's the opposite of the story being sold. "AI writes everything, developers become obsolete" doesn't survive five minutes of contact with a production system. Somebody has to decide where the review step goes, where the rollback goes, which permissions the agent never gets, and whether a PR that looks fine is actually going to break checkout on Friday evening.

The people most sure that developers are finished are usually the people who have never run an agent against a real repo.

So what's next

I don't know.

Maybe the abstraction gets good enough that we end up back at prompting. You say what you want, and underneath it a graph of loops does something nobody fully follows anymore. The circle closes.

Even then, someone designs that graph. Someone maintains it. Someone gets paged when it merges garbage at 3am.

Guess who.

Not interested in which layer you're on. Where did you hit its ceiling? That's the more useful conversation.