Twenty years of front-end, and what they are worth in the AI era

June 10, 2026 · front-end, web-design, ai, career

Today a short prompt to an AI model produces, in seconds, something prettier than almost anything I have built since I started making websites, twenty years ago. That is an uncomfortable thing to sit with, so I went digging through my old project folders to look at the trajectory honestly — and to try to answer the question that follows from it: what is still useful about a front-end skill built over those twenty years, in an era where a simple prompt outperforms most of it?

The trajectory, as found on disk

I still keep my first sites in a folder literally named “first sites (till 2006)”, numbered 1 through 13. The first one has a Flash menu — menu.swf, page.swf — because in that era a site without Flash felt unfinished. The HTML around it was produced half by hand and half by Dreamweaver, and you can tell which half is which. I was able to render some of these sites again for this post, and here I give you the first one, Flash menus included.

Security Heavens, a black-background hacker portal from 2004, with two Flash menus and virus news in Portuguese — Site number one, July 2004: "Security Heavens — o seu portal hacker". HTML frames, a Flash menu at the top and another on the left, and news about the first virus for cell phones. I was 13 years old, and it shows.

A few sites later I went all in and built one entirely in Flash, including the obligatory Matrix-style effect raining green characters behind the slogan.

A bit later come the first real client sites. One of them, a site for an office furniture company, opens like this:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<script language="JavaScript" type="text/JavaScript">
function MM_reloadPage(init) {  //reloads the window if Nav4 resized
  if (init==true) with (navigator) {if ((appName=="Netscape")&&(parseInt(appVersion)==4)) {

Every line of that snippet is a period artifact: HTML 4.01 Transitional, iso-8859-1 instead of UTF-8, the language attribute on script tags, and a Dreamweaver-generated workaround for a layout bug in Netscape 4, a browser that was already dead but that we still defended against out of superstition. The “design” was tables, sliced images, and one CSS file mostly used for fonts.

The next phase was hand-crafted CSS. A client site from some years later has a css/ directory with one stylesheet per page, a fonts/ folder, and small purpose-built JavaScript files — no framework, no build step. This is the phase where I actually learned the box model, positioning, and the discipline of reproducing a reference image pixel by pixel. I still have a folder containing just a screenshot of a progress indicator I liked and two test.html files where I tried to recreate it. That was the whole methodology: see something good, rebuild it from nothing until it matches.

Then React arrived and the work moved from pages to primitives. I wrote a library to manage CSS transitions with inline styles (react-inline-transition-group), and years later rewrote the same idea for the hooks era (react-transition-hooks). I built Material Design components by hand — data tables, paper-style widgets — before the big component libraries made that effort pointless. I also spent a good amount of time on Web Audio and Canvas visualizations, which taught me more about animation timing than any UI work did. Somewhere in this phase it became clear that what held my attention was never the design itself, but the engineering around it: I was always more interested in making a complex interface work in JavaScript than in making it beautiful.

Today most of my front-end output is Chrome extensions and the occasional product site, while my day job is backend platform work in Clojure. The front-end skill became a side discipline — and then the AI era arrived and seemed to devalue even that.

The site for Block & Focus, my Chrome extension. The first version is from 2017 — thirteen years after the hacker portal above — and was built with React, which says something about how far the default toolchain had moved from frames and Flash menus.

What the prompt actually replaced

To be fair about what changed: the model replaced the production of competent, good-looking default design. Decent spacing, fonts that match, pleasant colors, a landing page that looks professional — all of that is now the floor, available to anyone, instantly. The level I took years to barely reach is the new zero.

It also replaced the encyclopedic part of the skill. I no longer need to remember flexbox quirks or browser-specific workarounds, the same way I no longer need the Netscape 4 resize hack. Each generation of that knowledge died before this one; AI just killed the current generation faster.

But should the conclusion be that the years were wasted? I don’t think so, and not for sentimental reasons.

What is still useful

Critical sense, within my limits. I was never a designer — the model is honestly better than I ever was at the visual part, and pretending otherwise would be silly. But “pretty” and “right” are different judgments. I can tell when a component behaves wrong, when an interaction is slower than it looks, when the pretty version will not survive real data. The model still needs someone to perform that evaluation, and that part took years to build.
Vocabulary. A prompt is only as good as the words in it. Asking for a controlled component, a debounced input, or a transition that doesn’t unmount the element gets a different class of output than asking to “make it work better”. The years of building front-end applications gave me the names of things, and naming is now the interface.
The last ten percent. The model gets a page ninety percent of the way, and the remaining ten percent is the same job it always was: a dropdown that disappears behind another element, a flexbox child that refuses to shrink, an animation that stutters on a slower machine. Debugging that requires knowing what is behind the abstraction — and I know what is behind it because, at some point, I built most of those layers by hand.
Systems over screens. The model is good at producing one screen; what it is still weak at is the system around it. A real application is state flowing between components, screens that need to stay consistent with each other, an API that sometimes fails, data that grows beyond the mock. That is the same kind of thinking I use on the back end, where the systems serve millions of users — and it transfers in both directions. AI made the instances cheap; somebody still has to make them hold together.

Where that leaves me

After going through those old folders, my honest reading is that I was never really accumulating the ability to produce pixels — every generation of that ability expired, from Flash menus to Dreamweaver hacks to hand-written Material components. What accumulated was the judgment built as a side effect of producing them. AI moved the work from typing to evaluating, and evaluation is, perhaps conveniently for me, the only part that was ever durable.

So to me the trajectory still pays for itself, but with one caveat I can’t ignore: the next generation will build judgment without the years of manual production that built mine. The skill survives; the apprenticeship that produced it is what’s gone. I’m still not sure what replaces it.