I Have Decided I Don't Like Agentic Workflows

I Have Decided I Don't Like Agentic Workflows
A developer watches as ethereal AI agents write code on floating screens – the new reality of software engineering where we supervise rather than build

The TL;DR: Agentic workflows are incredible. They are productive. They are probably inevitable. They also quietly replaced one of the most enjoyable parts of software engineering: writing code. Somewhere between GitHub Copilot launching in 2021 and now, developers stopped being builders and started becoming supervisors. I’m not convinced that trade-off makes the job better — even if it makes it faster.

Tyrion Lannister - I don't like riddles

The 4.5-Year Identity Shift Nobody Processed

GitHub Copilot publicly launched in June 2021. That means we’ve had roughly 4.5 years of AI-assisted coding evolution. But the shift didn’t feel like disruption. It felt like convenience layered slowly enough that most of us didn’t notice the job description changing underneath us.

If you zoom out, software engineering went through three distinct AI phases — and the third one is where things quietly broke.

Phase 1: Autocomplete on Steroids (2021–2023)

Early Copilot felt like magic.

“Wow… it finished my function.”

You still designed the architecture, wrote most of the logic, debugged everything manually, and understood every line. AI felt like a pair programmer who never got tired and occasionally hallucinated nonsense.

The hallucinations were annoying, but they forced you to stay engaged. You still owned the craft. This phase made developers faster. It didn’t change who developers were.

Phase 2: Prompt → Function (2023–2024)

Then models got better at context, memory, and multi-step reasoning. You could now say:

“Write an authentication system with JWT rotation, role permissions, and refresh token storage.”

And it would generate something dangerously close to production-ready. Developers started writing less code and more prompts.

But we still rewrote parts manually, debugged actively, and treated AI output as a draft. AI felt like a junior developer. Still enjoyable. Still collaborative. Still human-led.

Phase 3: Agentic Workflows (2024–Now)

This is where the role fundamentally changed. The workflow now looks like:

  1. “Implement authentication.”
  2. “Integrate with database.”
  3. “Add tests.”
  4. “Update documentation.”
  5. “Open PR.”

And an agent does it. Then another AI reviews the PR. Then you feed the review comments back into the first AI. Then it fixes itself. Then you merge.

At some point you realize: you didn’t write code. You approved it.

AI became the developer, the reviewer, the documentation writer, the QA assistant, and occasionally your rubber duck. And you became… a workflow orchestrator.

The Role Reversal Nobody Prepared Us For

Developers used to hate writing documentation. Now documentation is the most important skill in modern engineering. But not user documentation. Not API documentation. Documentation for machines.

We now spend significant time writing:

  • Agent instruction files that define behavior boundaries
  • Context summaries that help models understand project state
  • Architecture explanations that guide decision-making
  • Prompt engineering guides that standardize team interactions
  • Task decomposition documents that break work into agent-sized chunks

Because if instructions are unclear, the agent produces garbage faster than any junior developer ever could.

We accidentally turned into technical writers for robots. This is not satire. This is daily workflow reality. We used to implement ideas directly. Now we describe ideas so something else implements them.

Wall-E humans on floating chairs

Remember Wall-E? The humans who floated around on chairs while robots handled everything? We laughed at that satisfying dystopia in 2008. Now we’re writing instruction manuals for our robot colleagues and calling it “prompt engineering.”

The Joy of Writing Code Was Never About Productivity

Here’s the uncomfortable truth most developers won’t admit publicly. We didn’t fall in love with coding because it was efficient.

We loved it because it was iterative, creative, personal, and full of tiny dopamine rewards. The loop was simple: You write something. It fails. You debug. You discover something subtle. You fix it. You feel brilliant for six seconds. Repeat 400 times. That loop is psychologically addictive.

Agentic workflows break that loop. Now the cycle looks like: describe the problem, wait, review output, request revisions, merge. It’s objectively more efficient. It is also emotionally flatter.

It feels like watching someone else speedrun a game you used to love playing yourself.

Old man yells at cloud

Yes, I’m aware I sound like Grandpa Simpson yelling at a cloud. But hear me out.

Even Code Review Is Quietly Disappearing

Code review used to be the second most intellectually satisfying part of engineering. It was where experience showed up. Where intuition caught edge cases, architecture smells, and performance disasters waiting to happen.

Today the pattern looks different:

  • AI reviews the PR and generates initial feedback
  • AI flags issues based on patterns and conventions
  • AI suggests solutions with code snippets attached
  • Developers forward feedback back to the original AI
  • AI fixes itself and updates the PR

We are increasingly reviewing the reviews of code we didn’t write. If that sounds dystopian, it’s only because you said it out loud.

Industry Data Already Shows the Shift

Multiple studies already hint at this transformation:

  • GitHub reports AI-assisted coding increases developer productivity but significantly changes how developers allocate time — with more time spent validating outputs rather than producing them.
  • Stack Overflow’s 2024 developer survey showed increased reliance on AI tools but also rising concerns about over-trust and skill erosion.
  • Research from Microsoft and MIT has shown that AI-assisted development increases speed but can reduce deep system comprehension if developers over-rely on generated solutions.

None of this suggests AI is harmful. It suggests AI changes how expertise forms. And that matters more long-term than productivity graphs.

The Skill Shift Is Massive

The skills that made you valuable five years ago are not the same skills that make you valuable today.

Traditional developer strengths:

  • Syntax mastery and language fluency
  • Debugging intuition built through pain
  • Framework memory and API knowledge
  • Runtime mental modeling
  • Low-level problem solving

Agentic developer strengths:

  • Task decomposition and scoping
  • Instruction clarity and prompt engineering
  • Context engineering and information architecture
  • Risk evaluation and edge case anticipation
  • Validation strategy design
  • System-level reasoning

This is less programming and more architecture + technical leadership + product thinking. That may be progress. But it is absolutely a different profession.

The Quiet Risk: Losing Craft

Writing code is similar to woodworking. Yes, CNC machines can produce furniture faster and more precisely. But craftsmanship isn’t just about output. It’s about the relationship with the material.

Developers historically had a relationship with code. You felt where systems were fragile because you built them. Agentic workflows insert a translation layer between you and the raw material. That layer is brilliant. It is also a buffer.

The Bigger Risk: Losing Intuition

Intuition forms through pain. Through writing bad code. Through debugging production failures at 2 AM. Through misunderstanding systems and suffering the consequences. Through fixing your own mistakes and remembering the lesson.

If agents write most code, junior developers may skip the painful phase where intuition forms. We may create engineers who can design beautiful architectures but panic when something behaves unpredictably at runtime. Because they never wrestled with the system personally.

This Is Not About Job Loss

I don’t think developers disappear. I think something more subtle happens. We evolve from builders into orchestrators.

Old developer pride: “I built this.”

New developer pride: “I orchestrated this.”

Both are valid. Only one is why many of us chose this career.

Let’s Be Honest — Agentic Workflows Are Insane (In a Good Way)

They remove boilerplate almost entirely. They improve test coverage dramatically. They enable solo developers to ship systems that previously required teams. They lower entry barriers into engineering. They increase organizational velocity.

From a business standpoint, resisting agentic workflows is irrational. From a technical standpoint, they are revolutionary. From a human experience standpoint… they are complicated.

Maybe This Was Always Inevitable

Thanos - I am inevitable

Civil engineers don’t lay bricks anymore. Mechanical engineers don’t hand-machine every part. Electrical engineers don’t solder individual transistors. Maybe software engineering is simply reaching maturity. Maybe we were never meant to handcraft everything forever.

But software always felt uniquely personal. You could build entire digital worlds with nothing but a keyboard and stubbornness. Agentic workflows blur that intimacy.

My Personal Rule (That Nobody Asked For)

If I cannot implement something manually, I do not allow the agent to own it fully. Not for productivity reasons. For survival reasons.

I deliberately drop into “manual mode” sometimes. Not because it is faster. Because it keeps my instincts alive. Also because occasionally, writing code manually still feels like playing an instrument instead of conducting an orchestra of machines that occasionally improvise jazz when you asked for classical.

The Part That Actually Bothers Me

Agentic workflows didn’t just optimize engineering. They optimized the parts of engineering that were measurable: speed, coverage, throughput, output volume.

But software engineering was never purely measurable. There was always an artistic layer. The feeling of solving something the hard way. The satisfaction of debugging something nobody else understood. The pride of knowing exactly why your system worked.

That part doesn’t show up in performance dashboards. But it’s why many developers stayed in this field instead of moving to higher-paying management roles years ago.

The Future Probably Isn’t “Agents vs Humans”

The real future is probably developers who can switch between three modes: Builder, Architect, and Supervisor.

The most valuable engineers will not be the ones who write the most code. They will be the ones who know when to stop delegating and start building again. Not for speed. For understanding.

Final Thought

Agentic workflows didn’t remove developers. They quietly redefined them.

They made us more productive, more scalable, and more strategic. They also made us less hands-on and less immersed in the craft. And maybe this is what progress looks like. Every industry eventually moves from manual creation to orchestration. Maybe software engineering is simply joining the rest of engineering history.

But right now, somewhere between merging AI-generated pull requests and writing documentation for systems that can implement entire features without touching a keyboard… I realized something.

I don’t hate agentic workflows. I use them every day. I benefit from them constantly. I just miss writing code line by line.

References