From programming to directing: how AI completely changed my work
Until a few years ago, my workday looked classic. Reading lots of documentation, dissecting new techniques, sifting through old code, testing, fixing, and trying again. At the end of the day I'd close dozens of StackOverflow tabs. Hours in a code tunnel, fully focused on one problem at a time.
Building features easily took days. Sometimes longer. Not because the concept was complicated, but because everything was manual: searching, copying, adapting, and debugging.
AI existed, but barely played a serious role.
That has completely flipped in two years.
The first phase: AI as a StackOverflow replacement
About two years ago I started using AI seriously. Initially mainly as a replacement for StackOverflow and Google. Asking questions, having snippets generated, and getting explanations about libraries or error messages.
It worked reasonably well, but rarely right the first time. Just like with StackOverflow, I usually still had to adjust the code, fix things, and understand what went wrong. The gain was limited: roughly an hour per workday.
Useful, but not a real gamechanger yet.
Now: planning, steering, executing
Today my workday looks completely different.
My stack includes:
- Claude Code with extensive custom markdown skills
- ChatGPT Codex for checks and second opinions
- Cron jobs that monitor commits
- Opus 4.6
- Sometimes agent teams
My workflow is usually:
- Have AI create a plan for a feature
- Read and assess that plan
- Steer and sharpen
- Spar about alternatives
- Finalize the plan
- "Go"
With a good plan, it's often one-shot these days. Where last year I still had to intervene regularly, AI now builds complete features independently with a solid plan.
My role mainly consists of reviewing, steering, guarding architecture, maintaining context, and enforcing quality. Meanwhile the build keeps running and I can literally grab a coffee while the code is being written.
I often work on three projects simultaneously, alongside a few hobby projects. That was unthinkable before.
Agent teams: from tool to team
For about a year now I've been using agents seriously. Additionally, I have my own OpenClaw agent: a personal assistant ("Jennifer").
She keeps track of my calendar, calculates travel time, warns me when I need to leave, and books invoices. As a solo developer, I now functionally have a complete team around me.
Not figuratively, but practically.
Rapid prototyping has completely changed
A prototype used to mean a few days of work. Now it's often a few hours.
In an evening I build complete CRMs with Kanban boards, dashboards with animations, and interactive demos. For example, a sales dashboard with a Formula 1 car driving around a circuit, where each lap represents hitting a target.
I didn't used to do that, simply because it cost too much time. Now I first build a prototype, show it to the client, get feedback, and often hear: "Nice, go build it." Then I throw the prototype away and rebuild the system, structured and maintainable.
Prototyping is now mainly "vibe coding": experimenting, generating ideas, and quickly getting something working. Only then does the real engineering work begin. AI doesn't replace structure.
From programmer to software engineer
I no longer see myself as a programmer. More as a software engineer, architect, and director.
My most important skill is no longer syntax knowledge, but maintaining overview, recognizing patterns, designing structure, guarding boundaries, and enforcing quality.
Additionally, keeping up is crucial. I read Reddit, test new tools, and experiment in the evenings. Not to be the best at everything, but to know what's possible and where the limits are.
Quality: better, but not automatically
The quality of AI code keeps improving. I need to babysit less and less. At the same time, context remains a bottleneck: AI still doesn't see the entire system.
That's why a few things remain essential:
- Good skills and context files
- Extensive unit tests
- Actively watching along
- Reading the "thinking mode"; often more useful than the reply itself
- Not merging blindly
- Keeping DRY enforced
AI writes code fast, but not good software. That difference remains important.
Impact on business
Lead times have become drastically shorter. Not because there's less work, but because much more work gets done in the same time. Backlogs disappear and side apps pop up everywhere.
At the same time, new work emerges: cleaning up AI slop, restoring structure, and normalizing architecture. That's already becoming a separate specialty.
Having AI build large systems completely unsupervised — I don't do that yet. Maybe in two years, but not for now.
Mental impact
Work has become more fun, but also more intense. Because AI builds in parallel, you automatically start opening other projects, answering emails, and adjusting other parts of systems.
With multiple projects simultaneously, you're constantly switching between contexts. That's mentally exhausting.
You also become dependent quickly. When AI goes down, a large part of my productivity stalls. But I don't want to go back. Debugging is fun when you solve it, but the hours before that remain frustrating.
Accelerated learning
A major advantage is that learning has become extremely fast. New frameworks, platforms, or languages are no longer a months-long project.
With a good prompt where I explicitly ask for explanation and reasoning, I can master something in weeks that used to take months. Not because AI does it for me, but because it guides me while building.
Looking ahead
Where we'll be in two years, nobody knows. What I do see is that juniors will struggle first, then mid-levels, and eventually seniors.
Non-technical people will soon build their own software. Toward the end of 2026, complete non-techies will be able to create functional applications.
Whether this generation of AI will ever build systems that last fifteen years, handle hundreds of thousands of requests per second, and remain perfectly maintainable — that remains to be seen. That still needs to be proven.
Conclusion
My work has shifted from writing code to directing systems. I guide, steer, guard quality, and correct where needed. AI builds.
I can no longer work without AI, and honestly, I don't want to anymore. As a solo developer, I now functionally have a complete team at my disposal.
And that changes everything.
Deep dive: what /insights reveals about my Claude Code usage
Claude Code recently got a new command: /insights. It analyzes your complete usage history and shows how you actually work with AI. When I ran this for the first time, I got a rather confronting yet educational picture of my own workflow, based on my Claude Code data.
In just over a month, it revealed among other things:
- Hundreds of sessions spread across multiple projects
- Thousands of interactions with Claude
- More than a hundred thousand lines of code added
- More than a thousand files touched
- Regularly multiple sessions active simultaneously
This made clear that AI is no longer a tool at the edge of my work, but a structural part of my development process.
Not as autocomplete, but as a colleague
The analysis shows I don't use Claude as a smart autocomplete, but as a colleague. I describe problems in plain Dutch, often the way I would with a human colleague. Claude then searches the codebase, reads relevant files, and comes back with an analysis or proposal.
The focus is strikingly often on reading and understanding. The majority of actions consist of opening files, searching through them, and building context, before any code is modified.
Parallel work: multiple sessions at once
A large part of my work happens with multiple Claude sessions side by side. While one session performs a refactoring, another runs a bugfix or analysis. In practice, it works as if you have multiple colleagues working simultaneously, each with their own focus.
Where Claude delivers the most value
From the data and practice, a few strong points emerge:
- Cross-stack debugging: from frontend to database in one session
- Large-scale refactors across many files simultaneously
- Time-intensive, boring work like translations, inventories, and migrations
- Structural tasks that are error-prone for humans
Especially being able to trace a bug through multiple layers is something that used to cost a lot of manual work and is now largely automated.
Meta-engineering: learning to collaborate better with AI
A significant part of my time now goes into improving how Claude works for me. I do this with:
- An extensive CLAUDE.md file with standards
- Custom skills for recurring tasks
- Session reflection
- Automatic checks via hooks
Every investment in better instructions pays off later in fewer correction rounds and less noise.
Where it goes wrong
The /insights data also clearly shows where things sometimes go wrong:
- Scope creep: a simple bugfix grows into a half refactor
- Over-analysis without implementation
- Errors in naming and conventions
This forces more explicit direction and boundaries. Without clear guardrails, AI goes too broad too fast.
From cognitive load to orchestration
The biggest gain isn't just in speed, but in mental load. Where I used to have to hold all context myself, I can now delegate tasks to Claude and steer at a high level.
The difficulty has shifted from execution to orchestration: steering processes, guarding scope, and managing quality.
AI as an extremely fast junior
The best metaphor remains: Claude is an extremely fast, broad junior developer. It can look up everything, read everything, and type everything, but needs guidance. Just like with a real junior, the power isn't in the tool, but in how you collaborate with it.
From tool to team member
The development is clear: from AI as a tool to AI as a managed team member. With agent teams, skills, hooks, and headless workflows, it increasingly resembles a virtual development team that's continuously available and grows with my way of working.
This deep dive confirms what I already noticed in practice: my productivity doesn't come from AI programming for me, but from it taking over the searching, reading, and execution work, allowing me to focus on design, decisions, and quality assurance.