Design is moving closer to the work

For most of my career, the distance between a good idea and a shipped product was treated like weather. You planned around it. You made peace with it. You learned which ideas could survive the trip through roadmaps, handoffs, analytics backlogs, engineering queues, research plans, data gaps, and the normal entropy of teams trying to do too much with too little time.

Designers got very good at making work legible across that distance. We made flows, prototypes, workshops, diagrams, journey maps, research readouts, and design system documentation. The best of that work still matters. I am not interested in pretending that taste, facilitation, systems thinking, or user understanding suddenly became obsolete because a model can write React.

But the distance changed.

The old model often forced designers to stop right when the work got interesting. You could see that a product needed a richer data layer, but the schema lived somewhere else. You could tell that a dashboard needed a better way to explain uncertainty, but the evaluation logic belonged to another team. You could imagine a more useful workflow, but the automation, permissions, source data, and edge cases were scattered across the organization.

So design became a translation layer. We translated user needs into artifacts. We translated complexity into screens. We translated ambiguity into alignment. That was valuable work, but it also kept us one step removed from the system we were trying to improve.

Tools that generate, summarize, retrieve, or act make that removal less inevitable. A designer can now explore data structures, write small scripts, inspect APIs, generate prototypes from source material, test variants, record workflows, draft eval criteria, and ask better questions of the implementation itself. Not as a replacement for engineering. As a way to arrive at the conversation with more evidence in hand.

I think this is the real shift. AI gives designers access to speed, but speed is the least interesting part if it only helps us produce more rectangles.

The better opportunity is proximity. Proximity to the science behind a recommendation. Proximity to the data that makes a visualization honest or misleading. Proximity to the edge cases that usually hide until late QA. Proximity to the actual text a user will read, the event a system will log, the source a model will cite, and the review gate a human will need before trusting the output.

That proximity changes the quality of design judgment. Saying 'this needs to be trustworthy' is easy. Inspecting the source data, writing the confidence language, designing the review path, and making sure the system never pretends certainty where it only has a guess is the actual work.

It also changes what evidence means. A useful model-mediated workflow should be able to tell the difference between a claim, a behavioral signal, a traceable outcome, and a controlled test. Those are not the same thing. Treating them as the same thing is how teams end up with dashboards that look confident and products that quietly drift away from reality.

There is a lazy version of the future where everyone becomes a prompt person and craft gets flattened into vibes. I do not buy it. The more AI enters the work, the more teams need people who can make judgment calls across messy boundaries.

Designers are trained to sit in ambiguity without immediately turning it into machinery. That matters. But now we can also build enough of the machinery to understand its shape. We can prototype with live data. We can notice when the data model is fighting the user's mental model. We can see when an automation creates a trust problem before it creates a productivity win. We can make the last mile feel humane.

The work is now interface design, system understanding, scope of authority, and what gets left behind for the next team to reuse.

That last question matters more than I used to think. The strongest work includes the durable pattern left behind: the critique routine, the source-of-truth rule, the design-system update, the eval rubric, the skill another person can run without needing me in the room.

A shipped thing teaches you differently than a static artifact. Even a small working prototype changes the conversation because it forces reality into the room. The copy either holds up or it does not. The data either arrives or it does not. The interaction either reduces cognitive load or creates a new little tax. The team can see it, use it, dislike it, improve it.

I care so much about live artifacts because they make the process visible: motion clips, public-data prototypes, Notion workspaces, skills, routines, working product surfaces.

I want designers close enough to the work that our judgment becomes more useful, more grounded, and harder to hand-wave away.

I want design to be less precious and more powerful. Less trapped in critique theater. More willing to touch the data. Less satisfied with a beautiful empty state if the underlying workflow is still broken. More fluent in the systems that produce the interface.

The once spark-deadening space between idea and shipped product is smaller than it has ever been. That should make us more ambitious. The designer who can cross that space with taste, care, technical curiosity, and a quality bar is going to matter a lot.