Back to articles
January 2025·5 min read

Tailwind, AI, and the Cost of Cheap Code

Tailwind, AI, and the Cost of Cheap Code

“Talk is cheap. Show me the code.”

— Linus Torvalds

For a long time, this was the mantra. If you had an idea, you proved it by writing code. Code was the work. Code was the evidence.

That mental model made sense when writing code was expensive; when it required sustained focus, context, and skill. Producing a working implementation meant something because not everyone could do it quickly.

Today, that assumption is broken.

With AI, writing code is cheap. Sometimes absurdly cheap. You can describe a UI in a sentence and get back JSX, Tailwind classes, responsive behavior, and accessibility attributes in seconds.

But here’s the part that’s easy to miss:

Cheap code isn’t the same as cheap software.

And nowhere is this more obvious than with Tailwind.

AI Makes Code Cheap (Tailwind Makes It Easier)

Tailwind and AI fit together almost too well.

Tailwind is:

  • Verbose
  • Declarative
  • Highly patterned

That’s exactly the kind of surface area AI excels at. Ask it for a “responsive card component with Tailwind” and it will happily generate a long list of utility classes that mostly make sense.

And honestly, that feels great.

Spacing, colors, breakpoints, hover states -- gone. The annoying parts disappear. The feedback loop tightens. You feel productive because you are productive, at least in the narrow sense of output.

At this point, “show me the code” isn’t a challenge anymore. Of course there’s code. There’s always code.

The more interesting question is no longer can you write it? It’s can you maintain it?

A Concrete Example

Here’s the kind of thing AI is very good at producing:

<div className="group relative flex flex-col overflow-hidden rounded-xl border border-gray-200 bg-white p-4 shadow-sm transition hover:shadow-md dark:border-gray-800 dark:bg-gray-900 sm:p-6">
  <h3 className="mb-2 text-lg font-semibold text-gray-900 dark:text-gray-100">
    Project Alpha
  </h3>
  <p className="mb-4 text-sm text-gray-600 dark:text-gray-400">
    A short description of the project goes here.
  </p>
  <div className="mt-auto flex items-center justify-between">
    <span className="text-xs font-medium text-gray-500 dark:text-gray-400">
      Updated 2 days ago
    </span>
    <button className="rounded-md bg-blue-600 px-3 py-1.5 text-xs font-medium text-white transition hover:bg-blue-500">
      View
    </button>
  </div>
</div>

Nothing here is wrong.

In fact, it’s pretty good:

  • Clean visual hierarchy
  • Sensible spacing
  • Reasonable defaults
  • Works in dark mode

You drop it in. It ships. Everyone’s happy.

Until it changes.

Where the Cost Shows Up

A few weeks later:

  • Design wants tighter spacing on mobile
  • The button style needs to be reused elsewhere
  • The card is now used in a denser list view
  • Hover styles should only apply on desktop

Now you’re back in this component.

You’re scanning utility classes, asking questions like:

  • Which padding actually matters here?
  • Why is this mt-auto needed?
  • Is this color a design decision or just something the AI picked?
  • If I change this class, what else will I break?

None of this is catastrophic. But it’s slow.

The AI optimized for generation speed, not long-term clarity. It gave you a first draft, not a system.

And software doesn’t get expensive when it’s written. It gets expensive when it has to change.

Maintenance Is About Ownership, Not Syntax

This is the part that often gets lost in AI discussions.

Maintenance isn’t just:

  • Fixing bugs
  • Tweaking styles
  • Refactoring code

It’s about ownership over time.

Someone has to:

  • Understand why the code exists
  • Decide which parts are stable and which aren’t
  • Know when to abstract and when not to
  • Keep the system coherent as it grows

AI doesn’t take responsibility for any of that.

Tailwind makes trade-offs very explicit: you put styling decisions inline, close to usage. That’s often a good deal. But when AI starts generating large volumes of Tailwind code, the cost of those decisions accumulates faster.

Humans feel verbosity. AI doesn’t. Humans pay the maintenance tax. AI doesn’t.

So we generate more code than we would have written ourselves--and we inherit all of it.

The Real Shift: From Writing Code to Owning It

AI doesn’t remove work from software development. It relocates it.

Effort shifts:

  • Away from typing
  • Toward reading, evaluating, and deciding what should survive

“Code as output” stops being a useful signal. “Code as a long-lived asset” becomes the real concern.

In this world, the valuable skills aren’t about producing code quickly. They’re about:

  • Knowing what not to keep
  • Creating structure once repetition appears
  • Designing systems that are easy to change under pressure

AI is excellent at first drafts. Software lives or dies on the fifth and tenth revisions.

Closing

Linus was right--for his time.

When code was expensive, “show me the code” was a meaningful bar. Today, code is abundant. AI can generate it endlessly.

The scarce resource now isn’t code.

It’s clarity. It’s ownership. It’s the ability to maintain what you’ve built when the novelty wears off.

AI makes code cheap.

Maintenance is still expensive--and someone always pays for it.