Are Developers Still Relevant in the AI Era?

Yes. Developers are still relevant in the AI era. But the part of the job that made most of us feel like developers, typing code, is the part that’s shrinking fastest.

I’ve been building for the web for more than twelve years. My most recent project was my own site, rebuilt this September as a custom WordPress theme, with an AI coding agent in the terminal writing most of the code. I came out of it convinced the job is changing, not disappearing. It’s moving from producing code to owning outcomes: deciding what gets built, proving it works, and explaining it to the people it’s for.

Here’s the reasoning, and what I’d do about it.

What AI replaces

It’s worth being honest about this part. AI coding tools are good at:

• Boilerplate. Registering post types, enqueueing assets, defining REST routes: well-documented code that looks much the same on every project.
• First drafts. A template from a design, a script from a description, a refactor from a pattern.
• Lookups. The hook name, the argument order, the function you half remember. The things we used to search for.

Even here, “replaces” means the typing, not the responsibility. Boilerplate from an agent still has to be the right boilerplate: output escaped, the capability check present, the hook that fires at the right moment. Someone has to know what right looks like.

If most of your value sat in those three, I’d expect it to shrink. I don’t think that’s a tragedy. Few people got into this work to register their fifteenth custom post type.

What AI amplifies

The same tools make some developers far more effective. As far as I can tell, it comes down to two abilities: saying precisely what you want, and checking whether you got it. I’ve argued that in AI coding is about thinking differently; the short version is that a clear brief and a good check are worth more than fast hands.

An agent multiplies what you bring to it. Bring a vague idea and you get a lot of confident, vague code. Bring a content model, constraints and a list of checks, and you get work you can ship.

The other thing it amplifies is systems thinking. A WordPress site isn’t a folder of files. It’s a theme, a database, a stack of plugins, a cache, a host and the people who edit it. An agent sees the files you point it at. Someone has to hold the whole system in mind and know where a change will ripple.

The agent wrote the code; the judgment was still human

On my rebuild the agent wrote most of the theme’s code. It also wrote bugs that only make sense once you know WordPress’s quirks.

Template variables named $more and $id caused a fatal error on single posts. Template files run in global scope, and both names are WordPress globals, so they collided. A REST route passed sanitize_title straight in as its sanitize callback. WordPress calls that callback with extra arguments, so an empty value made sanitize_title() fall back to the request object as its title, and the endpoint returned a 500. The fix was a one-line wrapper:

// Before: WordPress calls this as sanitize_title( $value, $request, $param ).
'sanitize_callback' => 'sanitize_title',

// After: only the value gets through.
'sanitize_callback' => fn( $v ) => sanitize_title( (string) $v ),

Bugs like these tend to surface through checks rather than reading: every page rendered with WP_DEBUG on, every file linted, every interaction tested by script. The agent ran those checks. Knowing which ones a WordPress site needs, and refusing to call anything done without them, is developer work.

Other problems weren’t in the code at all. Elementor Pro’s Theme Builder, still active from the old site, silently replaced the new theme’s header and footer. A caching plugin delayed all JavaScript until the first user interaction, which broke the loader and the animations. Both had to be switched off. Neither shows up when you read the theme, because the theme was fine. Those are system problems, not code problems, and you learn to recognize them from years spent inside real WordPress installs.

The skills that matter more for developers in the AI era

• Reading code. You’ll read far more than you write. Reading a diff for what it actually changed, not what it claims to change, is a skill, and it can be practiced.
• Debugging the platform, not only the code. WordPress, plugins, caches and hosting: the stubborn bugs tend to live where systems meet, and that’s where an agent has the least context.
• UX judgment. Deciding that code blocks on my blog should wrap instead of hiding behind a horizontal scrollbar was trivial to implement and still needed a person to decide. Every site is full of calls like that.
• Talking to clients. Finding out what someone actually needs, saying no to what they don’t, and explaining trade-offs in plain language. No agent sits in that conversation.

Practical advice, from both sides of the hire

If you’re a developer in the AI era

• Go deeper on your platform. Knowing why WordPress unslashes post data or runs templates in global scope is what lets you catch an agent’s mistakes before your users do.
• Build your own checks. Lint, debug-mode renders, screenshots against the design, scripted tests for the interactions that matter. Make them part of your definition of done.
• Practice writing briefs. Constraints, examples and a checkable finish line. It’s the most transferable skill in AI-assisted work.
• Keep the decisions. Let the agent propose. Own what gets accepted.

If you’re hiring one

• Don’t hire for speed. Ask how they verify their work, and what they would push back on.
• Expect AI in their workflow. Then ask where the human checks sit in it.
• Listen for questions. A good developer asks about your content, your editors and your business before talking about tools.

On the hiring side, I go through the decisions you’re really paying for, and the questions that reveal them, in what a good developer still brings to an AI-powered project.

It also helps to know where the tools still fall short. I’ve collected the common failure points in what AI still gets wrong when building real websites, and the bigger picture of what has shifted in how AI is changing the way we build websites.

So yes, developers are still relevant. The ones who use AI to skip thinking will find it does that job better than they do. The ones who use it to think harder about outcomes, about what should be built and how to prove it works, will have more to offer than before, not less.