Luke FinchSay hello

Posts

Lost in Translation: why writing is the ultimate design skill in the AI era

We’ve reached a strange moment where acceleration has become our primary proxy for quality.

Published

We’ve reached a strange moment where acceleration has become our primary proxy for quality. With generative AI baked into our tools, it’s never been easier to produce high-fidelity outputs. But this frictionless creation masks a deeper issue: In the age of AI-assisted product development, the most important discipline we can hold is knowing what you think before you generate anything.

I’ve recently been spending a lot of time thinking about the relationship between speed and quality. What I’ve come to realise is that AI doesn’t just change how we make things; it fundamentally disrupts the signals we rely on to know if anything we’re doing is actually any good.

To adapt, we need to instill cultural change, and foster a culture of writing first.

The trap of high fidelity

Historically, low fidelity was a signal. A rough sketch or wireframe came with the premise that it was purposefully unsettled and exploratory. It was the conversation starter to develop confidence within the group. As confidence in the solution grew, the fidelity of design grew with it. Work earned its polish.

AI has completely destroyed this natural progression. Everything gets output at maximum fidelity on the first pass. Psychologically we’re susceptible to polish; when something looks finished, we treat it as such — including the person that generated it. Everything comes out looking like a decision, whether or not a real decision has been made.

An MIT media lab study recently highlighted this trap. Students that used AI from the beginning of a project showed less brain activity, struggling to recall what they’d produced, and felt no ownership of the result. Conversely those who outlined their thoughts on their own first — then revised with AI — showed the strongest cognitive engagement.

Writing first

To fix this, we have to restore the barrier between exploration and execution.

The rule is simple: no interface work begins, until a written document exists.

This isn’t meant to be a bureaucratic gate; it’s a structural discipline. A written blueprint, in plain prose, is intentionally low fidelity. It forces thinking out into the open, before it gets locked into an interface.

Our fidelity should map to our level of confidence in an idea:

  • **Plain notes **for problems we do not yet understand
  • **Structural blueprints **for open solutions
  • **Rough wireframes & flow charts **for showing clear direction of intention
  • Prototypes for demonstrating committed solutions.

The needle without the thread

There is a hidden trap in our modern design review process: critiquing “finished” prototypes is almost always sullied by a total lack of context and historical understanding.

When you drop a stakeholder or peer into a polished prototype, they react to the visual execution, not the logical foundation. They don’t see the trade-offs or systemic constraints that led to this execution. As a result, feedback inevitably devolves into subjective debates on the surface level.

Handing someone a prototype without the underlying logic is like handing them a needle without the thread: you’re inviting them to poke holes instead of weaving a solution.

Critiquing a written blueprint changes the dynamics of critical thinking. When you sit down with the team to review the problem space in explicit terms — the user’s intent, the data model, the sequence of events — you are debating the actual problem. It forces the review to revolve around the why instead of the what.

By critiquing writing first, from first principles, you bring everyone along on the journey. They participate in foundational decision making. By the time we’re ready to build interfaces, the debates are already settled. We don’t need to go back to the drawing board, because we’ve already secured buy-in on the architecture.

You cannot delegate understanding

The philosophical weight of this approach comes down to one absolute rule: never delegate understanding.

In the film _Lost in Translation, _Bill Murray’s character remarks, _“The more you know who you are, and what you want. The less you let things upset you.” _A similar principle applies here. The more you know exactly what your problem is, because you did the hard work in writing it out first, the less you will get derailed by the non deterministic thrash spat out by the LLMs.

If you cannot write a plain-language explanation of the problem, the underlying data models, and intended interactions before committing pixel to canvas, you do not understand the problem yet. AI cannot generate its way to that understanding on your behalf.

I’ve seen this failure occurring at the organisational levels across the industry. Teams get stuck in pure execution mode, pressured by feature parity to prioritise rapid output over structural understanding. Designs end up shaped by training data conventions, rather than strategic intent, outputs are stuck in a generic meh-zone, nothing is wonderful, it’s just average at best.

I’ve got the need, the need for sitting down with a cup of tea and talking about this.

This isn’t an argument for slowness. It’s an argument for well-paced intentionality.

Machines run at a constant speed. They don’t pause to question the premise, and they don’t sit down mulling over a problem.

Writing the work first sequences the work such that acceleration happens at the right stage. We build deliberate bottlenecks to critique the blueprints. Once the blueprint is solid, it becomes the prompt for the AI tools. We can do the last leg blistering fast, precisely because we’ve honed the inputs.

The way to go fast is to do the understanding part first. Rushing past it doesn’t save time, or lead to a better product. It just creates disconnected features and designs that fail to solve a user’s actual needs.

Pipelines for accountability

When we write the decision down first, we encode accountability into our workflow. We stop being passive approvers in an LLM’s pipeline, and remain as active designers.

If you want to start putting these thoughts into practice, I’d start with these habits:

  1. Write the problem out before you prompt. Do it for yourself, and your team, not the AI. Write one or two sentences, who’s this for, what they need, your core hypothesis. If you can’t write it, don’t generate it.
  2. Make the written blueprint your primary artifact. Everything else — wireframes, systems, generated UI — must follow from the logic established in this document.
  3. Use AI to fail faster. Design lives in rejected drafts, and failure is a highly effective learning tool
  4. Document the why. Record trade-offs you made, rationalise why you went one way and not the other. This is how you build accountability and protect your team’s strategic intent.

Fast does not equal good. But clear, intentional thinking does.

Originally published on Medium.