I wrote an article about AI replacing devs a year ago...

...and a lot changed since then. Some of it I saw coming. Some of it I really didn't.

In June 2025 I published Will AI really replace devs?. The short version back then: no, AI is a tool that makes good devs better, fundamentals matter, and most of the news is exaggerated because it needs to sell.

TL;DR today: still no. But coding as we knew it is probably never coming back. Knowing what you need to do now matters way more than knowing how to do it.

Where I was a year ago

Funny thing about that article: it barely said how I actually used AI. I only admitted it in the comments. Back then, I mostly used it for basic inline autocompletes, quick syntax lookups, and debugging cryptic stack traces. I rarely touched agent modes. I had tried leaning on it harder for a while, but it quickly felt like a crutch—I felt like I wasn't learning anything, losing touch with my own codebases, so I backed off.

Today I hit my 7-day Claude limit almost every week. So yeah, things escalated.

How my usage changed

It wasn't one big moment or a sudden revelation. It was the sheer pressure of day-to-day delivery.

• End of 2025: I shifted from autocomplete to delegation. I stopped asking for "how to write this function" and started asking "go execute this task."
• 2026: My company started paying for a Claude subscription for everyone. Dropping my personal setup and adapting to enterprise-grade workflows forced me to rethink my entire process.
• Today: I don't just "use Claude" in a chat box. I maintain a personal development framework, structured and version-controlled like any production repository.

That setup lives in a private repo that acts as my personal engineering operating system:

• Rules: Clear, non-negotiable boundaries regarding code quality, data integrity, test coverage evidence, and git safety. It enforces principles like "never swallow errors silently" or "always verify log outputs before marking a task complete."
• Personas: A structured multi-agent workflow consisting of a dedicated review team, an executor, a task-slicer that breaks complex specs into isolated PRs, and a mentor.
• Skills: Deterministic routines for PR creation, commit formatting, automated self-reviews, and dynamic review team sizing based on the blast radius of the change.
• Mods: Custom tweaks and extensions built directly on top of Claude Code.
• A personal docs vault: A living knowledge base containing system context, architecture decision records (ADRs), backlog items, known pitfalls, and context packs. Agents are required to read from it before spawning a session and update it after finishing a task.
• A migration guide: When I set up a new machine, I clone the repo and tell Claude "read this and run it." It boots the environment, configures tools, and instantly adopts my exact working methodology.

Moving from isolated prompts to orchestration—agents, subagents, review personas, and deterministic rules—is what bridges the gap between generating a cool demo and engineering a production-ready application.

What I got wrong

Looking back at my original predictions, I had some strong opinions. I was wrong on several levels.

"Vibe coding is a dead end"

I used to think vibe coding was just a fad for non-developers. I was wrong. Vibe coding works, and it is here to stay. But there is a catch: it only works if you use it correctly. Vibe coding isn't about blindly accepting generated code; it's about acting like an architect who guides the AI with quick feedback loops. Without a clear plan, you get lost fast, but with good guardrails, it is a very fast way to build.

The S-curve

I argued that AI progress follows a classic tech S-curve and that we were past the peak of hype. Honestly, if AI is on an S-curve, I don't know where the flat part is anymore. I was way too skeptical about how fast these models would improve. The new jumps in capability keep surprising me.

"Sophisticated autocomplete"

I called LLMs "fundamentally sophisticated pattern-matching and auto-completion systems." That description is way too simple now. A year ago, you needed a specialized AI model for each different task. Today, the latest models handle complex reasoning, planning, and tool usage with high precision. They don't just complete patterns; they carry out real intent.

What I got right

I could have led with this section because, conceptually, the core thesis held up—even if the scale of execution surpassed my imagination.

• Prompt engineering is fading: I called it a temporary gap, and it proved true. You don't need magic words anymore. Models understand domain context naturally, assist in refining their own instructions, and orchestrate subagents independently. You don't craft prompts; you define intent and review execution.
• The typing part got commoditized: Completely. The act of manually translating logic into syntax is no longer the bottleneck in software creation.
• Devs move up the stack: My day-to-day shifted from writing code to intent specification, architectural direction, system steering, and code verification.
• Fundamentals still matter: More than ever. When code is generated in seconds, your ability to spot subtle architectural flaws, memory leaks, and concurrency bugs is the only barrier against system collapse.
• The panic was overblown: Technology shifts have always disrupted software engineering. AI is simply compressing the timeline.

The speed nobody prepared me for

At my last job, I was assigned a project with a standard 2-year delivery timeline. Leveraging an agentic workflow, I delivered it in 6 months. More importantly, it wasn't a fragile prototype—it was secure, performant, resilient, and currently runs at national scale.

That level of leverage was mathematically impossible a few years ago.

At my current job, my biggest operational struggle is estimation. I constantly miscalculate timelines because my brain is still calibrated to manual coding speeds. Estimating used to be "how long will it take me to write this implementation?" Now it's "how long will it take to validate the approach, and how often will a human need to step in when edge cases collapse?"

Where it still burns me

Despite the leap in capabilities, the current paradigm has distinct failure modes:

• Rule degradation: In long context windows, agents still suffer from instruction drift and forget explicit constraints.
• Silent architectural errors: It can produce clean, syntactically perfect code that makes fundamentally flawed system design assumptions.
• Contextual laziness: If bad patterns or legacy technical debt exist in your codebase, the agent will treat them as canonical examples and extrapolate those anti-patterns across new features.

It’s getting easier to trigger an agent, go to sleep, and wake up to working code. But that remaining 5% gap—where subtle edge cases, race conditions, and security flaws hide—is precisely where strict rules and multi-layered review personas earn their keep.

The learning trap got worse

A year ago, I worried that over-relying on AI would erode my technical growth. That worry didn't disappear; it evolved into a major industry trap.

When an agent can solve a complex bug in seconds, the temptation to accept the diff and move on is immense. But if you don't actively audit how the problem was solved, you gradually degrade from a software engineer into a glorified prompt operator.

To counter this, I intentionally engineered learning back into my environment:

• Mandatory explanation rules: My core instructions require agents to explain the architectural tradeoffs behind their implementation decisions, explicitly highlighting non-obvious code paths.
• Friction injection: The setup flags moments where I should implement a logic path manually to maintain muscle memory, rather than delegating it blindly.
• Plan-first execution: No code is written until the agent presents a high-level architectural plan for explicit approval.
• The Mentor Persona: After a feature is merged, a dedicated persona breaks down the core concepts used, explains alternative patterns that were rejected, and logs key lessons to my personal vault.
• System tracing skills: When exploring unfamiliar codebases, I use a custom routine that traces end-to-end event flows and generates targeted comprehension exercises for me to solve.

If the tool is going to take over the typing, it must be configured to accelerate your comprehension. Otherwise, you are quietly handing over your expertise.

So, what's the future?

My answer is the same as last year, just with much higher stakes.

Understanding underlying systems, domain modeling, system architecture, security, performance, and long-term maintainability still matters deeply. The cost of generating code has dropped to near zero, which means the value has shifted entirely to discernment, system integration, and domain expertise.

AI can write the code and build the platforms. But it won't understand your business domain, it won't negotiate requirements with stakeholders, and it certainly won't build the customer relationships that make the software valuable in the first place.

The how is getting cheaper every single month. The what and the why are your actual job now.