Tailwind made me design better

I started building websites in 2013. Back then it was just raw CSS, and honestly, I had no idea what I was doing design-wise. For years, the answer to that problem was Bootstrap, and it worked well enough. But Tailwind changed everything for me, not just how I write styles, but how I think about design.

From Bootstrap templates to actually designing

In the Bootstrap era, most of us weren't designing anything. We were buying premium templates from marketplaces because making something look good with Bootstrap was a genuine skill that most developers didn't have. You'd find a theme, customize it just enough to feel original, and ship it. Design felt like someone else's job. The workflow was painful too. You'd write your HTML, jump to a separate CSS file, create a class name, write your styles, switch back, and repeat. Caching issues meant you'd sometimes see stale designs even after making changes. And when you needed to update something months later, good luck finding which CSS rule was actually responsible. The stylesheets would grow bloated and tangled over time, and nobody wanted to touch them.

Why Tailwind just clicks

Tailwind takes a fundamentally different approach. Instead of abstracting styles into separate files, you write them directly in the class attribute of your HTML or JSX. At first glance, it looks messy. A button with bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded seems like a lot. But in practice, it means the design lives right where the component lives. This matters more than it might seem. When I need to change how a card looks, I open the component file and everything is right there. No hunting through stylesheets, no wondering which class overrides which. The mental overhead drops dramatically. The utility-first approach also pairs perfectly with component-based frameworks like React and Next.js. Since you're already thinking in reusable components, co-locating styles at the component level is the natural next step. You build a <Button> component once, style it with Tailwind utilities, and reuse it everywhere. The reusability happens at the component level, not the CSS level, which is far more intuitive.

How instant feedback taught me to design

The real magic happened when I combined Tailwind with a hot-reloading dev server in Next.js. Every change I made to a class was instantly reflected on the page. No build step, no cache clearing, no refresh. Just type and see. This created a feedback loop that fundamentally changed how I learned design. I could experiment at incredible speed, trying different spacing values, color combinations, and layout approaches in seconds rather than minutes. When something looked off, I'd tweak it immediately. When something worked, I'd notice why it worked. Before Tailwind, I never would have spent time experimenting with design because the iteration cycle was too slow and frustrating. But with instant visual feedback, design stopped feeling like a chore and started feeling like play. I learned more about spacing, typography, and visual hierarchy in a few months of Tailwind than in years of traditional CSS.

The framework that won, but can't pay the bills

Here's where the story takes an ironic turn. Tailwind has essentially won the CSS framework war. According to the State of CSS survey, Tailwind's retention rate sits in the high 70s, meaning roughly three out of four developers who try it keep using it. Compare that to Bootstrap at around 45%. Tailwind powers over 617,000 websites, including Shopify, GitHub, and NASA. But the business behind Tailwind is in serious trouble. Revenue has dropped approximately 80%. Documentation traffic is down about 40% since early 2023. In early 2026, Tailwind Labs laid off three of its four engineers. Founder Adam Wathan put it bluntly: "If absolutely nothing changed, then in about six months we would no longer be able to meet payroll obligations." The culprit? AI coding tools. LLMs like Claude, ChatGPT, and Copilot have been trained on Tailwind's documentation and can generate Tailwind code directly. Developers no longer need to visit the docs site, which is where Tailwind's paid products like Tailwind UI templates are advertised and sold. The framework became more popular than ever while the business model collapsed underneath it. This sparked a broader debate about open-source sustainability in the AI era. A GitHub issue was opened suggesting Tailwind adopt an LLM-specific license requiring AI providers to pay royalties for using the framework. It's a thorny problem with no clean answer. AI tools train on open-source code, make it more popular, reduce the need for anyone to visit the creator's monetization touchpoints, and the creator goes out of business.

The open-source paradox

I think about this a lot because without Tailwind, we genuinely wouldn't be moving this fast in frontend development. The framework made design accessible to developers who never considered themselves designers. It lowered the barrier so much that AI tools can now generate beautiful interfaces almost effortlessly, in large part because Tailwind's utility classes give AI a consistent, predictable vocabulary to work with. But if the people building these tools can't sustain themselves financially, what happens next? Tailwind v4 shipped with significant performance improvements, including 40-60% faster build times, proving the team is still pushing forward. The question is whether they can find a business model that works when AI has fundamentally disrupted the relationship between documentation traffic and revenue. For platforms like .NET MVC, native Tailwind support still isn't seamless without workarounds, which is surprising given that both TypeScript and .NET are Microsoft technologies. Better integration there would bring these benefits to an even wider developer audience.

What Tailwind really taught me

Tailwind didn't just give me a better way to write styles. It gave me the confidence and the feedback loop to actually learn design. The speed of iteration, the co-location of styles with components, the elimination of context-switching between files, all of it added up to a developer experience that made me genuinely better at building things that look good. Whether or not Tailwind Labs figures out its business model, the impact on how an entire generation of developers thinks about design is already permanent. The utility-first approach proved that developers can be designers too, if you give them the right tools.

References