There's no moral in writing code
There’s a lot of noise right now about AI and software development. On one side, people are saying, “In three years, there won’t be any developers left; AI will just do all the work.”
On the other side, you’ve got people saying AI code isn’t worth more than what a three-year-old could write.
How comes?
AI is a new tool. It’s part of our toolbox as a developer. Like any tool, it’s not about whether you use it; it’s about how you use it and what you get out of it. If it adds to you trying to achieve a certain goal.
Does it matter if you use Vim or VS Code? Or if you swear by old-school keybinds or split keyboards? Or if you’re cranking out code at 2 a.m. after an all-night grind versus methodically using Pomodoro timers?
No — it doesn’t.
What matters is the outcome: reaching the destination and producing the result that meets the bar.
Initial Idea
AI is a new tool — how you get there doesn’t matter, as long as the result does.
But does it make you 'more productive'?
AI code generation outpaces any wpm coder, no questions asked. But how much does the back & forth, debugging, etc. really cost you in the end?
The good old:
“In that time, I could've done it myself.”
or even
"Why spent 5 minutes doing something, when you could spent 5 hours trying to automate it?"
This is an argument even personally respected developer Internet of Bugs showcased through his AI comparison video.
The idea is to give the AI a task and judge how far it gets on it's own. How much do I need to intervene?
This approach tries to offload 80-100% (depending on the prompt) of work upfront to the AI, while then requiring higher mental engagement when having to fix someone else's code, when it eventually fails.
This might become a valid strategy once we have agentic systems with enough self correction loops in the future. But for now it will admitly, most likely, not produce the bar-meeting results.
So it's bad, right?
Friction reducing tools
A while ago, I got my hands on the Ultimate Hacking Keyboard (UHK) — my first fully customizable split keyboard that stuck with me. I’ve tried others, like the Kinesis and Moonlander, but the UHK clicked (no pun intended). I’ve customized the absolute hell out of it—super-specific keybinds for window management, application switching, formatting code, refactoring—you name it.
The goal?
To get what’s in my head onto the computer faster and with less friction.
This is the kind of tool that saves time and improves output. It’s like upgrading to a better saw if you cut trees for a living. You work faster, more efficiently. And yeah, that’s often how people measure the value of AI coding tools too:
- How much faster does it make me?
- How much time does it save?
But, productivity isn’t just about speed.
Friction reducing tools
One type of good tools: reduces friction between your thoughts and the computer.
Exploration tools
Is productivity even about being right?
Probably every developer has had the experience of working on a feature, only to find out this way of implementing it has serious flaws.
I even had the experience of looking at a feature I've built myself, thinking "Why did I do it that way? There's such a better way.", just to spent 3 hours refactoring and then arriving at the shattering "Huh, THATS why I did it that way."
And I think also every developer would confirm, that we're usually more criticle about someone else's code than our own.
In the spirit of creating choices, making choices being able to quickly spin up even the wrong solutions with often just a single prompt & then discarding them with a single button once you found a flaw in it, allows for a much quicker way of exploring the solution space.
Are there more types of tools?
What else makes a tool valuable for me as a developer?
If you really break it down, what’s the core thing developers bring to the table? It’s not typing speed. It’s what’s happening in their brains.
Developers solve problems in their heads. That’s the hard part. Typing it out? That’s just the output. Sure, there’s this mixed state where typing is part of the thinking process, like thinking as you speak. But when you’re burned out, it’s not your fingers that give up—it’s your ability to come up with solutions.
Active Exploratie Coding
I acknowledge there's a style of coding, where you're more so writing the code as you think; scrap parts again, etc. to help you explore the problem or solution space.
Ultimately, this is often just using the ability of our brain to self observe other parts of it's own output through different senses.
The effect is similar if you active-explore code, or if you talk your plan through (with the AI). With the benefit of a shared knowledge base after.
That's why rubber ducking is a thing.
This is where AI shines. But not always necessarily in coming up with the solutions.
It is not only capable of being a tool that makes you faster — it can also be a tool to reduce your mental strain. Because your brain, like any muscle, gets tired. At some point, you’re done. You need to recharge. But if a tool can offload even 20–30% of that cognitive load, suddenly you can work longer and stay sharper.
Producing 100% of the code manually does also cost you 100% of it as mental strain.
Getting more code out before you run out of steam is one way of increasing your productivity, often at fatal costs, showing in tech burnout rates.
Reducing the mental strain of producing your code, is another way of increasing your productivity, without offloading the entire thing at once & then start praying.
Embrace the bionic arm
It seems like most people look at AI coding more as a co-worker, that just doesn't complain – indipendant from you; rather than a bionic arm – a technological enhancement of your own capabilities, fused with your actions.
That sounds crazy, but what does that actually mean?
The obvious first:
There's plenty of tasks in a developers day that are very much fine with "good enough" code.
For a real life practical example, see How I use AI: WP Permalink Changes. I could've written the code for that script myself – 100%. I could've also located the correct table in the database, and janked up some SQL for it.
But both would've required a lot of mental engagement, especially in a different domain than I was currently operating.
Not having to switch thinking modes & spending 5min writing that script, took of a hard to define, but very real, amount of mental strain.
The "suboptimal" solution of per-page-javascript-to-console in this scenario, even came with the added benefit of being able to quickly validate the changes, before actually applying them, reducing additional mental strain in the lack of severity of potential errors.
What you do with that saved mental energy is up to you.
Invest it in longer sessions, producing more code.
Use it to not feel completely drained after a day of work and therefore keeping a healthy work-life balance, producing more and better code.
But this still falls into the co-worker category.
Let's look at the bionic arm.
Emergent behaviors in AI workflows
We’re starting to see emergent behaviors in how AI tools are being used and produce their output. Cursor is the first tool I’ve seen that really gets this. It’s not just “Here’s a chat window—copy-paste some code.” It’s building real workflows that feel seamless and integrated. And honestly? I don’t know why it’s taken this long for someone to get this right.
Earlier I've mentioned the greater mental strain of working on someone else's code. Using the bionic arm, means the AI working on your code.
When Cursor's predictive multi-line tab-completion allows me to add the newly added private scrollController property to the constructor, as well as the copyWith, toJson and fromJson methods, in a single keystroke, then I don't need to verify the code.
- The change is small enough for the AI to correctly get it, 100% of the time
- You can verify the code at a glance
It took off a hard to define, but very real, amount of mental strain.
Start using Cursor extensively and you'll find small shave-offs like this all over the day. In Germany we like to say: "Kleinvieh macht auch Mist", and I think that's beautiful.
When I use Cursor's inline-generate feature to quickly generate a date format function:
const formatDate = (date: Date): string => {
return new Date(date).toISOString().split('T')[0];
};Because typing "formateDate fnc YYYY-MM-DD" + Enter is faster than the best macro you've got.
It took off a hard to define, but very real, amount of mental strain.
I think you're starting to see where I'm going with this. You're still the one coding, but with each workflow & tool that can be incorporated reducing friction or strain, without re-introducing it (by usually keeping the scope small), you're increasing your ability to more quickly or easily bring the ideas in your mind to the computer.
Tools like this are starting to unlock the kind of collaboration that goes beyond just speeding up the work. They’re enabling new ways of thinking and working, and that’s where things get interesting.
Emerging Patterns
Tools like Cursor and GPT-4 are finally moving beyond “assistants” into integrated partners in development workflows. Enabling new ways of thinking and interacting with code.
Wrapping It Up
The conversation about AI and coding needs a reset. For now it’s about how we can use these tools to make our jobs easier, reduce friction, and conserve mental energy, while still delivering bar meeting results.
This does not require the AI to be a one-shot replacement.
For me, the most exciting part is discovering these emergent behaviors and rethinking what coding looks like when AI becomes a symbiotic partner in the process, especially once we're starting to talk about ermegence in the underlying LLM-behaviors (but that's for a nother time)..
Depending on when you read this, there is or is not more about my experiences with these behaviors and how I’m evolving my workflows.