Juniors Vibing, Seniors Flowing.
The Agentic Coding Shift Is Real..
“This shift can feel like cheating and seems to devalue the skills and status we’ve worked hard to attain.”
I said that in a recent video on the AI developer transformation, and I stand by it. But there’s a more profound truth underneath: it only feels like cheating when the rules change faster than we’re emotionally ready for.
Act 1: Resistance – The Identity Crisis of a Developer
One moment hit me harder than I expected. I had been procrastinating on a legacy component for weeks. Then I asked Claude to help refactor it. It returned a suggestion in seconds—decent, not flawless, but a shockingly good first draft. I felt both awe and dread in equal measure.
Was this the beginning of my obsolescence?
I have developed software for decades. I’ve led teams, built startups, and trained and mentored dozens of developers. My identity has always been tied to mastery—the ability to fix what others couldn’t and to see through complexity. And suddenly, an AI could do in seconds what I had been avoiding for days?
That wasn’t just doubt speaking. That was Resistance. My pride. My identity. And it’s something many developers are now confronting.
8 Minutes of AI, 8 weeks of debugging.
AI generated gargabe code.
Our Clients need to describe what they want so that they are safe.
AI doesn’t understand the domain.
AI doesn’t write maintainable code.
I can write this faster myself.
All these and more are projections of us human developers to protect ourselves against change. That’s the mother of all fears and Resistance's finest. I will no longer fall for this case, and the following article will explain why these statements are based on fallacies and not facts.
Let’s get into it.
Act 2: Flowing, Not Fighting – The Human-AI Hybrid Workflow
AI didn’t replace my role. Instead, it eliminated friction.
I made a commitment to experiment. I began utilizing Claude Code in production—seriously and for now 3 weeks with a spend of a little more than $200, not as a novelty but as a functional tool.
I took notes. I remained transparent. I focused on where it excelled and where it faltered.
👉 I’m curious if AI can genuinely achieve what many people mock or dread.
I discovered that I shifted from "writing” code traditionally. I began to shape outcomes, direct intent, and orchestrate architecture. It feels less like inputting lines and more like conducting a system—fluid rather than confrontational.
Whenever the AI crunched on the output, I expected something wrong, broken, or wrongly understood.
What really happened with Claude Code …
Ultimately, it proved to be highly precise, recognizing details I overlooked, rectifying aspects I didn’t address, and revealing a crucial insight: I struggled to articulate my intentions clearly. This is a significant drawback for a developer, highlighting an area where I need to improve. More often than not, I was the problem, NOT Claude Code. 🍪
AI didn’t replace my role. Instead, it eliminated friction. Tasks like boilerplate, migrations, and writing code are handled more quickly and efficiently, allowing me to concentrate on architecture, edge cases, and business logic.
Old qualities are even more relevant with AI.
But here’s the key: it only functioned effectively when the codebase was clean. When proper documentation was available. When context was supplied. Disorganized, undocumented, and heavily intertwined legacy projects puzzled the AI just as they baffled humans.
That’s when I began to implement new strategies:
Accelerate compile/test cycles to optimize API time.
Include filenames and function names in prompts.
Regularly supply AI with .md docs—context fuels success- and let it update it after execution with relevant changes. This is cheaper than allowing the agent to find out anew every time.
Guide AI as if onboarding a junior developer.
Evaluate AI output the way you would from a new hire.
Claude Code thrives not in isolation but with structure, feedback, and guidance—a hybrid approach we refer to as Flow Coding.
Act 3: Redefinition – The Rise of the 10x Engineer (Again)
Then, I had a surprising realization: Juniors were having difficulties. They struggled to know what questions to ask and didn’t question the results they received. Some appeared to trust AI outputs without reservation, while others seemed paralyzed, unsure how to start or follow. In contrast, senior developers who could effectively frame problems and validate solutions were suddenly x-times more efficient.
Their speed wasn’t due to typing faster; it stemmed from their understanding of how things function. I realized the issue wasn’t a lack of talent but rather a difference in mindset. This insight has transformed my approach to team leadership:
Juniors must learn how to prompt rather than simply copy, which requires in-depth experience and, to some degree, mastery.
Seniors should articulate their thought processes in documents, specifications, and code comments.
Projects must be designed to be modular, testable, and compatible with AI from the outset.
We’re not losing job roles; we’re evolving them into new positions: architect, mentor, strategist. Developers aren’t disappearing; they’re being redefined. We will code less, and at some point, we won’t code anymore.
The Real Economics of AI vs. Juniors
Let me get brutally honest.
As a founding engineer and employer, I’ve hired developers across a range of mid-four-digit monthly salaries in Germany over the past 16 years. Some turned out to be exceptional, while others, despite their high compensation, performed more like functional apprentices. They required constant guidance, struggled with autonomy, and ultimately cost time and money.
For a long time, I thought this was the price to pay: establish a good working culture and aim to improve everyone so that we all could work together. I phrased that approach as “The Average Developer.”
Now, how will smaller and larger companies decide when it comes to budget decisions and thinking in economic constraints?
Using Claude Code at $200–$500 per month per Software Engineer yields greater value than collaborating with an inexperienced developer, primarily when operated by an experienced engineer. This is because prompting and reviewing in a flow with a machine that updates safely up to hundreds of files (in a migration) doesn’t cost the senior too much time since the bulk of the work is done by typing. A less experienced person would do the same with way more time needed and maybe an outcome below expectations. During Flow Coding, you will get this feedback in minutes, while with an inexperienced human, it will take days or sometimes weeks.
Smaller tasks often can be done by AI while a senior would finish something else, such as responding to a chat message or making coffee. These tasks were there for less experienced colleagues to learn; good opportunities.
How many companies will still be willing to keep these opportunities open when AI could do them?
👉 Of course, this is a short-term view that doesn’t really help with the company's long-term stability, culture, and growth. We need upcoming new developers or “fresh blood” to have a future as a company.
Yet, the economic pressure is often greater than employees understand.
That’s a harsh reality, and it feels terrible to say it out loud. 😞
It may seem unfeeling, but from a business perspective, it’s straightforward arithmetic. This situation raises a significant question:
The big JUNIOR question every developer should ask oneself:
How can anyone gain seniority today if AI handles most hands-on tasks and junior developers miss out on valuable challenges during their learning process?
This goes beyond a mere tool change; it represents a generational shift.
As a developer and entrepreneur, I can't overlook this issue. I observe how AI elevates seasoned developers, yet junior developers struggle to keep up with the ongoing demands of prompting and reviewing, all while trying to understand the overall plan and expected outcomes.
This inevitably leads to the idea of Vibe Coding and why it will become a reality within the next decade.
Younger developers won't wait until "traditional" companies and startups find the time to take care of them, while financial constraints become more and more complicated.
You need to learn the differences between the Hybrid-Approach of “flowing with AI” and "vibing with AI blackbox”. Let’s get into it.
Vibe Coding vs. Flow Coding – Two Modes of Working with AI
Through experience, two distinct AI coding patterns have emerged:
1. Flow Coding: In this method, you work alongside the AI in an ongoing cycle. You share insights, and it generates drafts. You evaluate; it refines. This approach is utilized in current systems or scenarios where subtlety matters. I have successfully applied this method, which allows me to concentrate on broader aspects and engineering factors rather than getting bogged down in code and thoroughly hunting for specific deterministic issues. The goal is to work on and enhance the human-readable codebase, but keep it human.
2. Vibe Coding – High-context autonomy. You give the AI clear docs, clear prompts, and a well-defined outcome. It flows. Think greenfield projects with upfront design. The problem here is currently the limitation of AI, token space, and capabilities. While flow coding is about the human, the vibing approach decouples the codebase in a way that it could even be written in lower level languages or, at some point in time, directly compiled to machine code. Humans are NOT intended to be part of the codebase in the long run.
Flow is a human-AI hybrid. Vibe is almost autonomous.
The mistake? Jumping from Flow to Vibe too early.
I firmly believe that Vibe Coding will be the solution for the senior/junior problem.
The industry is facing significant disruption and is likely to undergo fundamental changes within the next decade, possibly even sooner. I am skeptical that coding without AI will remain the standard, and I don't believe that flow coding is here to stay. Vibe Coding could prove more effective and efficient when more substantial AI capabilities become available, but fortunately, they are not today.
Why fortunately? My entrepreneur-heart is happy, but my programmer-heart bleeds. Starting with age 8 on C64 BASIC, programming was a fundamental part of my life, and a future where this becomes more of a hobby or nostalgic thing to know is not likable at all. And I know many of you devs reading my words will disagree. But what I saw first-hand during the last three weeks made me certain about the change.
Side Note: What Claude Code Needs to Work Well
The following is an excerpt of a more extensive post to come. It might help your journey.
✅ Short test runs, fast lints, snappy compiles.
✅ File- and function-level prompt scoping.
✅ Up-to-date .md documentation.
✅ Clear interfaces and types (TypeScript strict mode FTW).
✅ Comments! Yes—good comments help the AI understand why.
❌ Monolithic chaos.
❌ Outdated, undocumented logic.
❌ Human-centric mental shortcuts without context.
We forget that our brains are connection machines. We can hold chaos in our heads. Claude can’t. It needs structure. Predictability. Documentation.
AI Doesn’t Think Like Us—And That’s the Point
A human developer will hack around edge cases and half-documented legacy logic. AI? It doesn’t play that game. It thinks more holistically, looking for consistency and patterns. It stumbles in systems we’ve “learned to live with.”
And yet… it thrives in new ones.
Mentorship Must Evolve
The most significant risk isn’t that AI will replace us.
It’s that we stop growing developers.
Right now, mentorship is broken:
Juniors can’t learn if the AI is doing all the thinking.
Seniors don’t have time to explain everything.
Teams are rushing to ship, not teach.
But we're building a brittle future if we don’t fix this.
The new model of mentorship must teach:
How to frame good prompts
How to evaluate AI suggestions
How to correct errors and validate intent
In other words, it is about thinking like a senior, not mimicking one.
In short: Let’s move away from the idea of the programmer or coder and move finally to Software Engineer; this is what we all will be in some years.
Changing the Way We Spec and Ship
This transformation goes beyond development—it’s changing planning too.
We will soon define features based on value instead of time or sprints. This is because the pace of work can vary with AI. For instance, a senior developer utilizing Claude Code might complete tasks in hours that previously required a team several days to complete.
Anticipate these outcomes:
Quicker iteration cycles
Features defined by ROI rather than time
Refactorings that would have been delayed for months are now completed instantly
Reduced burnout, increased flow
Final Thoughts: The Discomfort Is the Signal
Resistance arises when we recognize that significant changes are taking place. We have associated our identity with being problem-solvers, yet machines are also stepping in to address these issues.
However, they don’t replace us; they redefine the nature of the challenges we tackle. Instead of clinging to control, I chose to release it. In doing so, I found I gained even greater power. I gained more leverage, enhanced clarity, and the ability to concentrate on the broader perspective. This transition does not diminish our value; it invites us to evolve and discover new forms of worth.
TL;DR: How to Stay Ahead in the Agentic Era
Treat AI like a junior dev: guide, review, contextualize
Structure code for clarity: docs, types, patterns
Speed up compile/lint/test loops to reduce AI friction
Comment your code—for AI and your future self
Use AI for momentum, not mindless completion
Train juniors in thinking, not just syntax
Trust the AI, but verify its logic
Don’t commit AI changes blindly—review them yourself
Spec outcomes, not just output
So—Where Are You in the Shift?
Do you feel more empowered or displaced?
Are you resisting the flow or learning to ride it?
If you’re experimenting, struggling, or succeeding with agentic coders like Claude, I’d love to hear from you. This transformation is too significant to navigate alone.
Let’s figure it out together.
Adrian
By the way, you aren’t alone, believe me. I have trained many apprentices, guided a lot of devs and helped seniors to become cornerstones. Get a free introduction call to find out if you should have a mentor or not. You can find me on MentorCruise.com
Hopefully at last we get "Features defined by ROI rather than time"