Category: Claude

Last week, I watched Claude make the exact same mistake I’d corrected three days earlier.

Same project. Same codebase. Same error.

I’d spent fifteen minutes explaining why we use prepared statements for database queries—not string concatenation. Claude understood. Claude apologized. Claude fixed it beautifully.

And then, in a fresh session, Claude did it again. Like our conversation never happened.

Here’s the thing: it wasn’t Claude’s fault.

(Stay with me.)

The correction I’d made? It lived and died in that single session. I never added it to my Claude Code rules. Never updated my project guidelines. Never captured what we’d learned together.

So Claude forgot. Because Claude had to forget.

And honestly? I’ve done this more times than I’d like to admit.

.

.

.

The Uncomfortable Truth About Your Claude Code Rules

You’ve probably got project rules somewhere.

Maybe in a CLAUDE.md file. Maybe in a markdown doc you include at the start of sessions. Maybe scrawled on a Post-it note stuck to your monitor.

(No judgment.)

These rules matter.

They’re the guardrails that keep Claude from hallucinating, making mistakes, or generating code that looks like it was written by someone who’s never seen your codebase before.

But here’s what nobody talks about: most Claude Code rules are frozen in time.

You wrote them once—probably when you were optimistic and caffeinated and full of good intentions. Maybe you updated them once or twice when something broke spectacularly. And then… they fossilized.

Meanwhile, you’re out there learning. Every session teaches you something. Better patterns. Sneaky edge cases. Production bugs that made you question your life choices at 2am.

But none of that learning makes it back into your rules.

Your rules stay stuck at whatever understanding you had on Day One. A Level 5 Charmander trying to fight Level 50 battles.

(More on Pokémon in a minute. I promise this metaphor is going somewhere.)

.

.

.

The Three Problems That Keep Your Rules Stuck

Let me break down why this happens—because understanding the problem is half the battle.

Problem #1: The Inclusion Tax

You have to remember to add your rules file at the start of every session. Miss it once—maybe you’re rushing, maybe you’re excited about a feature, maybe you just forgot—and suddenly you’re debugging code that violates your own standards.

It’s like having a gym membership you forget to use. The potential is there. The execution… less so.

Problem #2: Context Decay

Even when you do include your rules, long sessions dilute them. By message #50, your carefully crafted “always use prepared statements” guideline has degraded into… whatever Claude feels like doing.

The rules are still technically in the context window. They’re just competing with 47 other messages for Claude’s attention. And losing.

Here’s what that looks like:

Problem #3: The Maintenance Black Hole

Rules should evolve. You know this. I know this. We all know this.

But who actually updates their rules file regularly?

(I’m raising my hand here too. We’re in this together.)

.

.

.

The CLAUDE.md Trap

Here’s what most developers do—and I get why it seems logical:

They cram everything into CLAUDE.md.

Security rules. Database patterns. API conventions. Coding standards. Error handling preferences. That one weird edge case from six months ago. All of it, stuffed into one giant file that gets loaded at the start of every session.

The thinking makes sense: “Claude will always have my rules!”

The reality?

A 2,000-line CLAUDE.md file burns through your token limits before you even start working.

You’re paying the context tax on every single message—whether you need those rules or not. Working on a simple UI tweak? Still loading all your database migration patterns. Fixing a typo? Still burning tokens on your entire security playbook.

It’s like packing your entire wardrobe for a weekend trip. Sure, you’ll have options. But you’ll also be exhausted before you get anywhere.

.

.

.

What If Your Rules Could Level Up?

Okay, here’s where the Pokémon thing comes in. (Told you I’d get there.)

Think about how evolution works in Pokémon. A Charmander doesn’t stay a Charmander forever. It battles. It gains experience. It evolves into Charmeleon, then Charizard. Each evolution makes it stronger, better suited for tougher challenges.

What if your Claude Code rules could work the same way?

Every correction you make.

Every “actually, do it this way instead” moment. Every hard-won insight from debugging at 2am. What if all of that could strengthen your rules automatically?

Not stuffed into a bloated CLAUDE.md. Not forgotten when sessions end. Actually captured and integrated into a system that gets smarter over time.

This is possible now. And it’s not even that complicated.

Enter Agent Skills (And Why They Change Everything)

If you haven’t explored Agent Skills yet, here’s the short version: Skills let Claude activate knowledge only when it needs it.

Instead of loading everything upfront—all 2,000 lines of your rules, whether relevant or not—Claude starts by reading just the skill descriptions. A few lines each. When a task triggers a specific skill, then it reads the full details.

Working on database queries? Claude loads the database skill. Building an API endpoint? It loads the API patterns. Simple UI change? It loads… just what it needs for that.

The token savings are significant. Instead of paying for your entire rulebook on every message, you pay for maybe 50 lines of descriptions, plus whatever specific reference you actually need.

But here’s where it gets interesting for our “evolving rules” problem…

The Card Catalog Architecture

Here’s the approach that solves all three problems we talked about earlier:

Structure your skill like a card catalog, not a library.

Your SKILL.md file becomes an index—brief descriptions pointing to reference files. The actual rules live in a references/ folder:

Instead of cramming everything into SKILL.md like this:

## Database Schema Rules
Always use snake_case for table names...
[50 more lines of database rules]

## Firebase Security Rules  
Auth patterns must follow...
[40 more lines of Firebase rules]

Your SKILL.md becomes a simple directory:

## Database Schema Rules
See: references/database.md
Guidelines for table naming, migrations, and schema patterns.

## Firebase Security Rules
See: references/security.md  
Authentication patterns and Firestore rules structure.

Why does this matter for evolution?

When you capture new insights, they go into the specific reference file—not bloating the main index. Your skill grows by expanding its reference library, not by inflating one massive file.

And when you pair this structure with the build-insights-logger skill? Your rules start updating themselves based on real learnings.

Your Charmander starts evolving.

.

.

.

Building Your Self-Evolving Skill: The Complete Walkthrough

Alright, let’s get practical. Here’s exactly how to set this up—step by step, with real screenshots from when I did this myself.

Step 1: Convert Your Existing Rules to an Indexed Skill

If you already have Claude Code rules somewhere (in CLAUDE.md, a rules file, or scattered notes), this is your starting point.

Here’s the prompt I used:

Convert the following project rules at @notes/rules.md into a live documentation skill using the "skill-creator" skill.

## Requirements

### 1. Skill Structure

Create a skill folder with this structure:

```
.claude/skills/[skill-name]/
    ├── SKILL.md           # Index file (card catalog, NOT the full library)
    ├── references/        # Detailed rule files
    │   ├── [category-1].md
    │   ├── [category-2].md
    │   └── ...
    └── [README.md](http://README.md)          # Optional: skill usage guide
```

### 2. SKILL.md Design (The Index)

The SKILL.md should act as a **card catalog**, not contain the full rules. 

Example:

```
[...content of SKILL.md...]

## Quick Reference

Brief overview of what this skill covers (2-3 sentences max).

## Rule Categories

### [Category 1 Name]

Brief description (1 line). See: `references/[category-1].md`

### [Category 2 Name]

Brief description (1 line). See: `references/[category-2].md`

[Continue for all categories...]

## When to Load References

- Load `references/[category-1].md` when: [specific trigger]
- Load `references/[category-2].md` when: [specific trigger]
```

### 3. Reference File Design

Each reference file in `references/` should:
- Focus on ONE category/domain of rules
- Include code examples where helpful
- Be self-contained (can be understood without reading other files)
- End with a "Quick Checklist" for that category

### 4. Evolvability

Structure the skill so new learnings can be easily added:
- Each reference file should have a `## Lessons Learned` section at the end (initially empty)
- The SKILL.md index should be easy to extend with new categories
- Use consistent formatting so automated updates are possible

## Notes

- Prioritize token efficiency: Claude should only load what it needs
- Keep SKILL.md under 100 lines if possible
- Each reference file should be focused (ideally under 200 lines)
- Use the indexed structure so the build-insights-logger can update specific reference files later

Two prerequisites before you run this:

• Install the “skill-creator” skill first
• Turn on Plan Mode (Shift+Tab)

Claude initiates the skill-creator and starts working:

It explores your codebase for existing patterns to follow. (I love watching this part—it’s like Claude doing research before diving in.)

In my case, Claude asked clarifying questions before finalizing the plan. This is Plan Mode doing its job—thinking before coding:

After answering, Claude proposed a complete plan:

The plan includes the SKILL.md design—notice how it acts as an index, not a container for all the rules:

I agreed to proceed with auto-accept edits. And here’s what Claude created:

The result:

• SKILL.md: 83 lines (the index/card catalog)
• 15 reference files, each under 200 lines
• Every reference file includes code examples, a Quick Checklist, and an empty Lessons Learned section

Those empty Lessons Learned sections? They’re intentional. That’s where the evolution happens.

👉 Don’t have existing rules to convert? You can ask Claude to analyze your codebase and extract patterns into a skill. Or check out my previous post on how to compile your own project rules first.

Step 2: Install the Build-Insights-Logger

This is the skill that captures learnings during your sessions and routes them to the right place.

/plugin marketplace add nathanonn/claude-skill-build-insights-logger

GitHub repo: https://github.com/nathanonn/claude-skill-build-insights-logger

(Yes, I built this. Yes, I’m biased. But it solves a real problem.)

Step 3: Work Like You Normally Would

Here’s the beautiful part: you don’t need to change how you work.

With your skill installed and the insights logger ready, just… build. Code. Debug. Do your thing.

I’ll show you what this looks like. I asked Claude to audit my WordPress plugin for security vulnerabilities:

Claude found several issues, fixed them, and documented the changes. Standard stuff.

But here’s where it gets good.

After the implementation, I triggered the insights logger:

Please jot down what you have learned so far using the "build-insights-logger" skill.

Claude activated the skill:

And logged 6 insights from the session:

Six insights. Automatically categorized. Saved to .claude/insights/session-2026-01-05-143600.md.

No manual documentation. No “I should write this down” that never happens. Just… captured.

Step 4: Review and Integrate (The Curation Step)

You can review immediately after one session, or batch multiple sessions together. I usually wait until I have a few sessions worth of insights—but that’s personal preference.

Here’s how to review:

Please use the "build-insights-logger" skill to review the insights logged so far.

Claude reads all session files and presents a summary organized by category:

Now here’s the critical part: don’t add everything.

This is where human judgment matters. Review each insight and ask: “Will this apply to future projects, or is it specific to this one-off feature?”

Some insights are gold. Some are situational. You’re the curator here.

I selected insights 1, 2, 5, and 6—the ones that generalize across WordPress projects:

Important detail: Notice my instruction. By default, the build-insights-logger updates CLAUDE.md. I explicitly redirected it to update the skill instead, with a reminder to keep SKILL.md clean—insights should go to the relevant reference files, not the index.

Claude reads the relevant reference files and adds the insights where they belong:

The result:

4 insights added to the skill:

• 3 security insights → references/security.md
• 1 lifecycle insight → references/plugin-lifecycle.md

The session file gets archived. And your skill is now smarter than it was an hour ago.

.

.

.

What You Actually Built Here

Let’s step back for a second.

Four steps. That’s all it took:

1. Convert rules to an indexed skill
2. Install the insights logger
3. Build like normal
4. Review and integrate learnings

But what actually changed?

You’re no longer maintaining documentation. You’re growing a knowledge base.

Every correction you make—every “actually, do it this way instead” moment, every insight from debugging at 2am—the system captures it. You review it. The good stuff evolves your skill. Your next session starts with rules that reflect what you actually learned, not what you thought you knew when you started.

The gap between your experience and your documentation? It closes.

That mistake I mentioned at the beginning—Claude repeating an error I’d already corrected? It doesn’t happen anymore. Because the correction made it into my Claude Code rules. Automatically. As part of my normal workflow.

Your Charmander evolved into Charizard.

And it keeps evolving.

.

.

.

Your Turn

If you’ve been cramming rules into CLAUDE.md—or worse, keeping them in your head and hoping for the best—try this process on your next project.

Start with whatever rules you have. Even messy ones. (Especially messy ones, honestly.)

Convert them to an indexed skill. Install the insights logger. Build for a few sessions. Then review your insights folder.

You’ll be surprised at what Claude captured. And you’ll be amazed at how much smarter your rules become when they’re allowed to learn alongside you.

What project are you going to evolve first?

Go build it.

Now.

You’re deep in flow state.

Claude Code is humming along—building your Next.js app, spinning up components, mapping out API routes, sketching database schemas. It’s beautiful. It’s efficient. It’s everything you dreamed AI-assisted coding could be.

And then.

Allow Claude to run `npm install`? [y/n]

You press Enter.

Allow Claude to run `git status`? [y/n]

You press Enter.

Allow Claude to run `ls src/`? [y/n]

Enter. Enter. Enter. Enter. Enter.

By prompt #47, you’re not even reading anymore. You’re just… pressing Enter. Like a very tired seal at a circus act nobody asked for.

Here’s the thing: that permission system was designed to protect you. And instead? It’s training you to ignore it entirely.

Let’s fix that.

.

.

.

The Paradox Nobody Talks About

I want you to sit with this for a second—because it’s genuinely wild when you think about it.

Claude Code’s safety system was built with good intentions. Ask before every risky action. Sounds reasonable, right? Sounds responsible.

But here’s what actually happens in the wild:

The safety mechanism designed to protect you makes you less safe.

Anthropic’s own testing confirmed this. They call it “approval fatigue.” And their data showed developers hit it within the first hour of use.

(Within the first hour. Not after weeks of grinding. One. Hour.)

Sound familiar?

Yeah. I thought so.

.

.

.

The Fix: Boundaries, Not Babysitting

Here’s where Claude Code Sandbox comes in—and it flips the entire model on its head.

Instead of asking permission for every tiny thing (like an overly anxious intern double-checking if it’s okay to use the stapler), the sandbox draws clear boundaries upfront. Work freely inside them. Get blocked immediately outside them.

Think of it like giving Claude a room to work in—not the keys to the whole house.

Inside that room? Full autonomy. Zero prompts. Go nuts.

Outside that room? Blocked. Immediately. At the operating system level.

Two Invisible Walls

Here’s what the sandbox actually does:

Wall 1: Filesystem Isolation

Claude can only read and write inside your project directory. Everything else—your SSH keys, AWS credentials, shell config—is invisible. Not just “blocked.” Invisible. Like it doesn’t exist. (Which, for Claude’s purposes, it doesn’t.)

Wall 2: Network Isolation

All network traffic routes through a proxy that only allows approved domains. npm install needs registry.npmjs.org? You approve it once. Some sketchy postinstall script tries to phone home to evil.com? Blocked. Immediately. No drama.

Why This Actually Works (And Why It’s Different)

Stay with me here—because this is the part that matters.

These aren’t application-level restrictions. They’re operating system enforced.

On Linux, Claude Code uses Bubblewrap—the same tech that powers Flatpak. On macOS, it’s Seatbelt—the same tech that restricts iOS apps.

This means even if a malicious prompt injection tricks Claude into trying to read your SSH keys… it physically cannot. The kernel blocks it. Full stop.

Prompt injection can’t bypass OS-level security.

That’s the whole point. That’s what makes this different from “please be good” security theater.

.

.

.

Quick Start: 5 Minutes to Actual Protection

Alright. Enough theory. Let’s get you set up.

Step 1: Enable Sandbox

In Claude Code, type:

/sandbox

Select Auto-allow mode.

This is the sweet spot: sandboxed commands run automatically, unsandboxed actions still prompt you. Best of both worlds.

Step 2: Create Your Config

Create ~/.claude/settings.json:

{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": ["docker", "docker-compose"],
    "allowUnsandboxedCommands": true,
    "network": {
      "allowLocalBinding": true
    }
  },
  "permissions": {
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)"
    ]
  }
}

Step 3: Verify It’s Working

Run:

/permissions

You’ll see your active configuration.

Now test with a simple command:

> List files in the current directory

If it executes without prompting? Sandbox is working.

That’s it. OS-level protection with zero friction for normal work.

(I know, I know—it almost feels too easy. It’s not a trick. It just… works.)

.

.

.

Real-World Configurations You Can Steal

The basic setup handles most projects beautifully. But different stacks have different quirks.

Docker can’t run inside a sandbox. Dev servers need to bind ports. Private registries need network access. You know how it goes.

Here are three battle-tested configs. Find the one closest to your setup, copy-paste, adjust as needed.

Scenario 1: Web Development (Next.js, Vite, React)

The Problem: You run npm run dev inside sandbox and… nothing happens. On macOS, the sandbox blocks port binding by default. Your dev server can’t start. Cue frustration.

The Fix:

{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": [],
    "network": {
      "allowLocalBinding": true
    }
  },
  "permissions": {
    "allow": [
      "Bash(npm:*)",
      "Bash(npx:*)",
      "Bash(node:*)",
      "WebFetch(domain:registry.npmjs.org)"
    ],
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)"
    ],
    "ask": [
      "Bash(npm publish:*)",
      "Bash(git push:*)"
    ]
  }
}

What this does: allowLocalBinding: true fixes the macOS dev server issue. npm/npx/node commands run automatically (sandboxed). Your .env files stay invisible to Claude. And it still asks before publishing to npm or pushing to git—because those are the “are you really sure?” moments.

Zero prompts for normal work. Full protection. Still asks before the dangerous stuff.

Scenario 2: WordPress with Docker and wp-env

WordPress development is trickier. Tools like wp-env and docker-compose fundamentally don’t work inside a sandbox—Docker needs to talk to the Docker daemon through a Unix socket, and the sandbox blocks socket access.

The Fix:

{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": [
      "docker",
      "docker-compose",
      "wp-env"
    ],
    "network": {
      "allowLocalBinding": true
    }
  },
  "permissions": {
    "allow": [
      "Bash(php:*)",
      "Bash(composer:*)",
      "Bash(wp:*)",
      "WebFetch(domain:packagist.org)",
      "WebFetch(domain:wordpress.org)",
      "WebFetch(domain:api.wordpress.org)"
    ],
    "deny": [
      "Read(./.env)",
      "Read(./wp-config.php)",
      "Read(./wp-config-local.php)"
    ],
    "ask": [
      "Bash(docker:*)",
      "Bash(wp-env:*)"
    ]
  }
}

The trade-off: Docker runs unsandboxed. That’s less secure—I won’t pretend otherwise.

But here’s the thing: Docker commands still require your approval. And your actual code (PHP, composer, wp-cli) runs fully sandboxed. Claude never sees your wp-config.php with all those database credentials.

You’re protecting where it matters most.

Scenario 3: Maximum Paranoia Mode (Untrusted Code)

Reviewing a pull request from an unknown contributor? Auditing a dependency after a security advisory? This is when you want full lockdown.

The Config:

{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": false,
    "allowUnsandboxedCommands": false,
    "excludedCommands": [],
    "network": {
      "allowLocalBinding": false
    }
  },
  "permissions": {
    "allow": [],
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)",
      "Bash(curl:*)",
      "Bash(wget:*)",
      "Bash(nc:*)"
    ],
    "ask": [
      "Bash",
      "Edit",
      "WebFetch"
    ]
  }
}

What this does: Every command prompts—even sandboxed ones. No escape hatch. Common data exfiltration tools (curl, wget, nc) are explicitly blocked. Three walls, all OS-enforced.

Malicious README contains hidden instructions to steal your AWS credentials? Claude literally cannot read ~/.aws/. The kernel says no. End of story.

.

.

.

The YOLO Warning: Why This Actually Matters

Let me be direct with you for a second.

Running Claude Code without sandbox is genuinely risky. I’m not being dramatic—this is just the reality of how npm packages work.

Every npm package you install runs postinstall scripts with full access to your system. Every malicious prompt hidden in a README could trick Claude into reading your credentials. Every compromised dependency could phone home with your data.

“It probably won’t happen to me” is not a security strategy.

(It’s barely even a sentence.)

The Claude Code Sandbox isn’t paranoia. It’s basic hygiene. Like washing your hands. Like wearing a seatbelt. Like not storing passwords in a Google Doc called “passwords.txt.”

The 84% reduction in permission prompts? That’s nice. That’s a quality-of-life improvement. But the real win is protection that actually works—because it’s enforced at the kernel level, not just “Claude, please don’t do bad things.”

What Sandbox Doesn’t Protect

Let’s be honest about the limits, though. Sandbox protects your system files, SSH keys, AWS credentials, shell config, and network exfiltration.

It does not protect your project files from mistakes, defend against social engineering, or magically secure allowed domains.

The sandbox makes Claude safe to use autonomously. It doesn’t make you invincible.

👉 Use git. Review changes. Read prompts when they appear. (The ones that do appear now actually matter—which is kind of the whole point.)

.

.

.

Stop Configuring, Start Building

Here’s the thing about sandbox configuration:

every project is different. Next.js needs different settings than Django. WordPress with Docker needs different settings than a Python CLI tool.

Figuring out the right config for YOUR specific codebase? That’s tedious. That’s the kind of thing that makes you put it off until “later” (which, let’s be honest, means “never”).

So I built a tool to do it for you.

Introducing: Sandbox Architect

It’s a Claude Code skill that:

1. Analyzes your codebase — Detects your stack, package managers, frameworks, Docker usage, sensitive files
2. Asks smart questions — Only what it can’t figure out automatically
3. Generates your config — Tailored to YOUR project, ready to paste

No more reading documentation. No more guessing which domains you need. No more discovering your config is wrong when commands fail at the worst possible moment.

Install Sandbox Architect:

/plugin marketplace add nathanonn/claude-skills-sandbox-architect

After adding the marketplace, the sandbox-architect skill will be available for installation and will help you configure sandbox settings for your projects.

That’s it.

Next time you start a project, just ask:

> Help me configure sandbox settings for this project

Done. Configured. Protected. Back to building.

.

.

.

Your Next Steps

1. Run /sandbox and enable Auto-allow mode
2. Create your ~/.claude/settings.json using one of the configs above
3. Install Sandbox Architect for automatic configuration
4. Never press Enter 50 times again

The Claude Code Sandbox isn’t just a feature—it’s a fundamental shift in how you work with AI coding assistants. Boundaries instead of babysitting. Protection that works because physics says so, not because we asked nicely.

What project are you going to secure first?

Drop a comment below—I’d love to hear what you’re building.

Now go make something.

Here’s a confession…

My accounting app was giving me existential dread.

Not because of the numbers.

(Well, okay, sometimes because of the numbers.)

But because every time I opened it, I felt like I was staring at the digital equivalent of beige wallpaper.

You know that feeling, right? When your app works perfectly but has all the personality of a doctor’s waiting room?

Mine tracked profit and loss beautifully. Managed transactions like a champ. Did everything an accounting app should do. It was built with ShadCN UI—that clean, functional, utterly forgettable component library that makes every SaaS tool look like it came from the same factory.

It was the IKEA furniture of web apps.

Gets the job done.

Zero personality.

(Sorry, IKEA. I still love your chicken wings.)

.

.

.

Here’s the thing: I needed something that felt like mine.

Something with actual personality.

Something that made number-crunching feel less like detention and more like… well, still accounting, but prettier accounting. The kind where you actually want to open the app instead of avoiding it like that one friend who only calls when they need help moving.

Redesigning an entire app though?

That’s like deciding to repaint your house yourself.

Sounds doable until you’re standing there with a brush, realizing you need to paint Every. Single. Room. Every. Single. Wall. And somehow make them all match.

Unless…

(Stay with me here.)

What if you could redesign ONE room, capture that exact paint color and technique, then magically apply it everywhere else?

That’s exactly what I did with Claude Skills.

And friend, it changed everything.

.

.

.

The Thing We Don’t Talk About: Generic Design Syndrome

Look familiar?

That screenshot is my accounting dashboard.

Could be yours. Could be literally anyone’s. It’s the starter home of SaaS designs—functional, affordable, and identical to every other one on the block.

It’s not bad.

It’s just… there.

Like elevator music. Like hotel art. Like those conversations where someone asks “how are you?” and you say “fine” even though you’re absolutely not fine because your app looks like it was designed by a committee of robots who’ve never felt joy.

(Too dramatic? Maybe. But you’re still reading, aren’t you?)

Here’s the choice every developer faces—and it’s a lousy choice:

1. Use a component library → Fast to build, looks like everyone else’s
2. Design from scratch → Unique, but requires the time commitment of a second mortgage
3. Hire a designer → Professional, costs more than your monthly coffee budget (and that’s saying something)

But wait.

There’s a door number four that nobody talks about.

What if you could create a design system once—just once—turn it into a Claude Skill, and apply it everywhere automatically?

Let me show you how.

(Spoiler: It takes less time than your last Zoom call.)

.

.

.

Step 1: Let Claude Show You What’s Possible (5 Minutes)

I opened Claude Code and pointed it at my sad, slate dashboard.

The key move?

I used the frontend-design skill (you can download it from here) and asked for 5 completely different HTML variants.

Not tweaks. Not “make the blue slightly bluer.”

I wanted personality. Drama. Something that would make my accountant jealous.

(Do accountants get jealous of app designs? Let’s say yes.)

Claude Code immediately understood the assignment:

Look at these descriptions—each one a different personality:

• Neo-Brutalist: Like your app went to art school and came back wearing all black
• Glass Aurora: What happens when the Northern Lights become a UI (dreamy!)
• Editorial Mono: The New Yorker meets your dashboard
• Warm Minimal: Like a hygge hug for your data
• Dark Command: For when you want to feel like you’re hacking the Matrix while doing expense reports

Five completely different vibes.

From one prompt.

It’s like speed-dating for design systems. (Is that a thing? It should be a thing.)

Each one broke free from that typical AI-generated aesthetic we all recognize. You know the one—like someone asked a robot to paint a sunset.

I fell hard for the Glass Aurora variant.

Yes, it had that slightly AI-ish glassmorphism thing happening.

But those aurora gradients?

Chef’s kiss.

It was like my dashboard went to Iceland and came back enlightened.

.

.

.

Step 2: Make It Yours (2 Minutes of Pure Joy)

The Glass Aurora design only came in dark mode.

But I needed both themes because I’m one of those people who switches to light mode at 6 AM like a responsible adult.

(I switch back to dark mode by lunch. We all have our limits.)

Claude Code didn’t just invert the colors like a lazy Instagram filter:

Look at that attention to detail:

• Soft gradients from slate to purple/teal (not harsh, not boring)
• White glass panels with 60-75% opacity (visible but not overwhelming)
• Pastel backgrounds that don’t burn your retinas
• Subtle gradient borders for depth (the devil’s in the details, friend)

Perfect.

I had my design.

Now here’s where most people would start the tedious work of manually copying styles across 47 different components.

Don’t be most people.

.

.

.

Step 3: Turn Your Design Into Documentation (10 Minutes That Save Your Life)

I switched to Claude Web (it’s better for this documentation dance) and attached both HTML files:

My request was specific.

(Specificity is your friend here. Vague requests get vague results. It’s like ordering “food” at a restaurant.)

I need you to analyze the attached HTML files and create two comprehensive design system documents:

### Document 1: Complete Design Guidelines (Markdown)
### Document 2: Interactive Reference Style Guide (HTML)

## Requirements for Both Documents

### Analysis Phase
First, thoroughly analyze ALL attached HTML files to extract:
1. **All CSS variables and design tokens** (colors, spacing, shadows, radius, etc.)
2. **All typography patterns** (font families, sizes, weights, line heights)
3. **All component patterns** (buttons, cards, forms, navigation, etc.)
4. **All layout patterns** (grids, containers, multi-column layouts)
5. **All utility classes** (margins, padding, text alignment, colors)
6. **All interaction patterns** (hover states, transitions, animations)
7. **Responsive breakpoints and mobile patterns**
8. **Naming conventions and prefixes used**

---

## Document 1: Design Guidelines (Markdown)

Create a comprehensive markdown file named `design-guidelines-complete.md` that includes:

### 1. Introduction Section
- **Design Philosophy**: Extract and articulate the design principles evident in the HTML
- **Key Characteristics**: What makes this design system unique
- **When to Use**: Guidance on appropriate use cases

### 2. Design Tokens
Complete CSS variable documentation with:
```css
:root {
    /* Extract ALL CSS variables from the HTML files */
    /* Group by category: colors, spacing, radius, shadows, etc. */
    /* Include comments describing each token */
}
```

### 3. Typography System
- Font family stack
- Complete typography scale table with:
  - Element/Use Case
  - Font Size
  - Font Weight
  - Color
  - Line Height
- Typography utility classes with code examples

### 4. Component Classes
Document EVERY component found in the HTML files with:
- Class name and purpose
- Complete CSS code
- Variants (if applicable)
- Usage notes

Organize by category:
- **Layout** (containers, grids, columns)
- **Cards** (all card variations)
- **Buttons** (all button types and states)
- **Forms** (inputs, textareas, selects, labels, file uploads)
- **Navigation** (navbar, links, menus)
- **Content Components** (articles, lists, chat bubbles, etc.)
- **UI Elements** (badges, tags, status indicators)
- **Specialized Components** (search bars, CTAs, heroes, sidebars)

### 5. Utility Classes
Complete list of utility classes for:
- Spacing (margins, padding)
- Typography (alignment, colors, weights)
- Display (flex, grid)
- Visibility
- Other utilities

### 6. Responsive Design
- Breakpoints used
- Mobile-first patterns
- Responsive grid behaviors
- Mobile-specific overrides

### 7. Animation & Transitions
- Timing functions
- Duration standards
- Transition patterns for different element types

### 8. Usage Examples
For each major component type, provide:
- Clean, minimal HTML example
- Real-world usage scenario
- Multiple examples showing variants

### 9. Accessibility Guidelines
- Color contrast requirements
- Focus states
- Semantic HTML recommendations
- Keyboard navigation notes
- ARIA considerations

### 10. Best Practices
- Implementation guidelines
- Common patterns
- Things to avoid
- Performance considerations

### 11. Additional Sections (if relevant)
- Color usage guidelines
- Icon/emoji usage
- Spacing scale
- Shadow elevation system

---

## Document 2: Reference Style Guide (HTML)

Create a comprehensive, interactive HTML file named `reference-styleguide-complete.html` that includes:

### Structure Requirements

1. **Self-Contained**: All CSS inline in a `<style>` tag
2. **Complete Design Tokens**: Include ALL CSS variables extracted from source files
3. **Live Examples**: Working, interactive examples of every component
4. **Organized Sections**: Clear sections with headers for each component category

### Required Sections

#### Header/Navigation
- Working navigation example from the source files

#### Color Palette Section
- Visual swatches for all colors
- Hex codes displayed
- Color names/variable names
- Organized by category (primary, secondary, neutrals, etc.)

#### Typography Section
- Live examples of every heading level
- Body text examples
- All typography variants demonstrated
- Labels, captions, meta text

#### Button Section
Demonstrate:
- All button variants (primary, secondary, outline, etc.)
- All sizes (small, medium, large)
- All states (normal, hover-able)
- Special buttons (pill, block, icon buttons)
- Button groups (if applicable)

#### Card Section
Show examples of:
- Basic cards
- Card variants (large, compact, etc.)
- Category cards
- Interactive cards with hover states
- Cards in grid layouts

#### Form Section
Include working examples of:
- Text inputs
- Textareas
- Select dropdowns (with custom styling)
- Checkboxes and radios (if in source)
- File uploads
- Input groups
- Form validation states (if applicable)
- Complete form layout example

#### Layout Section
Demonstrate:
- Container widths
- Grid systems
- Multi-column layouts
- Responsive behavior examples

#### Component Sections
For EVERY component found in source files, create a demo section:
- Search bars
- Navigation menus
- Article lists
- Chat interfaces
- Status badges
- Tabs/Pills (if applicable)
- Modals/Dialogs (if applicable)
- Tables (if applicable)
- Pagination (if applicable)
- Breadcrumbs (if applicable)
- And any other unique components

#### Utility Classes Section
Demonstrate utility classes with before/after examples

### Styling for the Style Guide Itself

Create a clean, professional layout for the style guide:
```css
.demo-section {
    /* Section container styling */
}

.demo-header {
    /* Section header styling - make it distinctive */
}

.demo-content {
    /* Content area styling */
}

.color-swatch {
    /* Color display boxes */
}
```

### Footer
- Notes about class prefixes
- Link to design guidelines
- Version information (if applicable)

---

## Output Format

Provide both files as downloadable outputs:
1. `/mnt/user-data/outputs/design-guidelines-complete.md`
2. `/mnt/user-data/outputs/reference-styleguide-complete.html`

---

## Quality Checklist

Before completing, ensure:

### Design Guidelines (MD)
- [ ] All CSS variables extracted and documented
- [ ] Every component class has complete CSS code
- [ ] At least 3-5 usage examples per major component
- [ ] Typography scale is complete with all variants
- [ ] Responsive patterns documented
- [ ] Accessibility guidelines included
- [ ] Best practices section is actionable

### Reference Style Guide (HTML)
- [ ] File opens and displays correctly in browser
- [ ] All colors displayed with swatches and codes
- [ ] Every component from source files is demonstrated
- [ ] Interactive elements work (hover states visible)
- [ ] Forms are functional (inputs accept text, etc.)
- [ ] Layout is clean and organized
- [ ] Sections are clearly labeled
- [ ] Self-contained (no external dependencies)

---

## Additional Instructions

1. **Be Thorough**: Don't skip any components, even small ones
2. **Extract Patterns**: If you see a pattern repeated, create a documented component for it
3. **Maintain Consistency**: Use the same class naming conventions from the source
4. **Provide Context**: Explain WHEN and WHY to use each component
5. **Think Developer-First**: Make it easy to copy-paste and implement
6. **Include Edge Cases**: Show how components look with long text, empty states, etc.

---

## Example Usage

After receiving these documents, a developer should be able to:
1. Understand the entire design system philosophy
2. Find any component they need with working code
3. Copy-paste implementation examples
4. See visual examples of every component
5. Understand responsive behavior
6. Know accessibility requirements
7. Follow best practices for implementation

---

Begin by analyzing all attached HTML files, then create both comprehensive documents.

I need you to analyze the attached HTML files and create two comprehensive design system documents:

### Document 1: Complete Design Guidelines (Markdown)
### Document 2: Interactive Reference Style Guide (HTML)

## Requirements for Both Documents

### Analysis Phase
First, thoroughly analyze ALL attached HTML files to extract:
1. **All CSS variables and design tokens** (colors, spacing, shadows, radius, etc.)
2. **All typography patterns** (font families, sizes, weights, line heights)
3. **All component patterns** (buttons, cards, forms, navigation, etc.)
4. **All layout patterns** (grids, containers, multi-column layouts)
5. **All utility classes** (margins, padding, text alignment, colors)
6. **All interaction patterns** (hover states, transitions, animations)
7. **Responsive breakpoints and mobile patterns**
8. **Naming conventions and prefixes used**

---

## Document 1: Design Guidelines (Markdown)

Create a comprehensive markdown file named `design-guidelines-complete.md` that includes:

### 1. Introduction Section
- **Design Philosophy**: Extract and articulate the design principles evident in the HTML
- **Key Characteristics**: What makes this design system unique
- **When to Use**: Guidance on appropriate use cases

### 2. Design Tokens
Complete CSS variable documentation with:
```css
:root {
    /* Extract ALL CSS variables from the HTML files */
    /* Group by category: colors, spacing, radius, shadows, etc. */
    /* Include comments describing each token */
}
```

### 3. Typography System
- Font family stack
- Complete typography scale table with:
  - Element/Use Case
  - Font Size
  - Font Weight
  - Color
  - Line Height
- Typography utility classes with code examples

### 4. Component Classes
Document EVERY component found in the HTML files with:
- Class name and purpose
- Complete CSS code
- Variants (if applicable)
- Usage notes

Organize by category:
- **Layout** (containers, grids, columns)
- **Cards** (all card variations)
- **Buttons** (all button types and states)
- **Forms** (inputs, textareas, selects, labels, file uploads)
- **Navigation** (navbar, links, menus)
- **Content Components** (articles, lists, chat bubbles, etc.)
- **UI Elements** (badges, tags, status indicators)
- **Specialized Components** (search bars, CTAs, heroes, sidebars)

### 5. Utility Classes
Complete list of utility classes for:
- Spacing (margins, padding)
- Typography (alignment, colors, weights)
- Display (flex, grid)
- Visibility
- Other utilities

### 6. Responsive Design
- Breakpoints used
- Mobile-first patterns
- Responsive grid behaviors
- Mobile-specific overrides

### 7. Animation & Transitions
- Timing functions
- Duration standards
- Transition patterns for different element types

### 8. Usage Examples
For each major component type, provide:
- Clean, minimal HTML example
- Real-world usage scenario
- Multiple examples showing variants

### 9. Accessibility Guidelines
- Color contrast requirements
- Focus states
- Semantic HTML recommendations
- Keyboard navigation notes
- ARIA considerations

### 10. Best Practices
- Implementation guidelines
- Common patterns
- Things to avoid
- Performance considerations

### 11. Additional Sections (if relevant)
- Color usage guidelines
- Icon/emoji usage
- Spacing scale
- Shadow elevation system

---

## Document 2: Reference Style Guide (HTML)

Create a comprehensive, interactive HTML file named `reference-styleguide-complete.html` that includes:

### Structure Requirements

1. **Self-Contained**: All CSS inline in a `<style>` tag
2. **Complete Design Tokens**: Include ALL CSS variables extracted from source files
3. **Live Examples**: Working, interactive examples of every component
4. **Organized Sections**: Clear sections with headers for each component category

### Required Sections

#### Header/Navigation
- Working navigation example from the source files

#### Color Palette Section
- Visual swatches for all colors
- Hex codes displayed
- Color names/variable names
- Organized by category (primary, secondary, neutrals, etc.)

#### Typography Section
- Live examples of every heading level
- Body text examples
- All typography variants demonstrated
- Labels, captions, meta text

#### Button Section
Demonstrate:
- All button variants (primary, secondary, outline, etc.)
- All sizes (small, medium, large)
- All states (normal, hover-able)
- Special buttons (pill, block, icon buttons)
- Button groups (if applicable)

#### Card Section
Show examples of:
- Basic cards
- Card variants (large, compact, etc.)
- Category cards
- Interactive cards with hover states
- Cards in grid layouts

#### Form Section
Include working examples of:
- Text inputs
- Textareas
- Select dropdowns (with custom styling)
- Checkboxes and radios (if in source)
- File uploads
- Input groups
- Form validation states (if applicable)
- Complete form layout example

#### Layout Section
Demonstrate:
- Container widths
- Grid systems
- Multi-column layouts
- Responsive behavior examples

#### Component Sections
For EVERY component found in source files, create a demo section:
- Search bars
- Navigation menus
- Article lists
- Chat interfaces
- Status badges
- Tabs/Pills (if applicable)
- Modals/Dialogs (if applicable)
- Tables (if applicable)
- Pagination (if applicable)
- Breadcrumbs (if applicable)
- And any other unique components

#### Utility Classes Section
Demonstrate utility classes with before/after examples

### Styling for the Style Guide Itself

Create a clean, professional layout for the style guide:
```css
.demo-section {
    /* Section container styling */
}

.demo-header {
    /* Section header styling - make it distinctive */
}

.demo-content {
    /* Content area styling */
}

.color-swatch {
    /* Color display boxes */
}
```

### Footer
- Notes about class prefixes
- Link to design guidelines
- Version information (if applicable)

---

## Output Format

Provide both files as downloadable outputs:
1. `/mnt/user-data/outputs/design-guidelines-complete.md`
2. `/mnt/user-data/outputs/reference-styleguide-complete.html`

---

## Quality Checklist

Before completing, ensure:

### Design Guidelines (MD)
- [ ] All CSS variables extracted and documented
- [ ] Every component class has complete CSS code
- [ ] At least 3-5 usage examples per major component
- [ ] Typography scale is complete with all variants
- [ ] Responsive patterns documented
- [ ] Accessibility guidelines included
- [ ] Best practices section is actionable

### Reference Style Guide (HTML)
- [ ] File opens and displays correctly in browser
- [ ] All colors displayed with swatches and codes
- [ ] Every component from source files is demonstrated
- [ ] Interactive elements work (hover states visible)
- [ ] Forms are functional (inputs accept text, etc.)
- [ ] Layout is clean and organized
- [ ] Sections are clearly labeled
- [ ] Self-contained (no external dependencies)

---

## Additional Instructions

1. **Be Thorough**: Don't skip any components, even small ones
2. **Extract Patterns**: If you see a pattern repeated, create a documented component for it
3. **Maintain Consistency**: Use the same class naming conventions from the source
4. **Provide Context**: Explain WHEN and WHY to use each component
5. **Think Developer-First**: Make it easy to copy-paste and implement
6. **Include Edge Cases**: Show how components look with long text, empty states, etc.

---

## Example Usage

After receiving these documents, a developer should be able to:
1. Understand the entire design system philosophy
2. Find any component they need with working code
3. Copy-paste implementation examples
4. See visual examples of every component
5. Understand responsive behavior
6. Know accessibility requirements
7. Follow best practices for implementation

---

Begin by analyzing all attached HTML files, then create both comprehensive documents.

Claude didn’t just list colors and fonts like a paint chip catalog.

It created a complete design philosophy:

Look at that structure—it’s like a love letter to your future self:

• Design philosophy (the WHY behind your choices)
• Design tokens (the WHAT of your system)
• Typography system (how words should dance)
• Component classes (the building blocks)
• Utility classes (your Swiss Army knife)
• Responsive patterns (because phones exist)
• Animation guidelines (movement with meaning)
• Usage examples (show, don’t just tell)
• Accessibility guidelines (because everyone deserves pretty apps)
• Best practices (learned the hard way so you don’t have to)

This isn’t documentation.

This is your design DNA.

The interactive reference was even better:

Live examples! Real components! Interactive demos!

It’s like having a tiny designer living in your computer.

(But less expensive and doesn’t judge your font choices.)

.

.

.

Step 4: Package Your Magic Into a Claude Skill (5 Minutes to Immortality)

Here’s where we turn stone into gold. Or design into reusable superpower.

(Same thing, really.)

Still in Claude Web, I asked:

Claude got it immediately:

Watch what’s happening—it’s like watching someone pack for a trip, but instead of forgetting their toothbrush, they remember everything:

• Reading the skill-creator documentation
• Understanding how to package design systems
• Checking reference patterns
• Organizing files with the care of Marie Kondo

The result:

Your skill package contains:

• SKILL.md (~300 lines of pure implementation wisdom)
• references/design-tokens.md (~1,900 lines of every design variable you’ll ever need)
• assets/template.html (~1,200 lines of interactive component library goodness)

Everything Claude Code needs to apply your design system to ANY component. It’s like having a design degree in a ZIP file.

.

.

.

Step 5: Installation Is So Easy It Feels Like Cheating (2 Minutes)

I downloaded the skill and added it to my project:

That’s it. That’s the installation process.

If you were expecting more steps, sorry to disappoint. Sometimes good things are simple.

(Unlike my relationship with CSS, which remains complicated.)

.

.

.

Step 6: Watch the Magic Happen (10 Minutes of Pure Satisfaction)

Back in Claude Code, I typed the magic words:

Claude recognized my skill immediately, like bumping into an old friend:

Then it went to work.

And friend, watching this is better than those satisfying pressure-washing videos:

Claude Code wasn’t just slapping styles around like a drunk painter.

It was methodical. Thoughtful. It:

• Read every component in the dashboard (getting to know the neighborhood)
• Understood the existing structure (respecting what was there)
• Mapped design patterns to components (matchmaking at its finest)
• Applied the Glass Aurora system consistently (no component left behind)

The transformation touched everything:

1. dashboard-client.tsx – Header, glass buttons, financial cards (the main stage)
2. dashboard-filters-bar.tsx – Glass-card container, themed filters (the supporting cast)
3. income-expense-chart-widget.tsx – Glass-card with gradient backgrounds (data, but make it fashion)
4. category-breakdown-chart-widget.tsx – Theme-aware chart colors (coordination is key)
5. accounts-overview-widget.tsx – Glass tooltips and grid layouts (the finishing touches)

Every. Single. Component.

Speaking the same design language.

Like a well-rehearsed choir instead of karaoke night at the dive bar.

The transformation?

From “generic SaaS tool #47,293” to “wait, what app is that and where can I get it?”

From forgettable to memorable.

From IKEA furniture to custom-built beauty.

And here’s the kicker: I can now redesign any page in seconds.

Not minutes. Not hours. Seconds.

(Are you crying? I’m not crying. It’s just… very dusty in here.)

.

.

.

Why This Changes Everything (And I Mean Everything)

Let’s talk about what just happened, because it’s bigger than it looks:

1. One design exploration session → 5 unique options to choose from
2. One selected design → Complete design system automatically documented
3. One Claude Skill → Infinite reusability across all your projects

Compare this to the traditional redesign process (aka the path of pain):

• Week 1: Design exploration (and existential crisis)
• Week 2: Component library building (and caffeine overdose)
• Week 3: Implementation (and debugging nightmares)
• Week 4: Consistency fixes (and more debugging)
• Week 5: Documentation (just kidding, nobody documents)

This approach?

• 30 minutes total
• Perfect consistency
• Reusable forever
• Documentation included

But here’s what really gets me excited (and I don’t get excited about many things anymore—I’m old and tired):

The skill gets smarter over time.

• Find a bug in the glass effect? Fix it once in the skill. Every project gets the update.
• Want to add a new component pattern? Update the skill. It’s everywhere instantly.
• Need to onboard a developer? Share the skill. They’re designing consistently from minute one.

Every improvement compounds.

It’s like investing in index funds, but for your design system. (That’s the most adult sentence I’ve ever written. I need to go lie down.)

.

.

.

The Benefits Nobody Mentions at Parties

Benefit #1: Design Consistency Without The Design Drama

You get enterprise-level design consistency without:

• Figma (and its 47 comments per component)
• Storybook (and its 3-hour setup process)
• A design team (and their strong opinions about kerning)

Just you, your skill, and perfect consistency.

It’s beautiful.

Benefit #2: Instant Design Language That Actually Makes Sense

That 300-line SKILL.md?

It’s not just documentation. It’s your design philosophy, your patterns, your principles—all captured automatically.

It’s like having a tiny design consultant living in your codebase, but one that never sends invoices.

Benefit #3: Version Control for Visual Design

Your design system is now code. Which means:

• Git trackable (see what changed and when)
• PR reviewable (catch issues before they ship)
• Rollback-able (when that neon green seemed like a good idea at 3 AM)

It’s version control for visuals.

The future is now, friend.

Benefit #4: Team Scalability Without the Scaling Pains

New developer joins the team?

Old way: “Here’s our 47-page design guide. Good luck!”

New way: “Use the sololedger-glass-aurora skill.”

Done.

They’re designing consistently from day one.

No training montage required.

Benefit #5: Professional Client Deliverables

That skill package? It’s also professional documentation you can hand to clients.

“Here’s our complete design system.”

Hands over ZIP file

Client is impressed

You look like a genius

(You ARE a genius, but now you have proof.)

.

.

.

Your Turn: From Generic to Gorgeous in 30 Minutes

Ready?

Here’s your recipe for design transformation:

Step 1: Pick Your Victim (I mean, page)

Don’t try to redesign everything at once. (That way lies madness.)

Start with one page. Dashboard, landing page, settings—doesn’t matter.

Pick the one that makes you saddest.

Step 2: Generate Your Options

Use Claude Code with the frontend-design skill. Ask for 5 variants.

Be specific about the vibe you want. “Make it pretty” is not specific. “Make it look like Spotify met a disco ball at a Nordic design conference” is specific.

(Also intriguing.)

Step 3: Fall in Love (Then Refine)

Choose your favorite. Get both theme versions. Make sure it sparks joy. (Yes, I’m Marie Kondo-ing your design system. Deal with it.)

Step 4: Birth Your Skill

Switch to Claude Web. Attach the HTML files. Generate comprehensive documentation. Package with skill-creator.

Watch your design system become immortal.

Step 5: Deploy Your Beauty Everywhere

Add to your project. Use the skill to redesign everything.

Feel that? That’s the satisfaction of consistency. It’s better than finding matching socks.

Step 6: Make It Better (Forever)

Your skill isn’t frozen in carbonite. Improve it. Expand it. Share it.

Every enhancement makes every project better.

It’s compound interest for your eyeballs.

.

.

.

The Real Talk Conclusion

I spent years accepting generic designs.

Not because I liked them.

But because custom design seemed too expensive—not in money, but in time.

Time I didn’t have.

Energy I couldn’t spare.

Mental bandwidth already allocated to remembering my passwords.

But what if custom design took 30 minutes instead of 30 days?

What if consistency was automatic instead of aspirational?

What if your design system could teach itself to any AI that needed it?

That’s not the future, friend. That’s what I just showed you.

My accounting app no longer looks like everyone else’s. It has personality. It has presence. It has that glass aurora glow that makes even tax calculations feel slightly magical. (Slightly. Let’s not get carried away—they’re still tax calculations.)

And it took less time than watching a Netflix episode.

(A short one. Not one of those prestige drama episodes that’s basically a movie.)

.

.

.

Here’s My Challenge to You

Open that project with the generic UI. You know the one. The one you show people quickly while saying “it’s still in beta.”

Give it 30 minutes. Just 30.

Generate your variants. Pick your favorite. Make it a skill.

Watch as your entire app transforms from “functional” to “fascinating.”

Because life’s too short for boring dashboards, friend.

And your apps deserve to be as unique as you are.

(Even if you’re not that unique. I’m kidding! You’re totally unique. Your mother was right.)

What design will you capture as a Claude Skill today?

Go. Create. Make the internet prettier.

We’re all counting on you.

(No pressure.)

P.S. – That glass aurora design I fell in love with? I’ve now applied it to three different projects. Same skill. Same consistency. Same “ooh, what’s that?” reaction from everyone who sees it. Total time to redesign all three: under an hour. The old way would have taken weeks, and they all would have looked slightly different, like siblings who don’t quite look related.

P.P.S. – Want to create your own design skills but feeling overwhelmed? Start here: Download the frontend-design skill from GitHub. Ask for design variants. Pick your favorite. Watch the magic happen. Then write me a thank-you note. Or don’t. I’ll just be here, admiring my glass aurora dashboard and feeling quietly superior to everyone still using default Bootstrap.

P.P.P.S. – Yes, I know that’s too many P.S.’s. But you’re still reading, aren’t you? See? Sometimes breaking the rules works. Just like breaking free from generic design. Full circle, friend. Full. Circle.

Let’s say you’re debugging.

Again.

That same gnarly issue that made you question your entire career choice last Tuesday. And the Tuesday before that. Your brain does that thing where it whispers: “Wait… didn’t I fix this already?”

You definitely fixed this already.

The solution exists somewhere—buried in a three-week-old Slack thread, or maybe that commit message you wrote at 2 AM when you were feeling particularly verbose. (Spoiler: You weren’t. The message says “fixed bug.”)

Here’s the thing: We’re hemorrhaging wisdom every single day.

Not because we’re not learning. We learn constantly. We discover edge cases, make architectural decisions, stumble upon performance tricks that would make your CS professor weep with joy.

But then? We move on. Next feature. Next sprint. Next fire.

And all that hard-won knowledge?

Poof.

Gone like your willpower at 3 PM when someone mentions there’s leftover birthday cake in the break room.

.

.

.

The Problem: Claude Code Has The Memory of a Goldfish

Picture this: You’re vibe coding with Claude Code. (Yes, that’s a technical term now. Roll with it.)

Together, you and Claude are making dozens of micro-decisions every session:

• “Oh right, this package completely changed its API in v2”
• “We need to store files in org-scoped directories for multi-tenancy”
• “This approach is 10x faster than the obvious solution”
• “Never—and I mean NEVER—use pattern X here because of edge case Y”

These aren’t just code comments, friend. This is architectural wisdom. The kind that separates the “I can center a div” developers from the “I’ve seen things you wouldn’t believe” architects.

But here’s what happens next. (You already know where this is going, don’t you?)

1. Claude Code discovers something important
2. You fix the issue together
3. You high-five virtually and move on
4. Next week, Claude Code makes the exact. Same. Mistake.
5. You debug the exact. Same. Issue.
6. Rinse, repeat, cry a little

Sure, we’ve got CLAUDE.md for project rules.

But let me ask you something: When was the last time you updated that file after a coding session?

Cricket sounds.

Exactly.

Nobody has time to document discoveries when you’re in the zone. Nobody.

So I built a Claude Skill that remembers everything for us.

(Stay with me. This gets good.)

.

.

.

The Complete Workflow: Capture, Review, Integrate

The Build Insights Logger skill creates what I like to call a “knowledge management system.” (Fancy, right? It’s actually pretty simple.)

• Step 1: Automatic Capture – Logs insights while you’re coding
• Step 2: Smart Review – Shows you insights organized by category
• Step 3: Selective Integration – Adds the good stuff to CLAUDE.md
• Step 4: Compound Learning – Every future session gets smarter

Let me show you how this saved my bacon. (Actually, it was more like saving me from a dependency nightmare, but “saved my bacon” sounds more dramatic.)

.

.

.

Step 1: Automatic Knowledge Capture (While You Code!)

Here’s what the Build Insights Logger does brilliantly: it automatically logs meaningful insights as Claude Code works.

No manual documentation.
No “I’ll add this to the docs later.” (You won’t.)
No lost learnings.

Just automatic capture of:

• Non-trivial edge cases you stumble upon
• Design decisions and their rationale (the WHY behind the WHAT)
• Performance optimizations that made you go “whoa”
• Security implications that could bite you later
• Architecture patterns you actually adopt
• API gotchas and their fixes
• Implementation trade-offs

Everything gets logged to .claude/insights/ during your session. Ready for review when YOU’RE ready.

Real-World Example: Building a Document Management System

On Monday, I was building a document management system. The complex kind—file uploads, multi-tenant storage, previews, the whole enchilada.

I started with my standard instruction to Claude Code

Notice the magic phrase: “Please use the build-insights-logger skill.”

That’s it. That’s all it takes.

Claude Code immediately gets it:

With the skill activated, Claude Code starts building. But—and here’s where it gets interesting—it’s not just coding. It’s documenting its discoveries:

As Claude works through the implementation, it automatically creates an insights log:

What Gets Captured: Real Architectural Decisions

These insights aren’t fluff. They’re the real deal—architectural decisions that matter:

Look at that first insight—a pluggable storage abstraction. Claude Code discovered you needed to support multiple storage backends (local disk, S3, Azure Blob) and documented the pattern.

Key insight captured: “By storing files in org-scoped directories with year/month structure (storage/documents/{orgId}/{yyyy}/{mm}/{filename}), we maintain tenant isolation at the filesystem level and enable efficient cleanup/archiving strategies.”

That’s not a code comment, friend.

That’s institutional knowledge.

As development continues, more insights accumulate:

Notice the categories:

• Architecture: System design decisions
• UI Patterns: Implementation approaches that actually work
• Navigation: Integration strategies
• Implementation Strategy: Why we’re building it this way

Each insight includes:

• The files involved
• Relevant tags (for finding it later)
• Clear explanation of the decision
• Why it matters (the part everyone forgets to document)

The Moment That Made Me a Believer: The cuid2 Bug

Here’s where the skill earned its keep.

After implementing the core functionality, I hit an error:

The build was failing. The error message? Cryptic as a fortune cookie: “Export cuid doesn’t exist in target module.”

Now, normally this triggers The Debugging Dance. You know the one—check imports, read docs, sacrifice a rubber duck to the Stack Overflow gods.

But watch what happened when I asked Claude Code to fix it and log the insight:

Claude Code didn’t just fix the bug.

It:

1. Researched the root cause
2. Created a comprehensive fix plan
3. Documented the gotcha for future reference

The fix was simple—the package had changed its API between v1 and v2:

But here’s the crucial part—this knowledge was captured permanently:

Look at that bug fix documentation:

• Clear problem statement
• Root cause analysis
• Wrong pattern marked (with a big ❌)
• Correct pattern provided (with a reassuring ✅)
• Package version context

This bug will never bite us again.

Never.

(Well, unless we forget to use the skill. But we won’t. Right?)

.

.

.

Step 2: Transforming Raw Insights Into Permanent Knowledge

So you’ve been capturing insights automatically. Your .claude/insights/ folder is filling up with valuable learnings like a wisdom piñata.

But insights in session files are like vegetables in your crisper drawer—valuable, but not helping anyone if they’re just sitting there.

Time for the review workflow. This is where the magic happens.

Triggering the Review: On YOUR Schedule

The Build Insights Logger respects your flow. It never interrupts with “Hey! Want to review your insights? How about now? Now? What about now?”

Never.

You review when YOU want. After the feature ships. After the bug is squashed. After your coffee. (Definitely after coffee.)

Here’s how simple it is:

One command: “Please use the build-insights-logger skill to review the insights from existing sessions.”

Claude Code immediately understands:

Watch what happens next. Claude doesn’t just dump a wall of text like your cousin’s Facebook posts. It systematically explores your insights directory:

Two session files found. 160 lines of insights total.

Raw knowledge waiting to be refined. Like coffee beans waiting to become that sweet, sweet nectar of productivity.

The Presentation: Organized, Categorized, Actually Useful

This is where the skill really shines.

Instead of showing you raw session logs (boring), Claude Code presents your insights like a senior architect presenting findings to the team:

Look at that organization!

Architecture & Design Patterns

• Document storage abstraction with migration paths
• Backend-first implementation strategy

Prisma & Database Patterns

• Complex filtering with OR/AND combinations
• Many-to-many relations with soft deletes

Each insight is:

• Numbered for easy selection (1/, 2/, 3/…)
• Categorized for context (because context is everything)
• Summarized with key details
• Explained with why it matters

The presentation continues:

Security & Permissions

• Tiered permission levels for different operations
• Defensive soft-delete checking

Data Integrity & Business Logic

• Transaction links removed on soft delete
• Per-file error handling in batch operations

And more:

UI Implementation Patterns

• File upload with hidden input ref pattern
• Document preview with MIME-type detection
• Two-level navigation integration

Bug Fixes & Dependencies

• That @paralleldrive/cuid2 import issue (remember that little rascal?)

13 insights total. Each one a potential bug prevented, a pattern established, a decision documented.

It’s like having a time machine that lets you send wisdom to your future self.

.

.

.

Step 3: Curating Your Knowledge Base (Be Picky!)

Claude asks: “Which insights would you like to add to CLAUDE.md?”

This is where you become the curator of your own knowledge museum. (Fancy!)

My selections:

• 2 – Backend-first implementation strategy (methodology worth preserving)
• 3 & 4 – Prisma patterns (made generic for any schema)
• 5 – Tiered permissions (security pattern)
• 13 – The cuid2 import bug (never. again.)

Notice what I did with insight 3? “Make this rule generic so that it can be applicable for any Prisma schema.”

The skill doesn’t just copy-paste like a lazy intern. It adapts insights to be broadly useful.

I didn’t select everything. Some insights were too specific. Others were already covered.

Quality beats quantity.

Every. Single. Time.

The Integration: Surgical Precision (No Mess)

Watch what happens when Claude Code integrates my selected insights:

Claude reads my existing CLAUDE.md (278 lines) and begins surgical integration.

It doesn’t just slap new stuff at the end like a P.S. on a love letter. It finds the RIGHT sections:

The Permission Layers section gets enhanced with the tiered strategy:

• GET endpoints for regular members
• PATCH/POST/DELETE for destructive operations require admin
• Clear examples with specific routes

A new Prisma Query Patterns section appears with that complex OR/AND filtering pattern:

// When combining multiple OR conditions in a single query, wrap them in AND:
if (where.OR) {
  where.AND = [{ OR: where.OR }, { OR: searchConditions }];
  delete where.OR;
}

This pattern will save you hours of debugging Prisma query conflicts.

Hours.

The Common Pitfalls section gets the cuid2 import pattern:

// ❌ WRONG - v1 pattern, will fail with "Export cuid doesn't exist"
import { cuid } from '@paralleldrive/cuid2';

// ✅ CORRECT - v2 exports createId
import { createId } from '@paralleldrive/cuid2';

Complete with root cause explanation. This bug will never happen again in any project.

(I’m not crying. You’re crying.)

The Confirmation: Knowledge Preserved

The summary tells the complete story:

Added to CLAUDE.md:

1. Backend-first implementation strategy → Coding Standards section
2. Complex Prisma filtering → New Prisma Query Patterns section
3. Filtering many-to-many relations → Same section, generalized
4. Tiered permission strategy → Enhanced Permission Layers section
5. @paralleldrive/cuid2 import → Common Pitfalls section

Session files archived:

• session-2025-11-18-003404.md → .claude/insights/archive/
• session-2025-11-18-121019.md → .claude/insights/archive/

The insights aren’t lost. They’re archived. But the valuable patterns? They’re now in CLAUDE.md where they’ll guide every future coding session.

It’s like upgrading from sticky notes to a proper filing system. (But one that actually works.)

.

.

.

The Selection Philosophy: What Makes the Cut?

Not every insight belongs in CLAUDE.md.

Here’s my selection criteria. (Yes, I have criteria. I’m fancy like that.)

Always Include:

• Universal patterns that apply across features
• Security decisions that affect the whole app
• Performance optimizations that should be standard
• Bug fixes for external dependencies
• Architectural principles that guide development

Usually Skip:

• Feature-specific implementation details
• One-off workarounds
• Obvious patterns Claude already knows
• Project-specific business logic
• Temporary fixes waiting for upstream patches

Transform When Adding:

• Make patterns generic (not tied to specific models)
• Extract the principle, not just the implementation
• Add context about when to apply (and when NOT to)
• Include examples that clarify usage

The goal isn’t to document everything. The goal is to capture patterns that make your next project better.

Less encyclopedia, more greatest hits album.

.

.

.

The Compound Effect:

Here’s what happens over time. (Spoiler: It’s beautiful.)

• Week 1: You capture 10 insights about authentication patterns
• Week 2: You capture 8 insights about performance optimizations
• Week 3: You capture 12 insights about error handling
• Month 2: You have 100+ insights spanning every aspect of your codebase

Now imagine Claude Code with access to all of that institutional knowledge.

It’s not just avoiding bugs. It’s:

• Consistent architectural decisions
• Proven patterns applied automatically
• Edge cases handled proactively
• Performance optimizations baked in
• Security considerations from day one

Your codebase doesn’t just grow. It evolves.

(Like Pokémon, but for code.)

Picture this:

Before this review:

• 2 session files with 13 insights
• Knowledge trapped in temporary logs
• Claude Code blissfully unaware

After 2 minutes of review:

• 5 critical patterns added to permanent knowledge
• CLAUDE.md enhanced with battle-tested wisdom
• Every future session benefits

Now multiply this across every coding session:

• Week 1: 5 insights added → Next development avoids 5 issues
• Week 2: 8 more insights → Next development avoids 13 issues
• Month 2: 50+ insights → Your codebase is basically bulletproof

Each review session doesn’t just improve documentation. It improves every future line of code Claude writes.

It’s compound interest for your codebase.

.

.

.

Your Complete Workflow: From Chaos to Compound Knowledge

Here’s your complete workflow. (Print this out. Stick it on your monitor. Tattoo it on your forearm. Whatever works.)

During Development (Automatic):

1. Activate build-insights-logger at session start
2. Code normally—insights log automatically
3. Discoveries, decisions, and fixes are captured
4. Session file grows with valuable learnings

After Development (5 minutes):

1. Request review: “Review insights from existing sessions”
2. Read through categorized insights
3. Select the valuable patterns (usually 30-50%)
4. Let Claude integrate into CLAUDE.md
5. Session files archive automatically

Next Development (Automatic Benefits):

1. Claude reads enhanced CLAUDE.md
2. Applies all captured patterns
3. Avoids all documented pitfalls
4. Implements proven architectures
5. Your code is better without trying

It’s not just documentation.

It’s evolutionary development.

Each development builds on the learnings of the last. Like standing on the shoulders of giants, except the giant is your past self. (Your past self is very tall in this metaphor. Roll with it.)

.

.

.

Your Action Items (Yes, You. Right Now.)

1. Implement the Build Insights Logger skill in your current project
2. Activate it at the start of your next coding session
3. Code normally—let insights capture automatically
4. Review weekly—spend 5 minutes curating insights
5. Watch your CLAUDE.md grow from basic rules to battle-tested wisdom
6. Measure the difference—track how many repeated bugs you avoid

What insights are waiting in your .claude/insights/ folder right now?

Go review them.

Your future self will thank you. (Your future self might even buy you coffee. Your future self is thoughtful like that.)

Resources:

• How to add “Build Insights Logger” skill into your Claude Code

Let’s say you’re sitting there at 2 AM.

You’ve just discovered this game-changing AI Elements library—launched recently, perfect for what you need. Your brain is doing that excited thing where it’s already building the feature before your fingers touch the keyboard.

You fire up Claude Code.

Type with the confidence of someone who’s done this a thousand times: “Build me an AI chat interface using AI Elements.”

Claude starts coding.

It looks… plausible.

Convincing, even.

Then you spot it: import { AIChat } from '@ai-sdk/elements'

That import doesn’t exist. The component is called Conversation. Claude is hallucinating an API that sounds right but isn’t.

It’s writing fiction dressed up as code.

You correct it.

Claude apologizes—sweet, polite, completely unhelpful.

Tries again.

Different hallucination.

Round and round you go.

Like trying to teach someone to cook while they’re blindfolded and you’re speaking different languages.

The documentation is literally right there on your screen. But Claude can’t see it.

Well.

That used to be true.

.

.

.

Here’s the Thing About AI and Documentation

Every week—every blessed week—new libraries launch.

The ones you already use? They’re dropping breaking changes like confetti at a wedding nobody wanted to attend.

Meanwhile, your AI coding agent is stuck in the past.

Claude Opus 4.1 doesn’t know about the library that launched last month. It definitely doesn’t know about the v2.0 that dropped while you were eating lunch yesterday.

(Is it weird that we expect AI to be omniscient? Like it should somehow absorb knowledge through the ethernet? Stay with me.)

You’ve probably tried the usual suspects:

• The copy-paste marathon—where you dump documentation into the prompt until your context window explodes like an overfilled water balloon.
• The MCP server hunt—searching for something that usually doesn’t exist. (Spoiler: it doesn’t.)
• The Context7 lottery—sometimes brilliant, sometimes returns docs from the Mesozoic era.
• The manual correction dance—where you become a human API reference for three hours. (Fun!)

Each approach fails spectacularly in its own special way.

• Copy-pasting burns through 80% of your context before you write a single line of actual code. Good luck debugging when you’ve already consumed 100k tokens on documentation alone.
• MCP servers are amazing. When they exist. Which is approximately never for the library you need right now.
• Context7 is like a box of chocolates—you never know if you’re getting current docs or something from 2022. You’ll find out the hard way.
• Manual correction? Sure, if your idea of a good time is playing “human API dictionary” until your eyes bleed.

There had to be a better way.

(There is.)

.

.

.

Enter Claude Skills: Your Documentation Superpower

Imagine this: You could teach Claude ANY library’s documentation.

Permanently.

Not the copy-paste-and-pray method. Not the please-let-there-be-an-MCP-server wishful thinking.

Actual knowledge.

The kind Claude can reference intelligently, pulling only the relevant bits for each task.

Like having a senior developer who’s memorized every documentation page but only shares what you need to know right now.

Here’s what becomes possible:

Claude Skills package documentation in a way that makes Claude understand not just WHAT the API is, but HOW to use it correctly. The difference between knowing the words to a song and understanding why it makes people cry.

Once you create a skill, it works forever.

Every project.

Every session.

Perfect implementation every time.

(Is it magic? Kind of. But the boring, repeatable kind.)

Let me show you exactly how I turned brand-new AI Elements documentation into a Claude Skill. Then used it to build a complete AI chat application.

Without a single hallucination.

Ferpetesake, it actually worked.

.

.

.

Step 1: Gather Your Documentation (2 Minutes, If You’re Slow)

I started at ai-sdk.dev/elements.

Downloaded everything—component references, examples, tutorials, the works.

Dropped them in my project like this:

Here’s the thing: Grab everything. Even that weird edge-case page you think you’ll never need. That’s the page that’ll save your bacon at 3 AM when nothing else makes sense.

(Trust me on this one.)

.

.

.

Step 2: Brainstorm Like You Mean It (5 Minutes)

Most people would jump straight into creating the skill here.

Don’t.

(Seriously. Stop. Put down the keyboard.)

First, you need to define exactly how you want Claude to use this documentation. Think of it like training a brilliant but literal-minded assistant—you need to be specific about expectations.

Here’s my exact prompt:

Prompt:

I want to create a skill that reads the docs in this folder @docs/ai-sdk-ai-elements-doc/.

The idea: whenever we work with AI elements or build an AI native app, we'll refer to the relevant docs first before building the app.

The docs are in markdown format and contain detailed information about the AI elements SDK including usage examples, and best practices.

Ask me clarifying questions until you are 95% confident you can complete this task successfully.

a. If the question is about choosing different options, please provide me with a list of options to choose from. Mark the option with a clear label, like a, b, c, etc.
b. If the question need custom input that is not in the list of options, please ask me to provide the custom input.

Always mark each question with a number, like 1/, 2/, 3/, etc. so that I can easily refer to the question number when I answer.

For each question, add your recommendation (with reason why) below the options. This would help me in making a better decision.

Watch what happens next.

Claude doesn’t just accept the task like an overeager intern. It asks targeted questions:

How should the skill activate?

• Automatic (when AI Elements terms pop up)
• Manual only (when you explicitly call it)
• Hybrid (best of both worlds)

Where should documentation live?

• Local markdown files
• WebFetch from the mothership
• Both (local with web backup)

I answer with quick picks. No dissertations needed.

Claude then creates a complete requirements document.

We’re talking 654 lines of specifications. It includes:

• Activation triggers (automatic when components are mentioned—like a helpful friend who knows when to chime in)
• 4 intelligent routing modes
• Smart multi-page fetching rules
• Response format templates
• Query interpretation patterns

This isn’t busy work.

This is Claude learning HOW you want it to think about this documentation.

Time invested: 5 minutes of Q&A.

(Worth every second.)

.

.

.

Step 3: Transform Requirements Into Reality (3 Minutes)

Now for the satisfying part.

I tell Claude: “Let’s use the ‘skill-creator’ skill to create the skill”

(Yes, we’re using a skill to create a skill. It’s skills all the way down. Stay with me.)

Watch as Claude:

1. Packages all 39 markdown files (31 components plus the kitchen sink)
2. Creates intelligent routing rules
3. Builds activation triggers
4. Generates a searchable index

The result?

Your documentation is now a reusable Claude Skill.

Forever.

(Take a moment. This is big.)

.

.

.

Step 4: Watch the Magic Happen (10 Minutes of Pure Joy)

Time to see if this actually works.

I tell Claude: “Read the @.notes/requirements.md, and use the ‘ai-elements’ skill to build the AI Chat Application.”

Claude recognizes the skill immediately:

Now here’s where it gets interesting.

Instead of guessing the API—or worse, making stuff up—Claude reads the actual docs:

• INDEX.md for component reference
• examples/chatbot.md for patterns
• components/conversation.md for core components
• components/prompt-input.md for input handling

Notice something?

Claude read 8 files out of 39. Not the entire documentation set. Just what it needed.

Surgical precision.

(This is the opposite of the copy-paste-everything approach. And it’s beautiful.)

Now Claude builds with the confidence of someone who actually knows what they’re doing:

Every import correct. Every API call accurate. Zero hallucinations.

Want proof this actually works? Here’s what I built:

The entire AI chat application builds perfectly:

• Database schema with Prisma
• API routes for chat sessions
• Real-time streaming with AI Elements
• Proper component composition
• Error handling
• State management

No back-and-forth. No corrections. No “actually, that’s not how it works.”

It. Just. Works.

(I may have done a small victory dance. Don’t judge.)

.

.

.

Why This Isn’t Just Another MCP Alternative

“But wait,” you’re thinking. “Isn’t this what MCP servers do?”

Kind of. But also not at all.

MCP servers:

• Require the library author to build one (good luck with that)
• Need constant maintenance (who has time?)
• Often lag behind latest versions (naturally)
• You have zero control (hope you like their choices)

Claude Skills:

• You create them yourself (15 minutes, tops)
• Work with ANY documentation (even that obscure library from 2019)
• Update when YOU want (not when someone else gets around to it)
• Full control over what’s included (your docs, your rules)

But here’s the feature that makes me want to write poetry:

Claude Skills read intelligently.

When working with AI Elements, Claude didn’t inhale all 39 documentation files like some kind of context-window glutton. It read the 8 relevant ones. No waste. No bloat. Just what it needed.

Try that with copy-paste.

(Spoiler: you can’t.)

.

.

.

The Compound Effect (Or: Why This Changes Everything)

Think about your current stack for a hot second:

• React components library
• Your database ORM
• Payment provider SDK
• Authentication library
• UI component system
• Analytics platform
• Email service
• File storage API
• That weird library Bob insisted on using

Each one could be a Claude Skill.

Do the math with me:

1 library skill = 2 hours saved per project 10 library skills = 20 hours saved Your entire stack as skills = Never manually correct AI again

But wait. (There’s more.)

• Version updates? Update the skill once. Every project gets the new version. Like magic, but boring and reliable.
• Team knowledge? Share the skill. Everyone codes like they wrote the docs. Instant expertise, just add water.
• New libraries? 15 minutes to perfect implementation. Even if it launched during your lunch break.

.

.

.

Your Library Skills Arsenal: A Field Guide

The Golden Rules

Rule 1: Include Everything, Let Claude Filter

Don’t try to curate “only the important docs.” You’re not the documentation police.

Claude Skills are intelligent. They’ll find what’s relevant. Your job is comprehensive coverage. Be the completionist.

Rule 2: Update Regularly (Set a Calendar Reminder)

Monthly skill updates. Put it in your calendar. Title it “Feed the Skills.” Your future self will send you thank-you notes.

Rule 3: Create Composite Skills

Building with Next.js + Prisma + tRPC? Create a “nextjs-stack” skill with all three. One activation, complete stack knowledge.

(Why make three trips when one will do?)

Rule 4: Test in Isolation

Before using a library skill in production:

• Create a simple test project
• Ask Claude to build a basic example
• Verify the generated code matches current docs

Trust, but verify.

Rule 5: Share Your Skills

That React Native Navigation skill you perfected? Your team needs it. That Stripe integration skill? The community wants it.

Build once. Help everyone.

(Be the hero.)

.

.

.

Your Action Plan (Do This Today)

Step 1: Identify Your Most Frustrating Library

Which one causes the most AI hallucinations?

• That new API you’re wrestling?
• The library with the major update?
• The complex SDK with 100+ endpoints?

Pick your nemesis.

Step 2: Gather Documentation (2 minutes)

Download or clone the docs. Create a folder. Done.

(Easier than making coffee.)

Step 3: Brainstorm Requirements (5 minutes)

Use my prompt. Answer the questions. Let Claude build comprehensive requirements.

No shortcuts here. Do the work.

Step 4: Create The Skill (3 minutes)

Run skill-creator. Package the documentation.

Watch as months of frustration evaporate.

Step 5: Test Immediately

Build something simple. Verify accuracy. Refine if needed.

(But honestly? It usually works perfectly the first time.)

Step 6: Use It Everywhere

Every project. Every feature. Perfect implementation.

No exceptions.

.

.

.

The Future You’re Building (Whether You Know It Or Not)

Picture this: You open Claude Code six months from now.

Your skills library includes:

• Every major framework (even the ones that don’t exist yet)
• Your company’s internal SDKs (the undocumented ones)
• That obscure library only you use (we all have one)
• The cutting-edge tool that launched this morning

You type: “Build me a real-time collaborative editor with our standard stack”

Claude activates:

• nextjs-15-skill
• collaboration-sdk-skill
• your-ui-components-skill
• websocket-patterns-skill

Perfect implementation. First try. Every single time.

No more “Claude doesn’t know this library.”

No more debugging hallucinated APIs.

No more being a human API reference.

Just your documentation, permanently accessible, intelligently used.

(Is this what peace feels like?)

.

.

.

Here’s What I Know to Be True

Every library you use regularly should be a Claude Skill.

Not because it’s trendy. Not because it’s the cool new thing. Not even because I said so.

Because spending 15 minutes creating a skill saves you hours of correction. Forever.

Because your team deserves consistent implementation without the learning curve.

Because you have better things to do than correct AI hallucinations all day.

(Like, literally anything else.)

Claude Skills aren’t just about saving time. They’re about eliminating an entire category of AI coding friction. The kind that makes you want to throw your laptop out the window.

So here’s my challenge:

Take that new library. The one with no MCP server. The one Claude keeps getting wrong. The one that’s been making you question your career choices.

Spend 15 minutes. Create the skill. Watch it work perfectly.

Then ask yourself:

Why would you ever go back to the old way?

Stop correcting hallucinations.

Start building with confidence.

Right now.

(Seriously. What are you waiting for?)

Resources:

• AI Elements
• AI Elements Skill For Claude Code