A Year of Designing With AI

I went freelance a year ago and rebuilt how I work around AI. Not dabbling with it on the side. Client websites, mobile apps, design systems, all of it running through agents and MCP servers.

Here's what actually stuck.

The speed is real, and it changed the job

A lot of people are sniffy about this. AI made me genuinely faster, and that mattered more than I expected.

Not because output volume is impressive. Because of what it does to the loop. If I'm unsure about a solution, I don't spend two days polishing a Figma file to find out I was wrong. I build a working prototype in an afternoon, put it in front of real users, and watch where they stall.

That wasn't available before. The gap between having an idea and testing it used to be weeks, and the cost of that gap was defending bad ideas because you'd already sunk time into them. Now you find out on Tuesday.

The pace is the new thing. What it's pointed at is still on you.

Empathy is the part that didn't get automated

Speed only helps if you're asking the right questions. Where does someone get stuck? What did they come here to do? Which decisions am I quietly dumping on them?

A model won't ask you any of that. It'll hand you something that looks resolved and skip every one.

Underneath those questions is empathy, and I don't think any model has it. It can describe empathy convincingly. It can write you a persona. What it can't do is sit with a real person's frustration and carry that feeling into every decision afterwards.

That's what experienced designers actually do. We hold real users in our head while we work. What someone reaches for first, what they'll misread, where their patience runs out, what they're anxious about before they even click. No skill file or prompt closes that gap.

Slop isn't an aesthetic problem

People say "AI slop" and mean generic layouts, samey gradients. That's the symptom.

The real failure is work that passes a glance test and falls apart in use. Fine in a screenshot. Then someone opens it, doesn't know where to click, finishes a flow without understanding what happened, and leaves.

That's an absence of intent. Nobody told the model who this was for or what success looked like, so it made something plausible instead of something purposeful.

Accessibility goes the same way. Contrast, focus states, touch targets, keyboard paths. Ask and you get them. Say nothing and you won't.

Feed it evidence, not vibes

Models get much better when you hand them real data.

On an existing product you're usually sitting on a pile of it. Heatmaps, analytics, click rates, drop-off points, search queries, support tickets. Most of it goes unread. Put it in front of the model with a clear question and you get analysis grounded in what people actually did, instead of a guess dressed up as a recommendation.

On something new, deep research got absurdly cheap. Pulling apart competitor reviews, forum threads and app store comments into a real map of where people are frustrated is now an afternoon rather than a fortnight.

Opinions in, opinions out. Evidence in, and it gets sharp.

Building is easy now. Marketing is the hard part.

Shipping a website or an app has never been easier, which means everyone is doing it and the competition for attention is brutal. The bottleneck moved. It's not "can I build this," it's "can anyone find it, and will they pay."

That side is genuinely hard, and most designers were never trained for it. Distribution, positioning, getting in front of the person who'd actually buy, building an audience before you need one so you're not launching into silence.

If you're making your own products, marketing isn't someone else's job anymore. It's the job.

My stack

Three layers, roughly.

Design. Paper.design does most of my visual work. The MCP is the obvious part, I prompt directions and run agents to explore variations of a feature. But what made it stick is that I can still design by hand in there, draw a box, move things around, adjust directly, all sitting alongside the agents. Coming from Figma you don't give up control, you just stop doing the tedious parts manually. It handles components and real design system work, and it renders actual HTML and CSS with Tailwind, so what you're looking at is what the web will give you rather than something a developer has to reinterpret.

Figma is still phenomenal and I want to be careful here. The manual side has started to feel like effort in the wrong place for how I work, but plenty of designers think best doing exactly that, and Figma now pairs that craft with agents in the background. That combination is strong if it's you.

Build and review. Cursor for running multiple agents in parallel, and its design mode for checking the thing actually looks how I want. Being able to inspect a live interface and give visual feedback directly, rather than describing it in a prompt, is a much better way to work for anything UI or UX. The Claude desktop app now has a built-in browser doing something similar, and Codex will let you draw on the interface to leave comments. Same idea across all three, and it removed a huge amount of friction from my review loop.

MCPs that pull weight. Mobbin MCP for reference. The agent can inspect existing products, pull out UX patterns and visual direction, and use it as grounding. That killed the screenshot ritual, hunting for examples, cropping them, pasting a dozen into a prompt. Big speed-up.

Playwright MCP for testing. It gives the agent the ability to actually walk through an interface, run a form, and surface visual or usability problems. The built-in browsers are quicker for a fast look, but for a proper pass over a flow this still earns its place.

The stuff that transfers

Tools churn. What carries over is the environment you build around the agent. Four files, four jobs.

CLAUDE.md is operational. How the project runs, what the agent should assume before it touches anything.

design.md is concrete. Colour, typography, spacing, how sharp or soft the radii are, what components exist, how they behave, what states they need.

brand.md is identity. Logo rules and usage, tone of voice, mission, vision, the language the brand does and doesn't use.

soul.md is the one most people skip and the one I'd argue matters most. Where brand.md says who the company is, soul.md says what the product is for. Who it's serving, what they're feeling when they arrive, what it should never become. None of that is a spec, which is exactly why it needs writing down. It's the layer a model can't infer from your code or your colour tokens.

Get those in place and the output changes character. You stop getting a plausible interface and start getting yours. When you move tools next year, that thinking comes with you.

The literacy nobody warned designers about

Git first. Not as trivia, as the thing that makes parallel agents safe. Branches and main, running different agents on different branches, merging cleanly, and reading the conflicts when two collide. Run more than one agent and that collision is coming.

Then enough code to steer. HTML and CSS, how Tailwind works, dropping in a library like shadcn/ui, running the install command that pulls a dependency. You don't need to be an engineer. You need to see what the agent did and know when it's wrong.

And the shape of the thing. Difference between a plain HTML page and a React app. How a project gets published, Vercel or otherwise, so what you designed ends up live.

None of that is computer science. It's literacy, and it's the gap between describing an outcome and steering toward one.

Start small

There's a new tool every week and everyone's posting a workflow. You won't keep up. Nobody is.

Look at your own week instead and find what's slow, repetitive, or blocking you. Not the impressive-to-automate parts, the ones that cost you time. If you want a shortcut, describe your working day to Claude or ChatGPT properly, boring tasks included, and ask what's worth accelerating first. Ten minutes, and you get something specific to you rather than another listicle.

Then pick one or two things and get good at them. Understand why they work, what context you're feeding in, what the model can't infer alone. Then extend.

The designers who'll do well here aren't the ones who tried everything. They're the ones who stayed clear about what they're for, understanding people and taking friction out, and got good at making the tools serve that.

The tools got fast. The thinking is still yours.