Skip to content

AI Doesn't Remove Work: It Moves It Upstream

"I have no special talent. I am only passionately curious." — Albert Einstein

This quote from one of the greatest minds of all time was obviously a show of humbleness on his part. On my part, on the contrary, it is a statement of facts, and that's why I'm glad AI has come to raise the bar for people like me.

But let's be honest: we have all heard that "AI is going to make developers obsolete". And that's partly true, but it's also an opportunity. I am not a developer. I have worked for more than 20 years in the oil and gas industry, but I have always loved computers, programming, hacking... and have always been an early adopter of new technologies: blockchain, AI, you name it. But by no means am I trying to lecture seasoned developers or people with CS degrees here.

I am trying to tell you what happened to me, and why I think it matters to you too.

Before AI: When Code Was the Bottleneck

I remember the old days when you had nothing but books and maybe some fancy computer magazines. It was just you and the terminal. I always wanted my code to be readable and maintainable, which really means one thing: "I will not curse myself 6 months from now when I come back to this same snippet." I guess you get the point.

That was the intention. Reality was more stubborn. You left behind a lot of "code corpses": casualties of the two constraints that never go away, time and resources. I tried hard to mimic the professionals:

  • read other developers' code obsessively,
  • took course after course,
  • got certified as a Python Developer with PyBites,
  • wrote tons of code...

The evolution was real, but slow. Results were not always where I wanted them to be.

Here's what I didn't realize back then: the bottleneck was never my motivation. It was the sheer mechanical cost of turning ideas into working code.

The Shift: Implementation Becomes Cheap

Fast forward to today. We now have great, cheap, tireless developers: LLMs. They write good code and they write it fast, which means keystrokes are no longer the scarce resource. Clarity of intent is.

Think about what happened when engineering moved from hand-drafting blueprints to CAD. The tool changed radically. Did the architect's role shrink? No. It grew. The bar for what you could design, and were expected to design, went up.

We are living through exactly that moment in software. And if you are not a traditional developer, like me, this is where it gets interesting.

Architecture as the New Leverage Point

Here is the uncomfortable truth I had to learn the hard way: AI amplifies your decisions, not just your output. Good decisions scale fast. Bad ones scale faster.

With a weak architectural mindset, AI will happily generate coherent-looking, deeply broken code. It won't argue with you. It won't warn you. It will just build exactly what you described, even if what you described was a mess. In my case, this meant I could create problems 10x faster than before. Same curiosity, same energy, but now with a power tool I didn't fully know how to handle. That was the turning point.

Thinking in Abstractions and Specifications

Once I accepted that architecture was the new bottleneck, I changed how I work. Before writing a single prompt, I now think through three things:

  • Communication: how do the different parts of the system talk to each other?
  • Organization: how are those parts structured internally?
  • Storage: what is the role of data, and how does it flow through the whole thing?

Once those three questions have clear answers, implementation becomes almost obvious, and the AI's output becomes genuinely useful. My role shifted from "person who writes code" to "system designer and requirement articulator."

If those three aspects sound familiar, you might know them as the COSI framework, which Arjan Codes teaches in his courses (Code, Objects, Storage, Interactions). I can't recommend it enough.

Evidence from the Field: Two Projects, One Lesson

Let me make this concrete with two projects I built around the same time, using the same AI tools.

The first was an early version of AIgency Forge, a multi-agent system where AI agents collaborate to build software. I was excited, moving fast, and skipping the design phase. Agents had overlapping responsibilities, no clear contracts between them, and storage was an afterthought. The AI generated plausible-looking code at every step. The system broke in spectacular, hard-to-debug ways. Every fix introduced two new problems. AI just helped me dig the hole faster.

The second was Pandora AI, a competitive intelligence platform. This time, before writing a single line of code or a single prompt, I wrote a full PRD and four RFCs covering:

  • the ranking engine,
  • the evaluation pipeline,
  • the peer comparison system,
  • and authentication.

Each component had a clear role, explicit interfaces, and defined boundaries. When I brought AI into the implementation, it stayed in its lane. Output composed cleanly. Velocity was real and sustainable.

Same tools. Same developer. Radically different outcomes. The only variable was the quality of the thinking that came before the code.

Conclusion: AI Raises the Bar

AI does not lower the bar for building good software. It raises it. It removes the excuse of "I didn't have time to design it properly" and replaces it with "you had no reason not to."

For people like me, who came to software from a different path, this is genuinely exciting. The leverage available to clear thinkers has never been higher, and the tools have never been more accessible.

If you want to thrive in this new reality, here is where to invest:

  1. Software architecture and design patterns — the fundamentals that AI cannot replace.
  2. Writing precise specifications before touching a prompt — PRDs, RFCs, interface contracts. Whatever forces you to think before you build.
  3. A structural mental model like COSI — anything that makes you answer "how does this fit together?" before "how do I implement this?"
  4. Build something real and let it break — there is no shortcut to the moment when your architecture fails and you understand exactly why.

The tools will keep getting better. The question is whether your thinking keeps up.

Where has AI exposed a gap in your own thinking? I write about AI engineering, software architecture, and the unconventional path from industry veteran to AI builder. If you found this useful, follow me here on LinkedIn and share it with someone who is navigating the same shift.

And if you want to learn how to build agentic systems hands-on, join the next cohort at pythonagenticai.com.