Long before my time, developers sat feeding computers with punched cards — physical cards with holes representing instructions. Each row was a command. Wrong hole, wrong program. The next generation moved to assembler: cryptic but precise instructions directly to the processor. MOV, ADD, JMP — one step at a time, in the machine's own language.
When I studied computer engineering in the late 1990s, we learned assembler for a brief semester. It already felt like a look back — something you should have seen, but not something you'd want to return to. We had high-level languages, object orientation and abstraction. Yet something important stuck: the core of what we do has always been about giving precise instructions. The format has changed — from holes in cardboard, through machine code and programming languages, to today's natural language with AI agents — but the demand for precision and intent has never gone away.
Over the course of nearly three decades as a software developer, I have experienced a steady, continuous improvement in how we build software and systems. We have moved from manual processes, Word-based deployment instructions and waterfall with requirements specifications and releases every six months. Then came Agile, DevOps, cloud platforms, containers and infrastructure as code. For a long time this was an evolution — a slow but steady shift towards more automation and better collaboration.
When I moved from a traditional developer role to also working with infrastructure and operations in 2012, I got my first digital colleague. Back then it wasn't an instructed AI agent, but PowerShell. Everything that had been manual — configurations and routines — was to be automated. From server setup to rolling deployment.
In early 2024, my team and I started testing GitHub Copilot — cautiously, in "ask mode". It didn't seem likely that GitHub Copilot could contribute much — after all, we have many years of experience writing good code ourselves. But quite quickly we saw that it covered everything we used to get from documentation, Google and Stack Overflow. Although we noticed it could introduce errors and confusion in early versions, it has become much better just in the first part of 2026.
Without really thinking about it, AI tools are used more and more, as a natural part of problem solving, maintenance and feature work.
From autumn 2025, agents arrived in full force: AI tools that don't just suggest code, but plan, write, test and refactor — across files and contexts.
The productivity increase is no longer linear, but exponential.
We practically no longer write code ourselves. What started gradually, as tool support, is now our new way of working.
Technical debt is a familiar topic. The good news is that agents neither procrastinate nor dread tackling it. They do, of course, need clear instructions — humans must still understand and prioritise the need and set the direction.
Do you recognise the feeling of uncertainty when you need to modify legacy code, written by someone who left five years ago? Code that "nobody dares to touch"? With today's AI tools, it's less daunting. The key lies in the approach:
Once the agent has established the tests, it's much safer to proceed with refactoring, cleanup and framework upgrades. And in the best case, you find unused functions or entire modules that can be deleted — joy!
After gradually increasing my use of AI tools for maintaining, problem solving and building on existing codebases, and growing buzz in tech and IT media and among colleagues, I wanted to try building something with AI in my spare time. From scratch, without the natural constraints of an enterprise environment.
After just a few hours hands-on with Claude Code, I had achieved far more than I had imagined. I realised that with good instructions and understanding, anything can be built this way. We don't need to fear security flaws or performance issues — as long as we instruct correctly.
Old debates about languages and tech stacks are no longer as important. Java or C#, JavaScript frameworks — Python, Java or Kotlin, functional like F# or Scala? Pick something the team knows and that is widely used. The team doesn't need to be experts, but they need to understand the code. Now you ask AI to explain any differences from a language you know better — and you learn fast.
As agents take responsibility for ever larger parts of the development cycle, our responsibility changes. What used to be code we wrote ourselves is now intentions and constraints we describe. For agents, precision is everything:
Providing precise descriptions of what to build, how to test it and what boundaries apply regarding security and compliance has become a core competency in modern development.
Job postings ask for frontend, backend or fullstack developers. I've seen "AI developer" — what is that? We will surely see "System Conductor", "AI Orchestrator" and the like, but I would probably read the "Experienced Developer" ad first.
Because what really matters is the same as before: domain understanding, systems thinking and the ability to solve the right problems.
We are the same problem solvers, with the same experience and domain overview. What changes is the tools — and with them, what we spend our time on:
Agents give us speed. Experience gives them safety and direction.
But what about those who haven't yet had time to build up this experience? When agents write most of the code, new developers lose the natural learning arena that we had — writing code, making mistakes, debugging and gradually understanding systems from the inside. Domain understanding, systems thinking and the ability to ask the right questions don't come by themselves.
One answer many of us point to is mob-instructing agents — experienced and new developers sitting together and instructing agents as a group. Not like traditional pair programming where you share a keyboard, but as a collective exercise in thinking out loud.
Throughout my career I have held many roles: developer, system architect, reviewer, test and quality lead, DevOps lead, IaC and CI/CD builder, and problem solver when complex bugs or hidden dependencies surfaced.
I enjoy challenges and happily take on tasks that are not just coding. Today, modern AI agents can take over much of the mechanical and repetitive work. Analysis, coding, documentation, pattern recognition and improvement suggestions happen in seconds.
Imagine an agent instructed to check the logs and find the slowest API calls from the past week where there are more than a thousand calls. It looks at the code, creates a Pull Request with suggested changes, and notifies the team on Slack. A task like that could easily take a developer half a day. The agent does it in minutes.
| Area | Agent handles | We must still own |
|---|---|---|
| Code production | Generates code, tests and refactoring suggestions | Sets architecture, direction and quality level |
| Documentation | Writes drafts, connects information, summarises | Adds context, history and domain insight |
| CI/CD and IaC | Creates YAML files, Terraform suggestions and structures | Defines standards, security and governance |
| System architecture | Suggests patterns | Makes the decisions that require system understanding and experience |
| Problem solving | Analyses error messages and points to possible directions | Assesses priority, risk and the bigger picture |
| Quality and security | Suggests tests and controls | Owns the risk and the quality |
I have not seen a bigger change in how we work, or learned more new things, than in the last part of 2025 and the beginning of 2026.