Everyone Coded. Nobody Curated.

Open ten landing pages that shipped in the past few months. Same gradient hero. Same dot-grid background. Same testimonial card with the same drop shadow. This is what a commoditized medium looks like, and it is the best news designers have had in a decade.

For the past few months, a lot of people who are not designers have been claiming AI will replace designers. The take has gotten loud enough that I want to push back on it. Not because it is threatening, but because it is wrong in a specific and interesting way.

What is actually happening is that the entry into design got a lot broader and a lot easier. The floor of web design has been raised across the board. Anyone with a frontier model open can now produce something that, a year ago, would have been gated behind a junior designer or an agency. That is real.

But raising the floor produced a second effect almost nobody is talking about. AI has pulled more people into design and multiplied the volume of work shipping, and in doing so it has raised, not lowered, the value of differentiation.

When everyone can ship competent, competent is no longer the moat.

So with this new level of competence, what does it mean to be a designer in 2026?

Code finally became a design medium

A year ago it was hard to believe AI would play a major role in design, and it is hard to blame the skeptics. You would prompt something and, if you were lucky, get something usable. Layouts would drift, text would overflow, or the result would come back as a big red Error you had to paste back into your agent to debug.

These error cases have now almost entirely stopped happening. Agent workflows have gotten more sophisticated, models have provided more reliable output, and everyone has gotten a little more familiar with how to ask for something reasonable from an AI. Harnesses, the layer around a model that shepherds it along to something useful, have started to emerge as a real category. The frontier coding products are now genuinely capable. They build things that are stable, and because the work is stable, we can finally start generating interesting artifacts on top of it. The latest generation of image models has been a useful lever on top of that.

We are at the very beginning of a new medium. The medium is designing directly in code, through an LLM.

Designing in code has been around for a while. People have called themselves design engineers in the context of producing with code, and historically those people could hand-craft things line by line. That is still a real and excellent role, but the prerequisite has changed. Now that prompting is the input modality, anyone can be a design engineer. It just depends on your appetite for prompting and your tolerance for the iteration loop, which sometimes still puts a big Error screen in front of you.

Competent is no longer the moat

The challenge for the design career, for the design professional, is now to have enough range in expression, call it taste, to produce something that is actually unique. Given the proliferation of the same handful of fonts, the same default color palettes, and the same standard web design vocabulary, there has been an explosion in creative work for the web represented in code.

And yet there is a vacuum in the polish that is required to actually finish something.

Look at early-stage brands today. They are all suffering from homogeneity. Any startup building a landing page right now has to grapple with the fact that, by default, it just feels boring. Polish is missing from the design process partly because a single prompt can get you somewhere acceptable, partly because budgets are limited, partly because everyone needs to move faster than ever. There is less internal appetite for things that are very well put together, and less time for things that are well curated.

What has actually happened is that the entire interface design industry has exploded in volume of work. And soon it will follow with an explosion in demand for high-quality work. There will always be a need, and an excitement, around the higher end. The floor for creative implementation of design in code has risen substantially, and soon to follow is demand for designers who really understand the medium and can implement artifacts that work within it.

Systemization becomes a primitive

There is an underlying theme of systemization happening with design, which has always existed in some form. Brand guidelines are the core primitive of it, essentially a higher abstraction of a design system. What is different now is that those guidelines are being represented in code, which means they can be translated into usable artifacts that agents can build on top of.

Whether it is a design.md file, a set of references, an image library, or something else, the agents are now able to play and remix with the resources that are out there. Which, if we are being honest, is what design has always done: remix what already exists. The difference is that anything code-native is now up for grabs. There are extensions that let you extract code from any site and paste it into your design environment. Or you can delegate the task to your agent and tell it to go pick something up and work with it.

Two things also seem to be true that pull in opposite directions.

The first is that there is heavy subsidization happening underneath all of this. The code-production machine that the frontier labs are running is functionally a subsidized product, and it is flooding the market with work. It is unclear how long this stays cheap, and unclear what the experience feels like when the costs catch up.

The second is that cost is already starting to become apparent at the margin. People are realizing they need to get more for their money. They are realizing that smaller models can inhibit certain tasks, or that three prompts to a cheap model equals one prompt to a more expensive model, with far less headache. They are realizing that, much like delegating to a person who needs to ramp on a project, the agent's memory and context on a given decision matters a lot. Persistent context is going to be one of the most undervalued primitives of the next year.

What it means for designers

The baseline expectation for design has been lifted. If your design skills are not at the same bar as an LLM's ability to suggest something basic, you need to upskill quickly. I am talking mostly about UX work here, the kind of obvious decisions that used to separate a competent product designer from a junior one and are now one prompt away. To stay ahead of that, you need a sharp sense of what is possible, so you actually know what to ask for.

The other thing is that designers are, more than ever, stewards of the overall experience. And the remixability of code makes that easier, not harder. It is now easier to bring systems into the work you are creating. You can pull in packages that immediately upskill what you can produce. You can bring in resources and elements from across the open web because, if you are working in code, everything is interoperable.

Code-as-design-medium has an expanding surface. The more your work is represented in code, the more use cases and form factors you can serve, and the more boundaries of what technology can offer you can push. Good design solves for the most cases. Code is the substrate that lets you do that.

Design tooling has not caught up

As of right now it seems clearly true that design tooling has not caught up with dev tooling. This is a sentiment I have heard echoed by senior design leaders at the largest organizations.

A lot of designers have started to build their own tooling, which is good. But that tooling tends to be reserved for a very specific niche: a precise comment-and-feedback flow, a particular kind of input control, one slice of the process at a time. It is uncertain how many different services you will need stitched together to have the full experience of a former design tool while generating things visually via code. Right now it feels like a duct-taped pile of disparate tools, and the opportunity for a centralized solution is still open.

One way to see the future is to look at what founders are doing, and a large portion of recent startups have vibe-coded their websites. Most of these websites look pretty boring, but they do get the company up and running in a medium, code, that offers maximum flexibility.

A lot of teams building in the design tooling space have also been chasing the HTML and CSS representation of code while still dragging along the old assumption of the prior era: direct manipulation as the primary, and sometimes only, input. That assumption is the thing I am most convinced is going to break.

The harness question

It is still very much yet to be seen how creative tools, and the agent harnesses underneath them, operate outside of the developer harness category. There is a large need for tooling to understand what a design harness even is and how it is supposed to operate. What does state look like inside it? What does context look like? What gets persisted across sessions? What is a skill that is supposed to express something visual?

The optimism here is strong. There are lots of good attempts at bringing in the ability for models to generate things visually. The divide between UI generation and image generation is closing a little with the latest image models, but there is still a real disconnect between the medium of flat images and code.

As people on the internet continue to rant about how design is dead, or how a new tool has supposedly ended the discipline, I want to emphasize that most of this is happening from people who are not really designers. Yes, anyone may now be able to produce something with a bit more creativity than they have before. But at the end of the day, designers are always looking to push the limits. We will probably never be satisfied. We are always looking for something bolder, more creative, something that pushes farther than the default.

Actually, I will take that back. Designers will never be satisfied. Because our responsibility is to stretch the creative limits of what we can do with what we have.

It can also be true that designers themselves have been eager and excited by this new medium, and the ones on the bleeding edge have embraced new tooling and effectively graduated into a kind of front-end engineering. What is left, then, is a very open and not-yet-well-understood space: working with creativity inside the harness category, and inside the model category. The people doing the most innovative work right now are either at the model labs or on the fringe in a tiny startup, and it has been impressive to hear the lengths of experimentation teams are going through to codify taste into their systems.

A new medium, not a better version of the old one

It seems like the industry has been chasing the old model of what design is, at exactly the moment when we are just beginning to discover the expression of a new medium, which is the visual representation of language.

The next design tool will not look like the design tools of the past. Building styling tooling is a difficult problem to solve across all the different surfaces a designer touches. Code is expressive temporally. You change the color of a button, and it changes in the codebase, but only for that one state of the button. Buttons have multiple states: hover, active, focus, disabled, the dark variant, the small variant, the loading variant. Solving that across the matrix of frameworks and conventions is its own multi-quarter problem.

What keeps showing up across this space is people investing in parts of the product surface that seem like they would be important, when the data says otherwise. In the age of AI, the biggest lift comes from how good the agent is and how effective it is at translating what you actually need. To get an excellent result out of the model, you have to find it with the most relevant context up front. Any tool that falls short of context curation and context execution is not going to be a tool that succeeds in this future.

Where this is by year-end

Here is where I think this is by December.

The static design file stops being the default artifact for new product teams. Not gone, design files do not disappear, but for teams starting work after the summer, the default canvas is the codebase itself, and the design file becomes an exploration surface rather than the source of truth. There will be room for drawing rectangles to explore things, but there is already a sense of tension between designers who code something and designers who draw something during design reviews.

Brand-as-code becomes a real practice. design.md, brand.json, whatever the convention ends up being, teams will start versioning their guidelines the same way they version their components, because that is the only form the agents can reliably consume.

Agents will become first-class users of design tools. They already play a large role in the generation of concepts, but a space will emerge where agents can drive autonomously to do creative work, and that space will not look like a static experience.

If the next 90 days is anything like the last 90 days, there will be plenty of disruption and claims and prophecies about the future of design. But I am confident in the designer's role, and eager to see the creative things that designers will make with the medium of code.