Walking the new path

I fell in love with software in 2020, my first year at NTNU. Six years later the craft looks almost nothing like it did back then, and I have had a front-row seat for every twist. This is that story, told as six eras of software development. It is not a history of the industry: it is my own path through it, my reading of where we stand, and my guess at where we are heading.

It maps almost too neatly onto the Dunning-Kruger curve¹: the confidence, the crash, the climb we are on now, and the plateau none of us have reached yet.

Era	What it was	Where it sits on the curve
1.0	The joy of creation	The starting line
2.0	AI-assisted coding	Confidence rising
3.0	Agentic coding	The peak of Mount Stupid
	The fallout	The valley of despair
4.0	Spec-driven development	The slope of enlightenment
	Where we are heading	The plateau of sustainability

1.0: The joy of creation

It was the joy of creating that hooked me. I almost had a god complex: I could build anything, and all I needed was a laptop and the skill to write code. No budget, no team, no permission. It was lovely.

This was software development 1.0. Three things made it work: creativity, programming literacy, and the hours you were willing to pour into building things and learning. Back then they mattered about equally, at least to me. All three are still success factors today, but the balance between them has shifted completely, and that shift is the whole story.

2.0: AI-assisted coding

The keyword here is assisted. In 2021 GitHub Copilot opened its technical preview² and every one of my friends got in, thanks to Sondre Alfnes telling us to sign up. It was absurd. You could write a comment like # Create a Python terminal Sudoku game and Copilot would implement it. Development speed skyrocketed, and nobody had invented the phrase “AI slop” yet.

Then, in November 2022, ChatGPT launched³ and everything changed. For most people “ChatGPT” simply became synonymous with “LLM”, the large language models behind all of these tools. Suddenly you could write whole scripts and entire applications in a chat window, paste the files into your project, and stop reaching for Stack Overflow and Google altogether.

The rest of the field caught up fast. Anthropic and Google shipped serious models, DeepSeek showed you could train a good one cheaply⁴, Meta pushed open source hard⁵, and Qwen, Mistral, GLM and others piled in. Somewhere in there the ground shifted under us, and we noticed that our AI-assisted coding no longer had much assisting in it. We were not writing the code anymore. The AI was.

3.0: Agentic coding

Then, behold: GitHub Copilot Chat.⁶ In my opinion that is where agentic coding, the AI working in your project instead of just answering in a chat, really started. No more copy-pasting, because the chat lived inside the IDE and wrote code straight into my files. It was not a true agent yet, more a very good chat with its hands in my editor, but it felt wild.

Then it evolved fast. AI-first IDEs like Cursor arrived with chat baked in and a whole buffet of models to choose from. Then came the CLI agents: Claude Code, Codex, and the rest. You could configure them until they were genuinely autonomous, hand them your tools, and watch them run. Soon I was not writing a single line of code. I had stopped thinking about code at all and started thinking only about agents and how to use them.

We became vibecoders, every single one of us, and for a while it felt glorious. It felt like I had solved the craft I loved on the first try, except now the agents did the typing. This was the summit. The trouble with the summit of Mount Stupid is that you cannot see the drop on the far side until you are already falling.

The valley of despair

Then the drop. People started forgetting how to write code by hand. There were real doubts about whether any developers would be left in a few years, and people were laid off. I fell into an existential crisis about my career and about the craft itself, the thing that had felt so glorious only a moment before.

We had sprinted up the peak of Mount Stupid and were now tumbling into the valley of despair. But if you know the curve, you know what waits past the valley: the slope of enlightenment, and beyond it the plateau of sustainability. That is where 4.0 comes in.

4.0: Taking back control

The syntax expert is obsolete. The person who knows what to build, and can orchestrate agents to build it, has never been more valuable.

Here is the good news, and it took me a while to see it. The purebred syntax wizard, the person whose whole value was knowing the language cold, is gone. That knowledge simply does not matter the way it used to. What matters now is everything that sits above the syntax: system design, architecture, strategy, taste. Knowing what to build, knowing how it should be built, and being able to judge whether what came back is any good.

So the role of the developer is not dying. I am now convinced it is becoming more important than ever, because the ceiling on what one person can produce has gone through the roof. Point that leverage in the right direction and it is a genuine superpower; point it in the wrong direction and you just generate slop faster.

The way I take back control is spec-driven development: you write the specification, and the agents build to it. Instead of vibing your way to a pile of code nobody understands, you define the intent precisely and let the agents execute against it. In practice, 4.0 looks like this:

Spec-driven frameworks such as OpenSpec and Spec Kit, which make intent the source of truth instead of the code.
Self-hosted and properly configured agents, tuned to how you work rather than left on their defaults.
Git worktrees, so you can run several agent sessions at once, each on its own branch, working in parallel.
Agentic systems and agent orchestration, where you direct a team of agents rather than typing every keystroke yourself.

None of that is a downgrade. The architect and the orchestrator, the person who knows what to build, is exactly who 4.0 needs. That is the slope of enlightenment, and it is a good place to be.

Soon, hopefully: the plateau of sustainability

The plateau is where the noise dies down. The doomers were wrong, the hype was wrong, and what is left is just the work, done well, with better tools. Nobody panics about AI writing code anymore, the way nobody panics about a compiler emitting assembly.

What stabilises here is the balance of skills. Syntax recall stays dead and unmourned. But judgment, taste, system design, and the ability to tell good output from plausible nonsense become the permanent core of the job, because you cannot orchestrate what you cannot evaluate. The developer who reaches the plateau is not a faster typist. They are an editor, an architect, and a verifier.

3.0 proved you can generate slop at a breathtaking rate; 4.0 gave us the specs and the review gates to stop. The plateau is when those practices are just how everyone works, when what the agents produce is something you can trust and maintain in three years rather than merely merge today. The tooling gets boring, in the best sense, the way Git and CI eventually got boring: stable, understood, no longer the story.

And this is where the crisis resolves. The god complex from 1.0 comes back, earned this time and pointed at bigger things. What I fell in love with in 2020 did not so much survive the last six years as grow into this. That is the plateau I want to live in, and I will write the real version of this section once I have been there long enough to know whether I was right.

The peak-and-valley curve, with Mount Stupid and the valley of despair, is a popular internet illustration rather than a figure from Kruger and Dunning’s 1999 paper, which found that the weakest performers overestimated their standing, not that confidence rises and crashes as you learn. See Kruger and Dunning, “Unskilled and unaware of it”, Journal of Personality and Social Psychology 77(6), 1999. I use the curve as a metaphor. ↩
GitHub announced the technical preview on 29 June 2021: Introducing GitHub Copilot: your AI pair programmer. ↩
OpenAI released ChatGPT on 30 November 2022: Introducing ChatGPT. ↩
DeepSeek reported about $5.6 million for the final training run of DeepSeek-V3, counting rented GPU time only. Research, failed runs and salaries are excluded: DeepSeek-V3 technical report. ↩
Strictly, Meta released open weights under its own licence, which the Open Source Initiative says is not open source: Meta’s LLaMa license is not Open Source. ↩
GitHub announced Copilot Chat in March 2023 as part of Copilot X, built on OpenAI’s GPT-4. It went from a private preview to a public beta for business users in July 2023: GitHub Copilot Chat beta now available for every organization. So it was never a GPT-3-era tool. What made it feel new was where it lived, inside the editor and aware of the open project, more than the model behind it. It was still a chat, though. It suggested code and you chose what to apply. The agentic part came later: Copilot’s agent mode, which edits across files, runs terminal commands, reads the test output and keeps going until the task is done, reached VS Code Insiders in February 2025 and every VS Code user in April 2025: Introducing GitHub Copilot agent mode. ↩