FLUTTERISDidier Boelens
← Articles & guides

ai · agentic-coding

35 years in IT, and my favorite key is now Enter

I have never been this productive, and yet I spend part of my days watching AIs work

Didier Boelens · 14 min read

35 years in IT, and my favorite key is now Enter

I have probably never been this productive in my entire career. And yet, I sometimes spend a good part of my days watching artificial intelligences work. A short account, from the inside, of a revolution that is changing our profession faster than our habits.

Difficulty: easy. Not a single line of code in this article, which, given the topic, makes perfect sense.

Foreword

I have more than 35 years of IT behind me, and throughout all those years, what I loved about this job was never really typing code. What I loved was the problem: that moment when you’re facing something you don’t yet know how to do, and you have to search, try, get it wrong and start over until you find the little idea that unlocks everything. I’ve been the architect of very large systems, I’ve always tried to stay one step ahead technically, and with Flutter, I pushed the technology far enough to be recognized as one of the leading experts worldwide. The “presentation” side, on the other hand, always excited me a little less. Moving a button three pixels to the left or arbitrating between two shades of blue was never the highlight of my day, and the designers who have worked with me can confirm it.

Today, I barely program anymore. Nobody stops me, my IDE works perfectly, and I could very well open a file and write a function by hand, like in the good old days. It has simply become very hard to explain why I would.

From the assistant you hold by the hand to the colleague you hand a mission to

Since April 2024, I’ve been following the evolution of frontier models very closely and using them every day, from GPT-4o and Claude Sonnet 3.5 back then to GPT-6 Astra and Claude Fable 5.1 today. In the rest of this article, I’ll call them my “buddies”. Not because I confuse an LLM with a friend, but because our exchanges increasingly resemble the ones you’d have with a brilliant colleague, available around the clock and blessed with a rare quality: they never roll their eyes when I change my mind for the fourth time.

In the beginning, the relationship was far less relaxing. In 2024 and for a good part of 2025, you had to polish every prompt, split the tasks, rein in your ambitions and check everything, systematically. I’d ask for something, my buddy would drift slightly off course, I’d clarify, it would fix three things and break two others, I’d point out the two others, it would apologize very politely… and then go break something somewhere else. It was already extraordinarily useful, but we were still working with AI, a bit like with a very gifted assistant you could never take your eyes off.

The first half of 2026 changed everything, at least in my daily use. The models started understanding what I meant even when I explained it badly, rephrasing my requirements better than I could, uncovering the unspoken and digging much deeper into their analyses than I had asked. I regularly read the rephrasing of an idea I had thrown out in a messy way and think: “Yes, that’s exactly it. It’s even better put than in my head.” Flattering for the tool, slightly humbling for the author. Since July, another step has been taken: agents hold on to their objective over time, run the tests themselves, read the results, fix and retest, and sometimes even take control of an environment to check in real time that what they’ve just built actually works. We’re no longer talking about smart autocomplete, we’re talking about a colleague you hand a mission to.

And me in all this? I’ve become a manager. Without a raise, obviously.

My typical day: analyze, approve, Enter… and wait

In practice, on most of my projects (except those where the client prefers to do without AI, which is entirely their right), my workflow fits in a few lines. I have an idea, I explain it to a buddy and ask it to analyze it, then to counter-analyze its own analysis, because experience has taught me that an idea that looks brilliant for five minutes deserves precisely to be torn apart for the next ten. We refine it together, it proposes a plan, I review it, correct whatever bothers me and hit Enter.

Then I wait.

Since waiting for a single agent quickly gets frustrating, I launch a second one on another project, then a third, sometimes a fourth or a fifth. For a few minutes, the feeling of power is intoxicating: I feel like I’ve become a one-man multinational. Then comes that strange moment when the first agent is thinking, the second is running its tests, the third is reading the documentation of a library I didn’t know existed that very morning, the fourth is visibly waiting for something from me, and I’m drinking my coffee. I could save even more time by dictating my instructions into the microphone, but I keep typing out of respect for the people around me, who have no desire to hear me repeat all day long “No, that’s not what I meant, start over from the beginning.”

The funniest part is that I sometimes launch so many things in parallel that I lose track of where I am. I’ve already closed a window only to discover that an agent had finished twenty minutes earlier and was patiently waiting for my green light. So even my AIs end up getting bored waiting for me, which, let’s face it, is a little insulting.

And when the result isn’t what I hoped for? It still happens, and I’d be dishonest to claim otherwise. But when I analyze these disappointments, I almost always reach the same rather humiliating conclusion: it was my fault. Instructions that were too vague or, on the contrary, too detailed, implications only I understood, not enough examples, or the urge to do everything at once. Knowing how to express precisely what you want has become a technical skill in its own right, and probably one of the most underrated ones right now.

It’s not just my impression

The figures published in recent months tell the same story. JetBrains’ Developer Ecosystem 2026 survey, conducted from May to July among more than 15,000 professional developers, shows that 90% of them use coding agents at work at least once a week, and 68% every day. By their own estimates, nearly half of the code they produce is now fully generated by agents. BairesDev’s Dev Barometer, published in September, shows how fast things are moving: 42% of the developers surveyed say AI writes at least half of their code, compared with 12% a year earlier. They estimate they save thirteen hours of coding per week, but two thirds of them also spend more time than before reviewing what the AI has produced.

That last figure sums up the situation nicely. We haven’t simply invented a tool that lets us write code faster: we’ve started handing code production over to the machine, while keeping the responsibility for what it produces.

OpenAI even built the matching keyboard

If one object had to symbolize this transition, OpenAI released it in July with keyboard maker Work Louder: the Codex Micro, a small $230 keyboard designed to drive development agents. Each “agent” key lights up to show whether its agent is thinking, working, waiting or done (amber when it’s waiting on you, which in my case is likely to be the dominant color), a joystick launches workflows and a dial lets you adjust the model’s reasoning level. OpenAI’s very first hardware product is therefore a keyboard. A keyboard for people who don’t type anymore.

Let’s take a few seconds to appreciate how far we’ve come. For decades, we perfected keyboards so that developers could type code faster, and now we’re building keyboards to monitor the AIs typing the code for us, with a dial to decide how hard our artificial colleague should rack its brains. At this pace, the developer keyboard of 2030 will only have two keys: Enter and “No, that’s not what I meant”. Maybe a third one, “Are you sure?”, because caution remains a professional virtue.

My knowledge is worth less, my experience is worth more

On one point, I have no illusions left: when it comes to pure knowledge, I’m no match. A frontier model knows languages I’ve never used, frameworks I’ve never opened, algorithms I forgot thirty years ago and more publications than I could read in several lifetimes. When I say it knows a thousand times more than I do, it’s obviously not a scientific measurement, but it’s roughly how it feels.

Certifications have become rather amusing as a result. When I prepare for an exam, I ask my buddy to be my instructor: it builds the curriculum, explains each domain in detail, quizzes me, spots my gaps and prepares mock exams. I pass, I receive a nice certificate stating that I, a human, have mastered the subject, and at the first real professional problem on the topic, I say: “Buddy, analyze this for me.” So it taught me what I needed to prove I knew it, so that I could then ask it to apply it in my place. The loop looks absurd, but it’s only half absurd: it’s precisely because I know the subject that I can tell when its answer is right… and above all when it isn’t.

Even other people’s code has lost its mystery. Taking over an existing project used to be an adventure, culminating in that 1,800-line function nobody dared touch because it seemed to handle invoicing, printing and probably the coffee machine all at once. Today, I hand the repository to a buddy who reconstructs its architecture and dependencies in minutes, whether the code is spaghetti or perfectly structured, and without ever complaining. The only thing it lacks is that great tradition of our trade: opening your predecessor’s project and exclaiming “What idiot wrote this?”, before running a git blame and discovering it was you, three years earlier. So we humans still hold a clear cultural lead.

Where experience makes all the difference is judgment. Thirty-five years of projects have taught me to look at a technically magnificent architecture and sense that it’s far too complicated for the problem at hand, to spot the choice that will cost a fortune in three years, or to be wary of a flawless demo that will turn into a maintenance nightmare. Above all, they’ve taught me a golden rule: when a solution looks extraordinarily elegant, start by looking for where the problem is hiding. That’s all the more valuable because AIs have a remarkable talent for presenting a bad idea with enough confidence to make you want to ship it to production. My role now is to set the destination: my buddy proposes the route and takes the wheel, and I make sure it hasn’t decided to go through Vladivostok to get from Brussels to Paris.

So yes, I sometimes get bored. But it’s a privileged kind of boredom

I don’t miss for a second the half-days spent figuring out why a library refused to compile, the 2,000-line merge conflicts or the encoding bug that only showed up on Fridays after 5 p.m. AI has eliminated a phenomenal amount of tedious work and lets me build incomparably more: exploring an idea in a few days rather than several weeks, comparing several architectures before choosing, working in a technology I barely know, running several projects at once. In my entire career, I’ve never had so many possibilities.

What I sometimes miss is the difficulty. Not pointless difficulty, but the kind that keeps you in front of a problem for hours until that little click: “That’s it, I’ve got it.” Give a crossword lover a “Solve puzzle” button and their productivity becomes spectacular: they can now finish 300 puzzles a day. You’ve just slightly missed the point of crosswords. That’s a bit how I feel, some days, in front of my screens.

But look a little closer and the difficulty hasn’t disappeared, it has moved up a floor. The question is no longer “how am I going to code this?”, but “is this really what we should build, how do I express it unambiguously, what constraints should I impose and how do I check that the result is actually good?”. A study published by the NBER in May, Writing Code vs. Shipping Code, illustrates this nicely: tracking more than 100,000 GitHub developers, its authors find that autonomous agents nearly triple the number of commits, while the releases actually shipped only rise by about 30%. Writing code is no longer the bottleneck. Deciding which code deserves to exist, validating it and shipping it, is. For decades, we waited for computers; now they wait for us, which is quite ironic when you think back to all those hours spent staring at Windows 98 progress bars.

No turning back, and that’s a good thing

There’s a lot of talk about a possible slowdown in frontier models. Let’s even imagine the extreme scenario: no progress at all for five years. Would I go back to the way I worked in 2023? Not for a second. Today’s models are already enough to profoundly transform the way software is produced, and there are years of gains left to harvest simply by learning to use them well. Many organizations still use them as a slightly smarter Google, others are cautiously waiting to see more clearly before allowing agents (which is rather wise as long as no governance is in place), and some still hold a three-hour meeting to decide whether the team may install a plugin. Technology has pulled several lengths ahead of organizations, and that’s where the real work lies today: governance, security, data privacy, compliance and adapting processes.

So the IT profession isn’t disappearing. What is gradually fading is the programmer as the main producer of code. The skill moves up a floor: code becomes abundant and judgment becomes scarce, meaning the ability to turn a vague need into actionable requirements, to weigh trade-offs, to recognize a bad solution even when it works and to take responsibility for the result. At that game, 35 years of projects, successes and a few memorable (and very instructive) failures are not a handicap. They’re leverage.

So, what now?

Let’s be clear: I’m not sadly watching the end of my career. I have a front-row seat to a transformation I find fascinating, even if it sometimes produces downright absurd situations. After 35 years spent learning to speak to computers, here they are understanding our language well enough to do a large part of the work for us. We explain, they analyze and build, we check, arbitrate and take responsibility. Then we hit Enter again.

Just this morning, I launched four agents on three different projects. I just checked: everyone is working, except me. So I’m off to get myself a coffee. That one, at least, I insist on doing myself.

And if you’re wondering how to get these “buddies” working in your organization without them taking a detour through Vladivostok, that’s exactly what I do. Let’s talk.

Sources

← All articles

What about your organisation?

Let’s connect these questions to your uses, constraints and next decisions.

Let’s discuss your needs