7 AI Agent Skills That Actually Deliver (And How to Combine Them)

Vercel just dropped the Agent Skills Directory. Suddenly everyone's talking about skills.

Here's the thing: I tried 30 of them. Most were overhyped prompts wrapped in marketing fluff.

But 7 of them? Actually changed how I work.

If you're tired of watching people rave about AI "skills" that are just fancy prompts, this one's for you.

The Real Value of Skills

Before we dive in, let's be clear about what a skill actually is.

A skill isn't a better prompt. It's codified expertise—engineers taking their best practices and turning them into reusable AI capabilities. When you call a skill, you're not just getting better output. You're getting expertise that's been tested, refined, and battle-hardened.

The pattern: Teams that build core technology (like Vercel with Next.js) are releasing skills that encode their own best practices. You're not just getting AI—you're getting their engineering wisdom.

Now, let's talk about the 7 that actually deliver.

1. React Performance Optimization (Vercel)

If you use React or Next.js, this should be your first stop.

Vercel dropped a massive performance optimization skill, and it does exactly what you'd expect from the team that built Next.js: it finds performance bottlenecks.

In the test run, it flagged 18 different issues—5 of them critical. Bundle size optimization, caching systems, intelligent re-render management. All resolved in under 15 minutes.

What's special: This is where the industry is trending. Technology creators are codifying their own best practices into skills. You're not getting generic performance advice—you're getting the same guidance Vercel gives their own engineers.

Real impact: The demo showed interaction speed improvements that were immediately noticeable in dev environment. Small jumps between views went from slow to smooth.

Use it when: You have a React/Next.js project that's moving slower than it should.

2. Writing Clearly and Concisely

This one's boring. It's also essential.

Language models love verbosity. Ask it for a README or a commit message, and you'll get paragraphs of flowery explanation. All that fluff costs you in tokens.

This skill puts an end to it. It enforces Strunk & White principles (yes, from the 1918 book). AI pattern detection catches verbose conventions. Rules cover grammar, punctuation, composition, formatting, word choice.

Before the skill: "This commit implements the functionality for ensuring that user authentication is properly handled, showcasing robust error handling capabilities after..."

After the skill: "Add user authentication with error handling."

The two benefits:

1. Clarity: Documentation becomes readable at a glance
2. Cost: You're not paying for output tokens you don't need

Real-world demo: The video showed this in action. Documentation generated after a performance optimization was spartan, direct, no fluff. Just what was done and what to avoid. The commit message? Same thing. Direct, no padding.

Use it when: You want documentation, commits, or any text output that's clear and concise.

3. Brainstorming

This is in my top 3 most-used skills.

Here's the mistake most people make: You jump straight into planning. You tell the AI what you want and let it generate a plan.

You're skipping the most important step: Understanding what you actually want before you plan how to build it.

This skill forces you to slow down and explore. It asks questions. It engages in back-and-forth dialogue. It explores different approaches. It presents designs in stages with check-in moments where you can say "yes, go this direction" or "no, change that."

The workflow:

1. Explain your idea
2. Let the skill ask clarifying questions
3. Explore different approaches together
4. Review the staged design
5. Then move to planning

The result: You get incredibly clear on what you're building and why every piece exists before you write a single line of code.

Real-world example: The video showed building a prompt-improvement agent. The brainstorming skill explored the codebase, asked questions about research capabilities, function requirements, and context handling. Only after that clarity was achieved did it move to actual design and planning.

Use it when: You're building anything substantial. Hardly ever build a feature without this first.

4. Agentation (The Easter Egg Skill)

This one's wild. It's a DOM selector that lets you click on elements and give specific visual feedback.

Enable it, and you can hover over your app, select any component, and type feedback. That feedback gets copied with specific DOM context—telling the AI exactly where the issue is.

Real example: A dashed border box that ruined the aesthetic. Click it, leave feedback "this doesn't fit the aesthetic," copy to Claude, and the AI knows exactly which element you're talking about and fixes it on the first try.

What's special: This is human-in-the-loop feedback. You're selecting, specifying, and directing. The AI doesn't have to guess which element you mean.

But here's where it gets interesting...

Combining Skills: The 1+1=3 Effect

Skills aren't meant to be used in isolation. The video showed a brilliant example of combining Agentation with another skill called Impeccable.style.

Impeccable.style is a UX/UI auditing tool. It diagnoses problems, improves quality, and polishes details. But it has a flaw: it only reads code—it doesn't actually look at the application.

The solution: Modify the critique command to use Playwright as an MCP server. Now it captures the visual state and applies critiquing criteria.

The workflow:

1. Run Impeccable.style critique
2. It opens Playwright, interacts with your app, takes screenshots
3. It generates a critique with visual context
4. Use Agentation to annotate and fix those specific issues

But the video went further: Automate the entire loop. Playwright controls Agentation to automatically fix every critique point, generating feedback you can copy-paste back to Claude.

This is where the magic happens. Agentation was built for human-in-the-loop. But by combining it with Impeccable.style and Playwright via MCP, you get an automated UI fix workflow that would have been incredibly difficult to build from scratch.

The lesson: Skills are building blocks. Combine them. Modify them. Create workflows that are greater than the sum of their parts.

5. Tailwind Design System

If you use Tailwind, get this skill.

Language models tend to go off the rails with Tailwind. They break best practices constantly. This skill keeps them on track with codified best practices for Tailwind.

Use it when: You're working on anything that uses your Tailwind design system.

6. UI/UX Promax

This one's about vocabulary.

The skill provides 67 documented UI styles, 96 color palettes by industry, font pairings, UX guidelines, best practices, and anti-patterns.

The real value: It gives you the vocabulary to prompt better.

Without this skill, you're saying things like "make it look like Airbnb" or "I want it to look modern."

With this skill, you can say: "Make it neomorphism" or "cyberpunk retro" or "hyper realistic textures" or "liquid glass" or "neo brutalism."

Real example: The video showed the same PRD and features built in Google Stitch with only the aesthetic style changed. Neomorphism. Cyberpunk retro. Material design. Minimalism. Same features, completely different feel.

The insight: The difference wasn't better prompting—it was better vocabulary.

Use it when: You want more control over your design aesthetic.

7. Writing Skills (Obra Superpowers)

This is my go-to for creating custom skills.

What makes it special? Test-driven development for skills.

Here's how it works:

1. Run a scenario without your skill—get baseline performance
2. Run the same scenario with your skill
3. Look at the gap between the two
4. Refactor your skill based on the difference

Most skill creators just write prompts and hope for the best. This one measures improvement. You can see exactly how your skill changes the AI's performance.

Use it when: You're building custom skills for coding, marketing, business automation—anything.

The Pattern That Emerges

Looking at these 7 skills, a pattern emerges:

Performance: Skills that fix specific problems (React optimization) Clarity: Skills that improve communication (Writing clearly) Process: Skills that improve workflows (Brainstorming) Visual: Skills that handle UI/UX (Agentation, Impeccable, Tailwind, UI/UX Promax) Meta: Skills that help you build skills (Writing Skills from Obra)

This isn't random. These categories map to actual work that needs to get done.

What This Means for 2026

The agent skills directory is just the beginning. Here's what's coming:

Technology creators will release skills that encode their best practices. Next.js skills from Vercel. Framer skills from Framer. Notion skills from Notion.

Skills will combine into workflows. Agentation + Impeccable is just the start. You'll see skill stacks—combinations that solve specific problems end-to-end.

Skill creators will emerge as a new category. Engineers who don't build products but codify expertise into skills that others can use.

Test-driven skills will become standard. You won't ship a skill without measuring its improvement over baseline.

The Medianeth Take

We've started integrating agent skills into our client work. Here's what we've learned:

For speed: The React performance skill alone cut optimization time by 70% on a recent project.

For quality: Brainstorming before planning prevents the "build the wrong thing" problem that kills so many projects.

For communication: The writing clarity skill made our documentation actually readable. Our clients noticed.

For iteration: Combining skills via MCP servers lets us create workflows that would have been impossible before.

Getting Started

Here's my recommendation if you're new to agent skills:

1. Start with Brainstorming - Build this into your workflow before you do anything else
2. Add Writing Clearly and Concisely - Your future self will thank you
3. Get the technology-specific skills - React if you use React, Tailwind if you use Tailwind
4. Experiment with combining - Don't use skills in isolation. Mix and match them.

The Future Isn't Prompts

The future isn't getting better at writing prompts. It's building skills that codify expertise and combining those skills into workflows.

When Vercel releases a skill, you're getting their engineering wisdom. When you combine skills, you're creating new capabilities. When you build skills test-first, you're measuring real improvement.

This is where AI is going. Not just smarter models, but codified expertise that anyone can use.

The question isn't whether you should use skills. The question is which ones you're going to master.

---

Want to integrate agent skills into your development workflow? We're building custom skill stacks for clients. Let's talk.

Building a product and want to codify your expertise into shareable skills? We can help.