<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Theo Soti on Medium]]></title>
        <description><![CDATA[Stories by Theo Soti on Medium]]></description>
        <link>https://medium.com/@theosoti?source=rss-217b8ac98858------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*KJjGsdw-1_x1IYJNNNmXYQ.png</url>
            <title>Stories by Theo Soti on Medium</title>
            <link>https://medium.com/@theosoti?source=rss-217b8ac98858------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 06:26:36 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@theosoti/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[CSS Relative Colors: Build UI Palettes Without a Color Picker]]></title>
            <link>https://medium.com/@theosoti/css-relative-colors-build-ui-palettes-without-a-color-picker-eb781ed29b84?source=rss-217b8ac98858------2</link>
            <guid isPermaLink="false">https://medium.com/p/eb781ed29b84</guid>
            <category><![CDATA[css3]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[css]]></category>
            <dc:creator><![CDATA[Theo Soti]]></dc:creator>
            <pubDate>Mon, 26 Jan 2026 00:00:54 GMT</pubDate>
            <atom:updated>2026-03-23T10:53:50.018Z</atom:updated>
            <content:encoded><![CDATA[<h3>Why relative colors feel like cheating</h3><p>If you ever built a tiny design system, you already know the loop: pick a brand color, then hand craft a hover state, a border, a shadow, a muted background, and a highlight. Five minutes later you have a handful of unrelated hex values that look correct but do not scale.</p><p>The problem gets worse as soon as you add more contexts. Dark mode, marketing pages, seasonal themes, or a new product line all require a new set of tweaks. Manual palettes start to drift, and every refactor becomes a color audit.</p><p>Relative colors break that loop. They let you reference a source color and adjust its channels directly in CSS. One base becomes a small palette, and that palette stays consistent as you change the base later.</p><p>I like to think of relative colors as relationships, not values. The system says, “hover is 12% darker than the base” instead of “hover is #3d56d6.” That mental shift removes a lot of tiny decisions from day to day UI work.</p><p>⚠️ <strong>Quick support note:</strong> global support for relative color syntax is <a href="https://caniuse.com/css-relative-colors">about 89.64%</a> as of February 2026, so it’s up to you if you want to use it now.</p><h3>The old workflow: manual palette drift</h3><p>Here is the classic setup. You define a base color, then you create a new value for every variation you need:</p><pre>:root {<br> --brand: #4b6bff;<br> --brand-hover: #3d56d6;<br> --brand-active: #2f45b2;<br> --brand-border: rgba(75, 107, 255, 0.2);<br> --brand-soft: #e9edff;<br>}<br><br>.button {<br> background-color: var(--brand);<br> border-color: var(--brand-border);<br>}<br><br>.button:hover {<br> background-color: var(--brand-hover);<br>}<br><br>.button:active {<br> background-color: var(--brand-active);<br>}</pre><p>This works, but each value is hand picked. If you ever change --brand, you also have to re-pick the hover, active, border, and soft background. That is why palettes drift over time.</p><p>The subtle issue is that every token becomes a frozen decision, not a relationship. Once you lose the relationship, you lose the system: changing the base color means re‑discovering the entire palette from scratch, and a new page or theme multiplies that work.</p><h3>Meet relative colors</h3><p>Relative colors let you extract channels from an existing color and modify them in place. You can do that in hsl(), rgb(), lch(), or oklch().</p><p>Here is the core idea:</p><pre>.button {<br> --brand: #4b6bff;<br> --shift: -12;<br> --hover: hsl(from var(--brand) h s calc(l + var(--shift)));<br> --border: rgb(from var(--brand) r g b / 0.2);<br><br> background-color: var(--brand);<br> border-color: var(--border);<br>}<br><br>.button:hover {<br> background-color: var(--hover);<br>}</pre><p>The hover and border are now derived from the same base value. Update --brand and the rest updates automatically.</p><p>The syntax looks strange at first, but it follows a simple pattern:</p><pre>hsl(from &lt;color&gt; h s l / &lt;alpha&gt;)</pre><ul><li>from &lt;color&gt; is the source. It can be a hex value, a CSS variable, currentColor, or another color function.</li><li>h, s, and l are placeholders for the original channels.</li><li>You can replace any channel with a number or a calc() expression.</li></ul><p>Hover or focus a piece to see how it maps</p><p>Examples:</p><pre>/* Shift hue by 30deg */<br>--accent: hsl(from var(--brand) calc(h + 30) s l);<br><br>/* Desaturate and brighten */<br>--soft: hsl(from var(--brand) h calc(s - 20) calc(l + 20));<br><br>/* Keep RGB but lower alpha */<br>--shadow: rgb(from var(--brand) r g b / 0.25);</pre><p>The mental model is simple: pick a source, then nudge the channel you care about.</p><h3>Choose the right color space</h3><p>Relative colors work in the space you choose. That choice affects how the results look:</p><ul><li><strong>RGB</strong> is great for alpha tweaks and direct channel edits. It is not perceptual, so changing channels can feel uneven.</li><li><strong>HSL</strong> is quick for hue and saturation shifts. It is intuitive, but the lightness channel does not match human perception.</li><li><strong>OKLCH</strong> is the most consistent for lightness changes. It is a better default when you want palettes that feel balanced across hues.</li></ul><p>Relative colors always convert the source into the output color space before doing any math. The result is expressed in that output space, which is why hsl() and oklch() can yield different shifts even with the same numeric offsets.</p><p>A good rule of thumb is to use rgb() for transparency and oklch() for lightness. Reach for hsl() when you want fast adjustments or you need wide support.</p><h3>Build a mini palette from one variable</h3><p>A practical way to start is to define a handful of tokens. You can keep the palette small and still cover most UI needs.</p><p>This recipe builds seven tokens from one base color and keeps everything in sync.</p><p>OKLCH uses different numeric ranges than HSL. Lightness resolves to 0–1, chroma resolves to 0–0.4 in relative syntax, and hue resolves to 0–360. That is why these offsets are written as small decimals instead of percentages.</p><p>Here is the token recipe that powers the palette:</p><pre>:root {<br> --brand: #4b6bff;<br> --strength: 0.12;<br> --strong-color: oklch(from var(--brand) calc(l - 0.12) c h);<br> --soft-color: oklch(from var(--brand) calc(l + 0.4) c h);<br> --accent-color: oklch(from var(--brand) l c calc(h + 20));<br> --brand-border: rgb(from var(--brand) r g b / 0.18);<br> --brand-shadow: rgb(from var(--brand) r g b / 0.3);<br>}</pre><p>This small set is usually enough for a button, a badge, a soft background, and a border. If you need more depth, add one extra step for a darker and lighter variation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*kYpxanC3L8ae6rSeLdGAuw.gif" /><figcaption>Relative palette builder</figcaption></figure><h3>A component recipe you can copy</h3><p>Relative colors shine when a component needs multiple accents. Here is a compact pattern for a callout card:</p><p>Keep derived tokens in one space so the relationships stay coherent. Mixing spaces is valid, but remember the source is converted to the output space for every calculation, which can subtly change the result.</p><p>The component only needs one input (--tone). Everything else follows.</p><pre>.callout {<br> --tone: #4b6bff;<br> --tone-strong: hsl(from var(--tone) h s calc(l - 12));<br> --tone-soft: hsl(from var(--tone) h calc(s - 20) calc(l + 28));<br> --tone-border: rgb(from var(--tone) r g b / 0.2);<br> --tone-shadow: rgb(from var(--tone) r g b / 0.25);<br><br> border: 1px solid var(--tone-border);<br> background-color: var(--tone-soft);<br> box-shadow: 0 12px 24px var(--tone-shadow);<br>}<br><br>.callout strong {<br> color: var(--tone-strong);<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yk0YZzCL89_D8MBsYrRGYw.png" /><figcaption>Callout card made from 1 color</figcaption></figure><h3>Altering the lightness channel</h3><p>If you want a quick set of tints and shades, you can keep the hue and saturation and only shift the lightness. The slider below changes a single --step value, and every swatch is derived from the same formula:</p><pre>.swatch {<br> --offset: calc(var(--step) * var(--i) / 100); // i is the swatch index<br> oklch(from var(--brand) calc(l + var(--offset)) c h);<br>}</pre><p>Here --step is a plain number. Because HSL lightness runs from 0 to 100, a step of 5 means &quot;five lightness points.&quot; Values are clamped to the channel range, so going past the ends just pins at 0 or 100.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*mSfGZZNUKUQRtdJ3Dwnf-w.gif" /><figcaption>HSL lightness threshold</figcaption></figure><h3>HSL vs OKLCH (why the difference matters)</h3><p>HSL is fast and familiar, but its lightness channel is not perceptual. The same +10% shift can feel dramatic on one hue and barely visible on another.</p><p>OKLCH is much more consistent. It keeps lightness changes feeling even across different hues, which is why it is great for UI palettes.</p><p>Also note the unit differences: HSL uses a 0–100 scale for lightness and saturation, while OKLCH lightness is 0–1 and chroma values are much smaller. That means a +0.1 OKLCH lightness shift is already significant.</p><p>Here is a side by side comparison using the same lightness shift in HSL and OKLCH.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*412E_z-XIOcTAwyzl9_-7Q.gif" /><figcaption>HSL vs OKLCH comparison</figcaption></figure><p>If you want predictable results across colors, OKLCH is usually the better space for lightness adjustments.</p><h3>Use relative colors with currentColor</h3><p>A neat trick is using currentColor as the source. That lets icons, borders, and highlights follow the text color automatically.</p><pre>.badge {<br> color: #1d4ed8;<br> border: 1px solid rgb(from currentColor r g b / 0.2);<br> background-color: oklch(from currentColor clamp(0%, calc(l + 40%), 100%) c h);<br>}</pre><p>currentColor resolves to the computed text color of the element. That means any change that affects the actual computed color (inheritance, state styles, media queries) will flow through the derived colors automatically.</p><p>One change to color updates the border and background without touching any other variables.</p><h3>The payoff</h3><p>Once you start using relative colors, you stop thinking in isolated hex values. You think in relationships: hover is a darker brand, borders are the same brand with lower alpha… and your palette stays coherent by default.</p><p>If you need older browser support, consider a fallback palette.</p><p>If you are building a design system or cleaning up a few components, this is one of the CSS features that makes everything feel simpler.</p><h3>Support My Work</h3><p>Feel free to leave your comments or questions via email at <a href="/service/mailto:hey@theosoti.com">hey@theosoti.com</a>.<br>If you found this article helpful, please share it with your peers.</p><p>Happy coding!</p><p><em>Originally published at </em><a href="https://theosoti.com/blog/css-relative-colors/"><em>https://theosoti.com</em></a><em> on January 26, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eb781ed29b84" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tailwind’s hidden trade-off]]></title>
            <link>https://medium.com/@theosoti/tailwinds-hidden-trade-off-8df75eeb0bd6?source=rss-217b8ac98858------2</link>
            <guid isPermaLink="false">https://medium.com/p/8df75eeb0bd6</guid>
            <category><![CDATA[tailwind]]></category>
            <category><![CDATA[css3]]></category>
            <category><![CDATA[css]]></category>
            <category><![CDATA[tailwind-css]]></category>
            <dc:creator><![CDATA[Theo Soti]]></dc:creator>
            <pubDate>Thu, 08 Jan 2026 18:56:44 GMT</pubDate>
            <atom:updated>2026-01-10T09:56:08.574Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wt22Q8CrwgPhQRwX25nQYA.png" /></figure><p>If you hang around modern frontend discourse (or pretty much any React codebase), Tailwind feels like the default.</p><p>It’s fast. It’s polished. It has great docs. It makes UIs look decent by accident.</p><p>And yet… I don’t use it.</p><p>This post is my attempt to explain that without turning it into a holy war. I’m not here to dunk on Tailwind, and I’m definitely not here to cosplay as the last defender of “real CSS”. Tailwind is an impressive piece of work.</p><p>But for the way I build things, it’s not my tool.</p><h3>Tailwind’s actual superpower (it’s not “utilities”)</h3><p>Most arguments around Tailwind get stuck at the surface:</p><ul><li>“Class soup is ugly”</li><li>“It’s basically inline styles”</li><li>“No, it’s faster”</li><li>“No, it destroys semantics”</li><li>“No, BEM is worse”</li></ul><p>That debate is endless.</p><p>The real Tailwind pitch is simpler: <strong>constraints + speed</strong>.</p><p>Tailwind turns styling into selecting from a predefined design system (spacing scale, font scale, colors, shadows, radii). That’s why it feels so productive. You’re not inventing a new margin value every 5 minutes , you’re picking from a menu. Tailwind’s own docs explicitly frame it as “designing with constraints”, and pair that with variants for hover, focus, and responsive behaviour.</p><p>When Tailwind works, it feels like this:</p><ul><li>You have a component in your head</li><li>You type the HTML</li><li>You sprinkle utilities until it looks right</li><li>You move on with your life</li></ul><p>No naming. No context switching between files. No “where is this class defined”. No cascade surprises.</p><p>And if you’re working in a team (or inheriting a codebase), the consistency is a big deal. You can open any component and recognise the spacing and typography patterns instantly, because everyone is pulling from the same scale.</p><p>That’s a real benefit.</p><h3>“Isn’t it just inline styles?” Not really.</h3><p>This is worth addressing because it’s the most common misunderstanding.</p><p>Inline styles are limited. No pseudo-classes, no pseudo-elements, no media queries, no selector relationships, no tooling. Utility classes live in real stylesheets, so they can do everything CSS can do (including complex selectors, responsive behaviour, caching, processing, etc.).</p><p>So no, Tailwind is not style=&quot;&quot;.</p><p>It’s more like: “write your CSS once, pre-slice it into Lego bricks, then build UIs by snapping bricks together.”</p><h3>The moment Tailwind clicks (and why people love it)</h3><p>I’ve worked on Tailwind projects. I get the appeal.</p><p>There are three moments where Tailwind feels undeniably good:</p><h4>1) You stop naming things</h4><p>Naming is hard. Naming CSS classes is its own little tax.</p><p>Tailwind sidesteps that by making your “naming” be the composition itself. You don’t create .pricingCardFeatured and then hunt for it later. You just describe the styles right where they apply.</p><p>Even if you disagree with the conclusion, the problem is real: CSS and HTML are coupled whether you like it or not.</p><h4>2) It makes boring layout work fast</h4><p>Spacing, flex, grid, alignment, typography: Tailwind is extremely optimized for the 80 percent case.</p><p>It’s especially good at “dashboard UI” work: cards, nav bars, modals, forms, tables, list items, and all the slightly boring stuff every product needs.</p><h4>3) It gives you a default design system</h4><p>This is the underrated part.</p><p>People don’t just like Tailwind because it’s utilities. They like it because the defaults are tasteful and cohesive. You can move quickly without designing a spacing scale from scratch.</p><p>That “design tokens out of the box” feeling is the gateway drug.</p><h3>The main trade-off Tailwind makes</h3><p>Tailwind’s trade-off is not “long class attributes”.</p><p>That’s annoying, but it’s manageable.</p><p>The real trade-off is: <strong>you move a big chunk of your styling layer into your markup layer</strong>.</p><p>Sometimes that’s exactly what you want.</p><p>But it changes how the codebase feels.</p><p>And that’s where I start to drift away from Tailwind, because for me HTML readability is not optional. It’s where I think about:</p><ul><li>structure</li><li>accessibility</li><li>content hierarchy</li><li>interactive states</li><li>layout relationships</li></ul><p>When every element is carrying 15 to 40 styling decisions, the document stops reading like a document.</p><p>Yes, components help. Yes, you can extract patterns. Yes, you can use @apply (we’ll talk about that). But the default mode is still “style lives in the markup”.</p><p>Some people love that. I don’t.</p><h3>Another trade-off</h3><p>There’s one more Tailwind trade-off that doesn’t show up:</p><p><strong>you’re not just adopting a set of utilities, you’re adopting a whole ecosystem.</strong></p><p>Tailwind works because it’s a tightly designed package: a Domain-Specific Language, a compiler pipeline, a config-driven design system, a documentation culture, and a bunch of editor tooling that makes it pleasant.</p><p>That’s great… until it isn’t.</p><p>This week, a GitHub discussion around Tailwind’s documentation (about adding an llms.txt endpoint for LLM-friendly docs) unexpectedly highlighted the fragility of that setup. In that thread, Tailwind’s creator described docs traffic being down significantly since early 2023, revenue being down sharply even while the framework remains popular, and a major reduction in engineering headcount. (c.f. <a href="https://github.com/tailwindlabs/tailwindcss.com/pull/2388">https://github.com/tailwindlabs/tailwindcss.com/pull/2388</a>)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vNw5U0ZnS39F8alERg6ang.png" /><figcaption>The original message of the creator of Tailwind mentionning various issues regarding LLMs</figcaption></figure><p>I’m not bringing this up to predict doom. Tailwind is widely used and not “going away tomorrow.”</p><p>I’m bringing it up because it clarifies the <em>risk profile</em> of adopting a framework-level styling layer:</p><ul><li>If Tailwind’s development slows, you can’t just “swap it out”.</li><li>Your markup is full of Tailwind’s vocabulary.</li><li>And if you leaned into @apply, even your CSS is now Tailwind-dependent.</li></ul><p>So the exit cost isn’t “rewrite some styles”. It’s <strong>rewrite markup, retrain habits, rebuild constraints, and reestablish a design system</strong>.</p><p>With native CSS, you can still make bad architecture choices , but at least you’re building on the platform’s most stable contract. If tomorrow you change approaches, your code doesn’t stop compiling because a tooling layer changed shape.</p><h3>The practical pain points (from actually using it)</h3><p>Here’s what bothered me in real projects, beyond vibes.</p><h4>1) “Content gets buried”</h4><p>When class lists get long, the actual content becomes harder to scan. This is a real maintenance cost: editing copy, reviewing diffs, reading templates, doing quick refactors.</p><p>If your workflow depends on “fold all classes” plugins, that’s a signal. Not necessarily a deal breaker, but a signal.</p><h4>2) You start needing tooling to keep it readable</h4><p>Tailwind is amazing with good tooling:</p><ul><li>class autocomplete</li><li>sorting</li><li>linting</li><li>folding</li><li>component extraction patterns</li></ul><p>Without that, it can feel like typing encrypted abbreviations.</p><p>Again: not fatal, just friction.</p><h4>3) It nudges you toward breakpoint-heavy design</h4><p>This one is subtle, and it depends on how you write CSS.</p><p>A really common Tailwind style is: sm:, md:, lg: everywhere.</p><p>That works, but it can also push you into “design at breakpoints” instead of building layouts that are fluid by default.</p><p>To be clear: Tailwind can do fluid layouts. But the path of least resistance often becomes breakpoint choreography.</p><h4>4) The “escape hatch” problem</h4><p>Tailwind is great until you hit something that doesn’t map nicely to utilities.</p><p>At that point you either:</p><ul><li>write custom CSS anyway</li><li>use arbitrary values</li><li>create weird utility combos</li><li>reach for plugins</li><li>or accept something “close enough”</li></ul><p>I don’t even mind mixing. The web is messy. But if I’m going to write CSS anyway, I start asking: why am I also maintaining a second styling language?</p><h3>“But you can just use @apply”</h3><p>A lot of Tailwind discussions end with:</p><p>“Just extract components.” or “Just use @apply.”</p><p>And you can. The issue is what you’re extracting into.</p><p>@apply is not CSS. It’s Tailwind syntax that requires Tailwind in your build pipeline. If you remove Tailwind, those styles break.</p><p>This is where Tailwind starts to feel less like “CSS helpers” and more like adopting a framework.</p><p>That’s fine. Frameworks are normal. I just prefer when my styling layer stays as close as possible to the platform.</p><h3>My honest reason: I like CSS as a language</h3><p>This is the part that gets misread as elitism, so let me say it plainly:</p><p>I don’t avoid Tailwind because I think Tailwind users are wrong.<br>I avoid Tailwind because I enjoy writing CSS, and modern CSS has become extremely capable.</p><p>I like:</p><ul><li>custom properties as real design tokens</li><li>cascade layers to keep priorities predictable</li><li>container queries for component-level responsiveness</li><li>newer selectors and pseudo-classes</li><li>small utilities that I control</li><li>debugging styles in DevTools as actual CSS rules, not a long list of class mappings</li></ul><p>Tailwind can coexist with modern CSS, but it’s still an abstraction layer. And when you already know the base language well, abstractions have to earn their place.</p><h3>The part people really want: “Okay, what do you do instead?”</h3><p>I try to steal Tailwind’s best idea (constraints) without adopting Tailwind’s whole approach.</p><p>Here’s the pattern:</p><h4><strong>1 ) Design tokens in CSS, not JS</strong></h4><p>Instead of a Tailwind config defining spacing and colors, I define tokens using custom properties:</p><pre>:root {<br>  /* spacing scale */<br>  --space-1: 0.25rem;<br>  --space-2: 0.5rem;<br>  --space-3: 0.75rem;<br>  --space-4: 1rem;<br>  --space-6: 1.5rem;<br>  --space-8: 2rem;<br><br>  /* colors */<br>  --bg: #f6f0e8;<br>  --text: #111;<br>  --accent: #1f6b55;<br>}</pre><p>This gets me the “designing with constraints” benefit, but it stays native.</p><h4>2) A tiny set of utilities that I actually use</h4><p>I’m not against utilities. I’m against importing 10,000 of them by default.</p><p>So I’ll define a few:</p><pre>.stack {<br>  display: grid;<br>  gap: var(--space-4);<br>}<br><br>.card {<br>  border: 2px solid var(--text);<br>  border-radius: 12px;<br>  padding: var(--space-6);<br>  background: var(--bg);<br>}</pre><p>Now my HTML is readable again:</p><pre>&lt;section class=&quot;stack&quot;&gt;<br>  &lt;article class=&quot;card&quot;&gt;<br>    &lt;h2&gt;Title&lt;/h2&gt;<br>    &lt;p&gt;Text&lt;/p&gt;<br>  &lt;/article&gt;<br>  ....<br>&lt;/section&gt;</pre><h4>3) Use CSS for the relationships Tailwind struggles with</h4><p>Tailwind is great at styling an element. CSS is great at styling relationships.</p><p>Parent state, sibling relationships, component structure, “if this exists then style that”, fluid layouts, container-driven behaviour.</p><p>This is why I keep coming back to CSS. The language keeps getting better at exactly the kinds of things that used to be Tailwind’s sweet spot.</p><h3>When Tailwind absolutely makes sense</h3><p>If you read this as “Tailwind bad”, you missed the point.</p><p>Tailwind is a great choice when:</p><ul><li>you have a product team and need consistent UI fast</li><li>you want onboarding to be easy (many devs know Tailwind now)</li><li>you want a default design system with strong guardrails</li><li>you build mostly inside component frameworks where markup readability matters less than component boundaries</li><li>you don’t want to spend time building and maintaining a CSS architecture</li></ul><p>It can also be a solid bridge for devs who feel lost in CSS, because its docs + constraints teach styling patterns indirectly.</p><h3>Why I still don’t use it</h3><p>If I had to summarise my position in one sentence:<br>I want Tailwind’s constraints, but I want them in native CSS, with readable HTML, and without adopting a second styling Domain-Specific Language.</p><p>That’s it.</p><p>Tailwind solves real problems. It just solves them in a way that makes my code feel less like the web platform and more like a framework language.</p><p>If that trade-off is worth it for you, use it. Seriously.</p><p>If you’re on the fence, my suggestion is boring but honest: try both approaches on a real project, then pick the one that makes you move faster without hating your codebase three months later.</p><h3>Support My Work</h3><p>Feel free to leave your comments or questions.<br>If you found this article helpful, please share it with your peers.</p><p>If you want more content from me, you can go <a href="https://theosoti.com/">directly on my blog</a>.<br>I also created a <a href="https://theosoti.com/email-course/">7-day email course</a> to learn more about modern CSS.</p><p>Happy coding!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8df75eeb0bd6" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>