Design infrastructure, or what's left when anyone can build anything.

For most of my career, being a designer meant making the thing. The logo, the landing page, the deck, the asset. This year I spent as much time designing and tinkering with the machines that make the things. Template systems in Figma, pipelines in Python, configs in YAML. I’ve started calling this design infrastructure, and I think it’s where a lot of design work is heading.

This post is the argument for why. AI collapsed the cost of building, so building is no longer what sets you apart. Taste is. And taste travels much further when you’re a generalist.

Anyone can build anything now

Two years ago, if I wanted a tool that watched Airtable and rendered designs based on the Figma templates automatically, my options were: hire a contractor or spend six months learning enough Python to hack it together badly.

Today the honest answer is that a designer with an idea and a Claude subscription can just build it. Design Clanker exists because of this. I’m not a software engineer. I had a clear picture of how the system should behave, I knew what the output had to look like down to the pixel, and I used Claude to fill in everything I didn’t know: API patterns, PDF internals, caching, deployment. The gaps in my knowledge stopped being walls and became things I could route around in a single afternoon.

This is genuinely new, and it cuts both ways. It means I could ship a tool that generated 2,000+ assets in production. It also means everyone else can ship things too. When building is cheap, it stops being the differentiator.

Taste is what’s left

Here’s what the agent could not do: it could not tell that a three-column stats layout looks broken when two columns are dashes. It could not decide that sponsor reports should feel personalized rather than templated. It could not look at fourteen layout combinations and know which ones a sponsor would actually be proud to forward to their boss.

That’s the job now. AI raised the floor: the default output of everything got better, faster, and more available. But the ceiling is set by whoever is directing it, and direction is taste. Knowing what good looks like. Seeing the thing that’s slightly off that nobody else notices. Recognizing which of the five generated options is the right one, and more importantly, when none of them are.

Designers have been training this exact muscle their whole careers. We just used to apply it one artboard at a time.

The generalist superpower

The usual advice for designers was to go deep. Pick a domain, master it, be the best at one thing. My severe ADHD never let me. I was always chasing novelty, wandering into a new domain right when I should have been drilling into the last one, and I ended up with a little knowledge about a lot of things instead of a lot about one. For years that felt like a liability. Then AI became what it is, and suddenly all those detours and distractions were the advantage: I knew how the dots connected across domains, and I finally had something that could fill in the depth I’d skipped.

A specialist with AI gets faster at their specialty. A generalist with AI gets capabilities. If you have a working mental model of how things should fit together, an agent can supply the implementation depth you’re missing, in whatever field you’re missing it. Your breadth decides how many places your taste can reach.

Everything I shipped this year worked this way:

• Design Clanker. I knew design systems and I knew roughly how the pipeline should behave. Claude filled in the Python, the Figma REST API quirks, ReportLab, pypdf, Fly.io. My contribution was the part no model could supply: knowing what the output needed to be.
• Framer code components. When we migrated PlatformCon from Webflow to Framer, I knew we were going to need a lot of custom elements. Not every feature that came with Webflow exists in Framer. Luckily Framer supports code overrides and code components. I don’t hold all of React in my head. I describe the behavior precisely, the agent writes the component, and I art-direct the result until it matches the picture I started with. The functionality of the sites I build is no longer capped by what I personally know how to code.
• This blog. Plain HTML and CSS on Vercel, with a small custom annotation syntax for circles, highlights and notes. I designed the reading experience I wanted first, then built exactly enough machinery to support it, learning the parts I didn’t know as I went.

In every case the pattern is the same: the idea and the standard come from me, the missing expertise comes from the model, and the result is something neither of us ships alone.

What the design mindset is actually worth

If you’re a designer wondering what you bring to this, it’s more than visual polish. A few things design training gives you that turn out to be exactly what directing AI requires:

You see systems, not instances. Design Clanker didn’t start as an engineering idea. It started as a design observation: these 2,000 assets are not 2,000 designs, they’re a handful of templates plus data. Noticing repetition, spotting the underlying pattern, separating what varies from what doesn’t. That’s design thinking, and it’s the whole insight the tool is built on.

You already know how to brief. Working with an agent is art direction. Vague briefs get vague work, from humans and models alike. Designers spend years learning to articulate intent precisely: what this should feel like, what it must do, what it must never do. That skill transfers directly, and people who have it get dramatically better output from the same models.

You know when it’s wrong. This is the dangerous part of gap-filling: you have to know enough to catch bad output. My rule is that I never ship code I couldn’t at least walk through and explain. The agent writes it, but I read it, question it, and make it prove itself on a real record before it touches production. Taste without verification is just vibes.

You know what not to build. Good design is mostly restraint, and restraint matters more when building is nearly free. The hardest decisions in Design Clanker were the features it doesn’t have. When an agent can add anything in minutes, scope discipline becomes a design skill, maybe the design skill.

How to actually work this way

Some practical notes, for designers who want to operate like this:

1. Start from a real problem you personally have. Not a tutorial, not a toy. I learn nothing from courses and everything from shipping. The sponsor PDFs taught me more Python than any curriculum could, because 3am is a great teacher.
2. Hold the spec, delegate the syntax. Your job is the mental model: what the system does, how the pieces connect, what correct looks like. The agent’s job is remembering how pypdf handles page merging.
3. Read everything what it writes. You don’t need to be able to write it from scratch. You do need to be able to follow it, and to notice when it did something you didn’t ask for.
4. Treat the agent like a very fast contractor. You wouldn’t accept a contractor’s work without review, and you wouldn’t blame them for a bad outcome from a bad brief. Same rules.
5. Build your own tools first. Before you automate for a team, automate something for yourself. The feedback loop is instant and the only stakeholder you can disappoint is you.

The job moved up a level

None of this makes designers obsolete. It makes the narrow version of the job obsolete: the one where you’re the human copy-pasting data into templates at 3am, which, as it turns out, was never really design anyway.

What’s left is the better part. Deciding what should exist. Setting the standard for what’s good. Designing the templates, the systems, and now the machines that produce the work. The output multiplied by a hundred, and the taste directing it is still one person’s.

That’s design infrastructure. I’d rather build it than be it.

---

Built with taste, and a lot of gap-filling.