Predictions about AI are cheap, and most of them are written by people with something to sell in the direction they're pointing. So before any of mine: my basis for having an opinion, and my bias.
I run a one-person studio building custom websites, and I built WebSeek.ai, an AI website generator that turns one prompt into a deployed site across three model providers. So I sell custom development and I built the machine meant to make it unnecessary. My bias probably cuts both ways, which is the best I can offer.
Everything below is labelled with how confident I actually am, because a prediction without a confidence level is entertainment.
What I'm extrapolating from
Not from model announcements. From two years of watching where these tools help and where they stop, on real projects with real deadlines.
The single most useful observation: the limits I hit are mostly structural, not quality-related. When a generator can't decide whether a restaurant's booking flow matters more than its menu, that's not a gap a better model closes — it's missing information that exists only in the owner's head. Improvements in raw capability don't touch it.
That distinction drives almost every prediction here. Where a limit is about capability, expect it to fall. Where it's about knowledge, stakes or accountability, expect it to persist.
Already true, just unevenly distributed
Some of "the future" has happened and hasn't spread yet.
Setup cost is already near zero. Debugging unfamiliar errors is already a conversation. The tedious quality work — schema, accessibility passes, test cases — is already cheap enough that skipping it is a choice rather than a budget constraint. Plenty of teams haven't adopted this yet, which means the next couple of years will look like dramatic change and will mostly be catch-up.
If you want the current state rather than the forecast, that's what has actually changed.
1. Better models won't break the generator ceiling
Confidence: high.
This is the prediction I hold most strongly, because I've watched it directly. Running one product across three providers, the differences between them are real but textural. None of them changed the fundamental problem: someone types "website for my restaurant" and the model must invent a hundred decisions nobody made.
It invents them plausibly. Never knowingly. That gap isn't a capability gap — it's an information gap, and no amount of model improvement fills it, because the information was never written down.
What will improve is the quality of the guess and how well the tool asks for missing context. Both are worth having. Neither turns a generated site into a considered one.
What follows: generated sites keep getting better and stay recognisably generated. The gap between "looks finished" and "is finished" narrows visually and stays where the money is.
2. Agents take more of the loop; accountability doesn't move
Confidence: high on the first half, very high on the second.
The clear direction of travel is from "generates a snippet" to "carries out a multi-step task" — makes a change across several files, runs the tests, reads the failure, tries again. That loop will keep getting longer and more reliable.
What doesn't change is who answers the phone. When a booking form silently drops enquiries on a Friday night, the client calls a person. No degree of autonomy shifts that, and it's most of what a client is actually buying.
So the practical shape is more capable tools operating under someone who remains responsible for the result. That's not a small change — it's a large one — but it's an amplification of the current arrangement rather than a replacement for it.
3. Review becomes the paid skill
Confidence: high.
If producing code trends toward free, the scarce thing is judging it. That inverts how the profession has valued people: writing was the skill, reviewing was overhead. It's already flipping and it will flip harder.
This is awkward, because review is genuinely harder than writing and much less pleasant. Writing, you build the mental model as you go. Reviewing, you reconstruct someone else's — and generated code has no author to ask.
What follows: the developers who do well will be the ones who can read a large diff and spot the one subtly wrong thing. That skill is built by writing a lot of code by hand, which is the uncomfortable part of the prediction — the path to being valuable runs through the work that's being automated. The limitations post covers what that review is actually looking for.
4. The junior pipeline breaks before anyone fixes it
Confidence: high on the problem, low on the solution.
Junior developers historically did the work AI now does well. That work was badly paid and slightly boring, and it was also how judgment got built — you learned what good looked like by producing a lot of not-good and being corrected.
Remove the bottom rung and you get fewer seniors in a decade. Everyone in the industry can see this. Almost nobody is acting on it, because the cost of training juniors is immediate and the cost of not training them arrives later, somewhere else.
I don't know how this resolves. My guess is that firms which invest in training anyway end up with an unfair advantage in about five years, and that this becomes obvious in retrospect. But that's a guess, and the honest position is that this is the most serious unsolved problem the tooling has created.
5. The average website becomes free, so specificity gets more valuable
Confidence: high.
A competent generic site is heading toward costing nothing. Which means it's worth nothing as a differentiator — if everyone's site is competent, competent stops being an advantage.
What stays scarce is a site that could only belong to your business. The specific flow. The proof that only you have. The tone that sounds like a person. Models converge on the average of what they've seen, so anything genuinely distinctive is, almost by definition, the part they can't produce.
For a creator with 600,000 subscribers, generic was the problem we were hired to solve. That kind of work gets relatively more valuable as the baseline gets cheaper, not less.
What follows for businesses: stop paying for a website that looks like a website. Start paying for the parts a generator structurally cannot do.
6. Being cited outgrows being ranked, for some businesses
Confidence: medium-high on direction, low on timing.
People increasingly ask an assistant for a recommendation instead of scrolling a results page. That's a different game with a different referee — search rewards the page that earns the click, assistants reward the source that's easiest to quote accurately.
I'm confident this share grows. I'm not confident how fast, and anyone giving you a percentage is guessing. What I'd say practically: the work that makes you quotable — clear factual claims, real structured data, content that answers a question completely rather than teasing it — is the same work that has always made for a good website. It's a low-risk bet because it pays off either way.
The mechanics are in GEO vs SEO and getting recommended by ChatGPT.
7. The middle of the market gets squeezed hardest
Confidence: medium-high.
The bottom — cheap template assembly — goes to AI builders, and honestly should. Those clients were being poorly served.
The top — genuinely custom work with real stakes — is fine, arguably better off, because the tedious parts got cheap and the differentiating parts got relatively more valuable.
The squeeze is in the middle: shops charging real money for work an AI builder now approximates. Their pitch was "better than a template, cheaper than custom," and the floor just rose underneath them.
This is a prediction against my own market segment as much as anyone's, which is why I'd rather state it plainly. The response isn't to compete on speed — it's to be clearly on one side of the line. Agency versus freelancer covers where that line currently sits.
8. The tooling disappears into the workflow
Confidence: medium-high.
Right now AI assistance is a thing you go to — a panel, a chat, a separate product. That's what every new technology looks like before it settles, and it's usually temporary.
The direction is toward assistance that's simply part of the environment: present where the work happens, aware of the project without being told, invoked without ceremony. When that lands, "AI tools" stops being a category the same way "spellcheck tools" stopped being one.
The practical consequence for anyone choosing tools now: don't over-invest in a particular product's workflow. The capability will outlive the interface, and the interfaces will churn a lot before they settle.
Confidence, honestly
| Prediction | Confidence | Rough horizon |
|---|---|---|
| Better models don't break the generator ceiling | High | Already true |
| Accountability stays with a person | Very high | Indefinite |
| Review becomes the paid skill | High | Underway |
| Agents take longer task loops | High | 1–3 years |
| Average site trends to free | High | 1–3 years |
| Junior pipeline problem worsens | High (problem), low (fix) | 3–10 years |
| Middle market squeezed | Medium-high | 2–5 years |
| Citation outgrows ranking for some | Medium-high direction, low timing | Unclear |
| Developers become unnecessary | Low | Not on this evidence |
Three predictions I think are wrong
"Developers are obsolete within two years." This assumes the job is writing code. The job is deciding what to build and being answerable for it. Writing was how that got expressed, not what it was. People making this prediction are usually describing a job they've never done.
"Everyone becomes a developer now." Producing code got easy; understanding it did not. The gap between what a non-developer can generate and what they can debug is the widest it has ever been. That's a maintenance crisis in slow motion, not a democratisation.
"AI will write and maintain entire systems unsupervised." Maintenance requires knowing why something was built a particular way. That reasoning frequently exists nowhere — not in the code, not in the docs, only in someone's memory of a conversation. Unsupervised maintenance means confidently changing things for reasons nobody can check.
How you'll know if I was wrong
A forecast you can't check isn't worth much, so here are the specific things that would tell me I've misread this. I'd rather write them down now than quietly revise the story later.
On the generator ceiling. I'd be wrong if generated sites started making genuinely good decisions about ambiguous briefs — not producing better-looking output from the same guess, but correctly identifying what a business's site should prioritise without being told. The tell would be a generator that asks the two questions that actually matter instead of inventing answers to a hundred.
On accountability. I'd be wrong if a serious commercial market emerged for AI-built sites with no human responsible for the outcome — someone selling a website with the failure risk genuinely priced in rather than passed to the buyer. That would mean the accountability problem was economic rather than structural.
On review becoming the paid skill. I'd be wrong if verification became automatable — if checking correctness got as cheap as generating. There's a real argument that models will become good enough at reviewing each other's output that this happens, and I hold this prediction less firmly than the first two for exactly that reason.
On juniors. I'd be delighted to be wrong here, and the signal would be firms genuinely training people into judgment rather than hiring only seniors and hoping the supply holds.
The prediction I'd defend hardest is the one about specificity, because it isn't really a claim about AI. It's a claim that as any capability becomes universal, it stops being an advantage — and that has held for every technology I can think of.
What to actually do about it
If you're a developer: get faster at the mechanical parts and spend the time on judgment. Keep writing some code by hand deliberately, because that's what preserves the ability to spot bad output. Get closer to the business side — understanding why something is being built is the part that isn't being automated. The learning path I'd take is built around this.
If you're a business owner: assume the baseline is free and stop competing on it. Spend on the parts that are specific to you. Own your code and your content so you can move as the tooling shifts — the businesses that struggle over the next five years will be the ones renting both from someone else.
If you're hiring: stop asking whether someone uses AI. Ask what they wrote by hand and why, and what they've rejected from a model recently. That distinguishes supervision from delegation, and it's the only question here that will still be useful in five years.
The honest summary
The future of AI-assisted web development looks a lot like the present, with the dials turned up. Faster mechanics, higher floor, more review, same judgment, same accountability.
The interesting shift isn't technological. It's that the parts of this job which were always the most valuable — knowing what to build, telling right from plausible, owning the outcome — are now the only parts you can reliably charge for. That's uncomfortable for anyone who was making a living on the rest, and it's clarifying for everyone else.
If you want the whole argument rather than the forecast, the AI and web development cluster collects it, and how I actually build is what all of this looks like applied to a real project.