Build
July 26, 2026 · 5 min read
AI vs human web development usually gets argued with cost tables and vibes. I wanted a cleaner answer, so I ran the human side for real: I hand-built a one-page site from a fixed brief, then made the one change a client always asks for and measured exactly what it cost. This is for anyone deciding whether to hand a real site to AI or to a person, and by the end you'll know exactly where each one pulls ahead. The honest headline is that AI wins the first working page by a landslide, then hands the lead back the moment the job starts to look like real client work.
One thing up front. I didn't stage a fresh AI build to screenshot for this piece. The AI side here rests on documented, repeatable tool behavior, with sources, not a session I'd have to dress up. The measurement that carries the story is the hand-built side, and that part I ran myself.
I built one page for a fictional ceramics studio, by hand, with a single rule: after the first version worked, make one realistic client change and measure exactly what it cost. The page needed a hero with a headline, three feature cards, a simple pricing line, and a "Book a class" button. Nothing exotic. This is the kind of small-business page that makes up most of the web, which is exactly why it's a fair test.
The AI route on the same brief is the one the build a website with AI guide walks through: describe the page in a paragraph, let the builder scaffold it. I've put those builders head to head before in Lovable vs Bolt. So I already knew how the AI side behaves. What I didn't have was the hand-built number to compare it against.
The change a client actually asks for is small and specific, and by hand it stayed small. The request was to turn the button green and warm the hero background from cold gray to a soft cream. I opened the file, changed two properties, and saved. Done in under a minute.
I saved the page as before.html first, made the edit, and ran diff before.html index.html. It reported exactly two changed lines:
background: #f8fafc; -> background: #fef3c7; (hero)
background: #2563eb; -> background: #16a34a; (button)That's the whole change. Two lines, nothing else touched, nothing to re-inspect. Good enough ships, and this shipped in the time it takes to read this paragraph.
For the first working page, AI is the clear winner, and you don't need a staged demo to prove it. Producing a full styled page from one paragraph of instructions is exactly what these builders are documented to do: a dark-themed layout, feature cards, a pricing line, and a working button, all rendered and scrolling from a single prompt. A hand build, meanwhile, starts as an empty file and a header.
This is the half every comparison guide gets right. If the contest ended at the first working page, it wouldn't be close. The AI side would win the morning by a wide margin. The interesting part is what the guides skip: what happens on the very next request.
The lead flips the instant you make the first change a real client would ask for, because AI builders regenerate whole files instead of editing single lines. By hand that change was a 2-line diff I could read in five seconds. On the AI side, the same request is a full-file rebuild, and that is a documented pattern, not a horror story I'm staging.
It's called code drift: the model reinvents anything you didn't explicitly pin down, so a "just recolor the button" request can come back with different card spacing or a quietly reworded headline you never asked for. It's reported consistently enough to have a name and a cost analysis behind it, and design-system teams have written up the same drift from the styling side.
There's a money side to this too. Because each tweak is a full rebuild, it eats a real slice of your daily allowance. As of July 2026, Lovable's free plan gives you 5 daily build credits and v0's free plan gives $5 in monthly credits with a 7-message daily cap. Three rounds of "just move this and recolor that" can burn through a free day before lunch. That's not a hidden fee, it's the documented economics of regenerating a whole file for a two-line change.
If you stop at the first working page, AI wins by a mile; keep going with the changes a client actually asks for, and it lands in a near-tie, with the hand-built side in far better shape to keep editing. An AI-built page tends to look great and land fast. The hand-built page is slower to appear and easier to maintain, with no surprise edits hiding in it. Two honest strengths, pointing in opposite directions.
The neat "AI sets the pace" conclusion from every comparison guide turns out to be exactly half right and half misleading. AI sets a blistering pace to the first draft and a worse one for everything after it. I went deeper into what a full solo AI build actually looks like in my one-day landing page build, and the same shape shows up there: fast to a first version, then careful re-reading on every change.
Yes, and I'd split the job instead of picking a side. Use the AI builder for the first draft, get to a real page fast, then export the code and switch to hand edits for every change after that. The morning is where AI is genuinely unbeatable. The afternoon of small, precise changes is where a person editing two lines quietly wins. Trying to do the whole job in one mode is how you lose a lead you already had. Fair enough. That's the trade.
Time: a day
Cost: $0 on free tiers (Lovable free plan for the AI side; a text editor for the hand build)
Tools: Lovable (AI side), plain HTML and CSS (hand build)
Difficulty: 2/5 to start, 3/5 once the changes pile up
Claude Code vs v0 vs Lovable: I gave three AI tools the same app brief. One I built and measured, two I judged on documented behavior. Here's the winner.
I measured 15 production Claude Code skills, file by file. 81% of the library stays out of the context window until it fires.
I built the same website three ways with AI in one afternoon. Here's the real decision tree for picking a coding agent, UI generator, or no-code builder.