The starting point for everything that follows: we have built a system that can take any website and recreate it exactly as it looks, in perfect, maintainable, production-grade code, and that can create an unlimited number of new great sites nobody has seen before. Nobody else can do that.
The proof is on the next screen. The rest of this page proves nothing; it explains. The images are placeholders, not results. All amounts on this page are in US dollars (USD).

Every AI on earth fails at the same thing, and no AI company has fixed it. We are the only ones who can. First, two concrete examples: what an ordinary user gets, and who pays. Then, in order: what the problem is, why it exists, why nobody else is fixing it, how we do it, how much of that is built, and what it is worth. The short version: frontend and design is a market of about $500 billion a year, and this is the one thing that lets an AI take it.

What it is. A recreation of Stripe's Swedish homepage, built by our system in one shot. The source code: github.com/JoelEmanuelNilsson/not-stripe. The code is production-grade and maintainable: React 19 and TypeScript, one folder per component (35 of them) with its own styles, colours, type and spacing kept as design tokens, all copy in a single content file, and a type check and 33 tests that pass.

The frame runs the real site, not a picture. Switch between desktop, tablet and mobile, or drag the edge of the frame to any width: the layout adapts as you drag. Open it in a new tab to see it full size. Links and buttons on the site lead nowhere: it is built as a demo.

This is the whole value, seen from an ordinary person. Today she gets the same mediocre page as everyone else, whichever AI she asks, and still needs a designer and a developer. With our data in the AI she gets a great website, with finished code, from a single message. That goes for every person and every company that asks any AI for a site. Why that is: the chapter "The problem".

The lab has a problem it cannot fix on its own: its AI cannot do frontend, and it has been that way for years. We sell the data that fixes it. The lab trains its AI once, and after that every user of that AI, and every product built on it, gets great sites: the bakery, Lovable and every tool like it, the agencies, and an AI agent for businesses, the option often suggested. We have one customer, not a thousand. The customer has everything else: the models, the chips, the users, the money. It lacks only the data.

Dark background, a row of numbers, two pricing cards, a purple button. Four companies, four separate AIs, one and the same layout. That is not a coincidence: they all learned to build websites in the same place, the public web, because that is the only large pile of website code that exists. American or Chinese, open or closed: same pile, same habits, same layout. The next screen shows what is in the pile.

Each dot is a website whose code an AI can read. Great design takes months and rare skill. Turning it into great code takes longer and rarer skill. The few who do both almost never publish the code: it stays private or ships in a form nobody can learn from (the hollow dots). What is public is templates, course exercises, tutorials and plugins: the worst code there is, with essentially no design. That is the whole pile.

This is the one thing to understand about these AIs: they don't pick the best thing they've seen, they reproduce the most typical thing they've seen. Ask for a website and you get the typical website of that pile. The typical one is that dark page with the purple button. And it can never land on the right: the typical thing in a pile is, by definition, not the best thing in it. The average of bad is bad.

The score is a tournament: two AIs build the same page, a person picks the one they prefer, the winner's score rises. So it can only ever say "beats the other AIs more often". Every contestant draws from the same pile, so the winner is the cleanest average, not a different layout. And the rise itself came from data: the labs collect millions of those votes and train on the winning pages. More of the same pile makes the layout prettier, not better. Nothing can enter that was never in the pile.

The same models, the same year. Ask for a Minecraft or a Rocket League and you get a working game, with physics, that looks like the real one. Why? Whole game engines are open source, thousands of complete finished games are on the web, and the labs pay game studios for more. Great game code is easy to get. Ask for a website and you get the purple page, because great website code is not for sale and not public. If the AI were the problem, the games would be bad too. It is a data problem.

Downloading the web again gives the same web. Asking the AI to write new sites gives the AI's own average, which is the same pile. Paying people to hand-build great sites costs thousands of dollars each and never reaches millions. That is the whole problem, in one sentence: the data that would fix this does not exist, and nobody can generate it at scale.

An AI is a prediction machine: it writes the next word, or the next line of code, from everything it has read. It cannot invent. Everything it makes is built from its training data.

In maths, logic and backend code it has read everything: every textbook, every paper, all the code on the web. So it can draw parallels between subjects, calculate, reason for hours on one problem, check its work, keep notes, try again. That is how it solves problems nobody has solved: new to us, assembled from what it read.

For the frontend it is the same machine with nothing to work from. Almost no great sites in what it read, so nothing to draw parallels between, nothing to reason toward. It generates the pile. (That no program can check "beautiful" makes it worse; the main reason is simpler: no data.)

So the training data has to be insanely good, and in huge quantities. That is the thesis.

When OpenAI's image model GPT Image 2.0 was released, people started having it draw landing pages as images and then asking an AI to build them. The images were perfectly fine: not great, but not slop. So the models already have a sense of what a good page looks like; more screenshots are not what is missing. What is missing is the source code: going from image to correct, finished code in one pass requires the AI to have read enormous amounts of perfect code, and no AI has. That is why every example in our data is a whole website: every subpage, screenshots at every screen size, and source code that is perfect for that exact site. Image and code together.

None of the problem is a secret. Everyone who understands these models knows an AI cannot make what it never read, that great web design is not in the data, and that a wrapper has no edge of its own; the labs treat it as an open research problem, and the Lovable-type companies compete on infrastructure, pricing and integrations instead. The data is missing for one reason: nobody knows how to make it. It shows: nobody has released a Lovable competitor that does frontend well, and the models themselves have not got better at frontend at all. Millions of S-tier sites, all different, all correct, has not been done. That is what we know that almost nobody agrees with: it can be made, at scale, at the quality and diversity needed.

Paste the address of any website. The machine studies it and writes brand-new code that produces the same look: layout, colours, type, behaviour, on every screen size. It downloads the site's pictures, fonts and other assets and uses them; it never sees the site's source code, because that is not public. Like an architect drawing complete new blueprints from looking at a building, furniture included.

Press once and out comes a website nobody has seen: a new design, complete working code, every screen size. S-tier means the top grade: the level of the best design studios in the world, in code a senior engineer is happy to maintain. How the machine does this is not in this document.

The input takes the arguments: how many sites, which types, which stacks. Then the machine runs on its own until the dataset is done. Every site is a new design of any type: a shop, a bank, a bakery, a software product, a magazine. Every example is complete: the whole site with every subpage, screenshots at every screen size, and the source code. Each one is checked before it counts. The next best thing that exists is people building S-tier sites by hand, a few at a time. Nobody else has a machine that does this; this is the green pile, and we are the only ones who can make it.

What Lovable actually is. An AI agent: a lab's AI model, paid per API call, running in a loop. Read the task, pick a tool, call it, look at the result, go again. Tools are functions it may call: write a file, run the code, look at the screen. MCPs are the integrations (Stripe, a database, login): one shared protocol for every AI, where each plugin describes how to use itself; anyone can build one. Around that, a system prompt (standing instructions), caching, and for production a sandbox per user and the plumbing to scale it. All ordinary engineering, with open-source examples. Why people use Lovable anyway: they were first. The founder, Anton Osika, built GPT Engineer, the first really good AI wrapper, and it went viral; then he put together one of the best startup teams to be found in Stockholm, and they have done a fantastic job. So when people talk about AI companies, they talk about Lovable: the brand, the integrations, the team, and people liking to use it. That is worth a lot, and it is not enough. The model, which does the actual work, is the lab's and is paid for per API call. And the model is the problem.

Lovable delivers what the lab's AI generates: the pile, polished. That is where the slop comes from, and no wrapper can fix it. Ours is not a wrapper. It is a system, and the AI is one part inside it; how it works is not on this page. It does two things nobody else can. Press once: a new S-tier design. Point it at any website on the entire web: an exact lookalike. If we sold it as a product, the frontend would be better than any Lovable-type tool's, and the backend is not hard: we would match it.

Remember the rule: the AI generates the most typical thing it has read. (That is a simplification. A model is trained to predict the next token, meaning the next piece of a word or of code, from the ones before it, and on top of that comes post-training with reinforcement learning and many other techniques that steer how it answers. But none of that adds anything it never read; it shapes how it uses it.) Change what it reads and you change what it generates. If millions of the websites in its pile are great, the typical website is great. Nobody has to correct it afterwards; great is now what it expects a website to be. That is what "solving frontend" means: anyone asks any AI for a website and gets correct S-tier code, every time.

Every part of the solution exists and works today: replication, generation, the checking, the stacks. What remains is to run it at scale and produce the first dataset. How each part works, and the numbers behind the remaining step, we go through in person.

That is the thesis: S-tier, novel, every type, unlimited. An AI pretrained on that generates S-tier by default, and everything built on that AI gets it too. The machine can be sold three ways. As a product like Lovable: you type, it builds, ours is better. As an API to the web and design agencies that make sites for a living. Or as the dataset: the biggest and best frontend data in the world, sold to the labs to pretrain on. The first two are good businesses. The third is where the billions are, and the next chapter shows why.

All amounts in this chapter are in US dollars (USD). The right place to start is not a huge market but a small one you can own completely, then grow outward from it. The market here is training data for frontend, sold to AI labs. About six buyers. No sellers. We would be the only one. From there it grows in rings: one lab, then every lab, then every stack and every new library as it appears. The large number on the right is not our market. It is what the buyer's AI takes once it has the data, and it is the reason the buyer pays.

Frontend and design are one problem, and we solve both, so they are one number. About 8 million frontend developers and 1.5 million designers are paid roughly $450 billion a year. Companies buy another $55 billion of design and development from agencies. The tools, from Figma to Wix, are about $15 billion. Half a trillion a year, every year. An AI that does this work may shrink that market (fewer people per site) or grow it (far more sites built); nobody knows which. What is certain is that the lab whose AI does the work takes part of it, and that lab pays for the one thing that makes it possible.

A company is worth X, the value it creates, times Y, the share of it the company captures, and the two are independent. X here is about half a trillion a year. Y belongs to the lab, and it is unknown: we do not know how the labs will price frontend or how much of the value they will keep. What is known is what they already pay for ordinary data, the grey bars: data made by hand, which improves a model a little. Meta paid $14.3 billion for half of one such vendor. Ours is the only data that makes a model able to do frontend at all, and every one of the six labs needs it. That is why $20 billion is the number we aim at, and $3 billion the number below which we do not sell.

The alternative most often suggested is to sell a product instead: an AI agent for businesses, or something similar for consumers. It is a real business and can make millions, if it turns a profit in time. But look at the list. It is a wrapper around a lab's AI model, paid for via API, the same as Lovable, so the only things to compete on are staff, sales, integrations, operations and price, against hundreds building the same thing on the same model, and the margin belongs to the model owner. The dataset's list has two lines, and no competitor. The order is fixed: the data first, because every site a product ships is public and the labs would read it for free. The product, an agent for businesses included, comes after the deal, on an AI that finally does frontend.

The way every large technology company started: own a small market completely, then grow from it. Step one: raise, run the machine, produce the first dataset, the highest quality there has ever been and probably the biggest, and sell it to one lab. Step two: reinvest, produce a dataset ten times bigger, and let the labs bid; every lab needs it. Step three: the exit, in whichever shape a buyer wants: the company with the tool and the data, exclusively, or the data alone, or the same data to several labs. And speed: nobody else is doing this because nobody else knows how, and we close the first deal before anyone works out how.

The question that matters: why is this still the leading company ten years from now? Being first counts for little; being the last one in the category is what counts. Every route to the same data is closed: it cannot be scraped, the AI cannot write it, people cannot make enough of it, and nobody is building a machine because nobody knows how. The machine does not stop at today's web: every new language or library gets its dataset too, so the data never goes stale. Whoever owns it stays ahead in frontend for as long as AI needs data. We sell that position to a lab, fast, before anyone works out how it is done.

An AI generates the most common thing it has read. Great website code is not there to read, so every AI's site is mediocre, and that cannot be prompted away. Nobody can make the missing data, except us. The machine that makes it is built and works today: S-tier sites without end, for cents each. A lab pays billions for the data, because it gives its AI an ability no AI has. Then every AI can do frontend, and the lab takes its share of a market of $500 billion a year. What is left for us is to run the machine at scale and sell the dataset. No staff, no customers to support, no competitor. The details, in person.