TTWWADI: The Most Dangerous Sentence in the Age of AI

Tinkering with Time, Tech, and Culture #7

TTWWADI Thats the Way We Always Did It

0:00

/226.479979

1×

“That’s The Way We Always Did It.”

It sounds harmless. Even comforting.
But in the age of AI, TTWWADI is where innovation goes to die.

(In my last post, I explained why I’m still optimistic about AI — how it multiplies our creative and cognitive power. This post is about why we keep dragging old thinking into this new world.)

The Moment

We were deep into a brainstorm — building what could be a killer customGPT product. Something genuinely useful.
And then someone said, “We’ll need to build a companion website, of course…”

I said:
“No. No, no, no. That’s TTWWADI talking.”

Why rebuild an interface when the interface is already here?

That suggestion — automatic, well-meaning, and completely backwards — came not from the problem space, but from habit. From muscle memory. From decades of "good practices" now rendered obsolete.

That’s the thing with paradigm shifts. You don’t notice them when you're in the middle of one — unless you're looking directly at the moment you almost missed it.

This was mine:

The LLM is the interface. The product is the prompt. The app is the conversation.

We don’t need a “companion website.”
We need to stop thinking like it’s 2015.

Natural Language Is the Ultimate Interface

We’ve spent 50 years building layers to make computers understandable to humans:

• Command-line interfaces
• GUIs
• Menus
• Toolbars
• Form fields
• Mobile apps
• Voice assistants that mostly suck

All of it — a slow crawl toward one simple goal:

Let the human say what they mean. Let the machine understand.

Now, finally, we have that.

Large language models aren’t just clever — they’re transformative. Because they let us talk to software in the most native, intuitive, and accessible format we’ve ever had: language.

You don’t need to “learn the app” anymore.
You just need to say what you want.

And very soon — in six months, maybe less — most people won’t even be typing. They’ll be talking. Whispering ideas. Shouting tasks. Conversing with their own personal agent on a walk, in the car, while cooking dinner.

The keyboard is optional.
The UI is ephemeral.
The interface is you.

But Developers Can’t Let Go

This is where TTWWADI kicks in hard.

Developers have spent decades doing things a certain way — building websites, APIs, frontend frameworks, dashboards, onboarding flows. They’re good at it. It's familiar.

But legacy expertise is a poor substitute for future vision.

They see LLMs and instantly start building around them:

• “We’ll need a menu for prompt selection.”
• “We should wrap this in a React frontend.”
• “We need to train the user.”

No. Stop.

The user already knows how to talk.
They’ve been doing it since they were two.

The friction isn’t in the interface anymore — it’s in the assumptions baked into your design process.

TTWWADI in the Wild

You’ll hear it everywhere if you listen:

• “We always launch with a landing page.”
• “We’ll need a CMS to manage the prompts.”
• “Users expect a dashboard.”
• “Let’s build an onboarding flow.”

These are relics of a different age. The age of clicks and scrolls and static buttons.
But now we’re in the age of intent.

You don’t need to teach users what to do anymore — they can just ask.

And yet we’re still wrapping these raw, magical, generative systems in old-school constraints. Because TTWWADI is comforting. Safe. Familiar.

It’s also wrong.

The Interface Is the Intelligence

The real shift — the one most people haven't metabolized yet — is that the interface isn't a layer anymore. It’s not the thing around the intelligence.

It is the intelligence.

The conversation is the product.
The prompt is the UX.
The LLM is the app.

If you’re building an LLM-powered tool, the last thing you want to do is hide it behind a bunch of buttons and tabs and “workflow builders.”

That’s like putting a trench coat on a lightsaber.

We’ve finally built the closest thing to frictionless interaction — and the first impulse of most devs is to duct-tape an admin panel to it.

Letting Go of Legacy Thinking

This isn’t just about tech.
It’s cultural.
It’s neurological.

TTWWADI is a reflex, not a rationale.

We reach for the old way — not because it’s better, but because it’s burned into our synapses.
We’re “experienced.” We’ve seen what works. We’ve shipped a hundred apps. We know what to do.

But every now and then, something comes along that says:

Forget what you know. Start over.

That’s where we are now.

And if you can’t shed that legacy thinking, you won’t just fall behind — you’ll miss the entire plot.

A New Way of Building

Here’s the reality: most of the “product” now happens at the language layer.

• Building a tool? The core is the prompt.
• Personalizing a system? It’s in the context.
• Tuning UX? It’s how the model interprets and responds to intent.
• “Shipping an update”? It’s uploading a better knowledge file or adding a new function call.

The “frontend” is now optional. The user might never see your CSS. They might never even click.

Instead, they’ll ask.

That’s the product.

So What Do We Do?

We do what hackers, artists, and explorers have always done:

• Question the defaults
• Unlearn what no longer fits
• Build weird, fast, and without shame
• Focus on the interaction, not the polish
• Trust the user to express themselves

If you’re building something in the age of LLMs, don’t start with the UI.
Start with the conversation.

And if you hear someone say “That’s the way we always did it…”

You stop.
You breathe.
You say:

“Then it’s probably time to do it differently.”