Essential CSS
JavaScript Roadmap
Learn JavaScript
Mastering Web Typography
Practical Astro
Understanding Async JS
Unorthodox Tailwind
API Masterclass
Build and Deploy
The Beginner Freelancer
Real World Node
Profile Billing Logout
Unorthodox Tailwind
Lesson Plan
  1. Introduction
    1. Introduction
    2. What Tailwind brings to the table
    3. Tailwind: The Good and The Bad
    4. The First and Most Important Step
    5. Simple Unorthodox System
    6. The System I Use
  2. Tailwind Fundamentals
    1. Introduction
    2. Installing Tailwind
    3. Using Tailwind utilities
    4. Understanding Tailwind’s utility system
    5. Understanding Tailwind values
    6. Understanding Tailwind variants
  3. Unorthodox Fundamentals
    1. Introduction
    2. Making Simple Tailwind Utilities
    3. Components vs Utilities
    4. Specificity, Cascade, and CSS Layers
    5. Debugging Tailwind Styles
    6. Composable Utility System
    7. Create lots of components
  4. Layouts System
    1. Tailwind is great for layouts
    2. Four Types of Layouts
    3. Building Shell Layouts
    4. Building Macro Layouts
    5. Better Responsive Variants
    6. A collection of maximum widths
    7. A note on grid wrappers
    8. Working with sections
    9. Building Micro Layouts
    10. Positioning Layouts
  5. Typography System
    1. Introduction
    2. A system for using multiple typefaces
    3. Tailwind's font-size system
    4. Finding your font-size system
    5. My font-size system
    6. A simple responsive typography system
    7. The main body
    8. Vertical rhythm
  6. Theming System
    1. Introduction
    2. Tailwind's colour system
    3. The pigment system
    4. Tailwind's gradient system
    5. A friendlier gradient system
    6. Handling SVG fill and stroke
    7. Improving Tailwind's colour palette
    8. A simple way to theme
  7. Useful Tools
    1. Introduction
    2. Making functional utilities
    3. Custom variants
    4. Scaffolding tools
    5. Extending Tailwind
  8. Effects System
    1. Introduction
    2. Vertical text
    3. Strikethrough text
    4. Text stroke
    5. Highlighting text
    6. Nicer shadows
    7. Transitioning shadows
    8. Drop shadows
    9. Dark mode tricks
    10. Gradient borders
    11. More effects to explore
  9. Putting Everything Together
    1. The Unorthodox Tailwind process
    2. The 4 systems combined
    3. Create components liberally
    4. Advanced tips
    5. My CSS Structure
    6. A Cheatsheet
    7. Consolidating your thoughts
    8. Parting words

Create components liberally

2m:44s

I really mean it when I told you to create components liberally in an earlier lesson.

The idea is to make things easy for you by creating reusable “functions” or code pieces that you can plonk and use easily with a few variables here and there.

I call that writing higher-level CSS.

That is because when CSS is written in a way that is understandable and quick to apply, we don’t have to dive into the nitty-gritty details and spend our time there.

This is why I create components at every opportunity — so I don’t have to go through the grind of writing smaller utilities one-by-one when they can be re-used.

Now let me dive a little bit deeper into this concept.

Two ways to create components

The two ways are:

  1. Make a CSS component
  2. Make a framework component file

Making a CSS Component

Whenever writing Tailwind classes in the HTML becomes clunky, I almost always create a CSS component file. These components are what you’d expect. Examples of these include accordions, tabs, pricing cards, etc.

Their purpose is to store groups of styles that are similar to each other. So you’ll have an easier time finding them.

css components example

I’m using “utility” and “component” interchangeably here because they mean the same thing in this system.

It doesn’t matter whether you choose a @utility or a .class. But if you want some rules, I would choose @utility over .class if:

  1. I want to @apply the utility later
  2. I don’t want the utility to show up in my CSS unless it is used

Since I’d use almost everything I build on a site, it doesn’t really matter whether I build components with utilities or classes. But when I build a library (like Splendid Styles), I use @utility.

Component File

Component files are files that house the HTML for a component. One for an accordion might look like this:

<div class="accordion">
<h3>
<button> <!-- header goes here --> </button>
<svg> <!-- svg icon --> </svg>
</h3>
<div class="accordion-content">
<!-- content goes here -->
<slot />
</div>
</div>

I use my utilities in these framework files as well. But I have no problems transferring more complex declarations into a CSS component file.

An example here is a pricing plan card. It might contain stuff that’s too complex to recreate multiple times. But simple enough if we encase it into a component.

<!-- Pseudo code makes more sense here as an example -->
<div class="pricing-card">
<!--recommended tag -->
<!--price -->
<!--discounted price -->
<!--title -->
<!--items -->
<!--link to purchase -->
</div>

Common gotcha when building component files with Tailwind

Tailwind needs the entire utility name + value written as one string. It cannot contain variables mid-string.

// doesn't work
const theme = 'yellow'
const color = `text-${theme}-500`

To circumvent this, you might want to create a theme map for your component. Then extract the necessary classes from it.

// works
const theme = 'yellow'
const themes = {
yellow: {
bg: 'bg-yellow-50',
text: 'text-yellow-900',
},
// other themes ...
}
// Then you can use your values like this:
const chosenTheme = themes[theme]
const { bg, text } = chosenTheme