My 5 Must-Have Skills to Code with AI

The skills you use will change everything about how you code with AI.

I've tested dozens of community skills. In the end, there are 5 I never remove from my workflow. Only one is mine, the other 4 come from contributors I love.

In this post, I'll show you these 5 skills, what they do, and most importantly why they actually make a difference. You'll also find every link to install them.

1. Impeccable: the end of visual slop

The first one is Impeccable. At first, I was only half convinced. Over time, I realized it genuinely brings something.

Everyone knows Anthropic's frontend-design skill. It's almost "the skill of skills", it defined a ton of things. But today I find it also creates slop: weird fonts, cliché design choices... By trying to avoid slop, you end up recreating a new kind of slop.

Slop evolves, so you need skills that evolve with it. And that's exactly what Impeccable does, subtitled The Missing Design Vocabulary for Agents.

Installation

npx impeccable install

How it works

Once installed, a single step to get started:

npx impeccable init

It generates an impeccable folder with a design file built around your application. This file defines how your design works, what the agent should do, what it shouldn't do, the rules to follow, etc.

Then comes what I call deslopification: Impeccable fixes every flaw so it looks sharp. Typography, contrast, spatial design, responsive, interactions, motion, UI design.

Why I use it this way

Impeccable actually contains 23 sub-skills: clarify, harden, optimize... Personally, I never hunt for the right sub-skill by hand, it's too annoying to figure out which one to use.

I run the main skill directly, which acts as a router:

/impeccable

It picks the right pieces on its own to make sure your app follows the rules. There's also a CLI (npx impeccable) that scans your files to detect antipatterns.

I tested it on my course app, and honestly, it makes the UI fun: big buttons, consistent styles, polished details. A big part of it was one-shot thanks to Impeccable (with me behind the screen to check, of course 😅).

2. Grill me: so the agent one-shots your feature

The second one comes from Matt Pocock. He published a bunch of skills, I downloaded all of them... and in the end, the only one I really use is Grilling (its old name was grill me).

Interview the user relentlessly about a plan or design.

The idea: you run the skill, and it grills you with questions about your plan before writing any code. Tons of questions, on tons of topics.

Installation

npx skills@latest add mattpocock/skills --skill grill-me

Why it's so powerful

When you code with AI, the goal is always for the agent to one-shot your feature. And what prevents one-shotting is almost always a poorly defined need.

Grill me solves exactly that:

1. You have an app or feature idea
2. The skill asks you questions
3. You answer, it digs deeper, it re-questions
4. The need becomes crystal clear
5. The agent can finally build the right thing on the first try

My mobile app, I managed to one-shot it because I grilled myself for a good while first. The time you spend clarifying up front, you get it back tenfold during implementation.

3. APEX: the agent that tests its own code

The third one is obviously APEX. I no longer run a single task without it.

APEX is an acronym: Analyze - Plan - Execute - eXamine. And what it changes is that the agent tests your features itself.

Installation

APEX is one of my AI Blueprint skills. You install it like the others:

npx skills@latest add melvynx/aiblueprint --skill apex

The flow

• Initialization: it analyzes the task with parallel agents
• Planning: it defines acceptance criteria
• Execution: it codes
• Validation: type checks, and tests if you ask for them
• eXamine: it reviews the code with several agents
• Verification: it makes sure every feature actually works

The detail that changes everything: screenshots

The incredible part is that for each feature, APEX launches the app and sends me a screenshot of how it looks.

So no more launching the app and testing by hand. I look at the screenshot, I say "no but this is nonsense, why isn't this there?" (yes, I talk to it a bit harshly 😄), it fixes it, and sends me a new screenshot proving it works.

On my onboarding, without APEX it did nonsense. With APEX, it worked until it actually functioned. That changes everything.

4. Make Interface Feel Better: the magic of details

The fourth one is Make Interface Feel Better.

It looks like Impeccable, but it's about the details. Where Impeccable turns an ugly page into a decent one, this skill takes an already-decent page and makes it beautiful.

What it improves:

• borders that become perfect
• polished animations
• numbers that render cleanly (tabular numbers) instead of jumping around
• tons of micro-polish details

It's simple, it's effective. And it's exactly this kind of detail that makes the difference between a beautiful app and an average one.

The skill does one thing: design that makes an interface feel better. It won't impose ultimate rules, it'll just make your app prettier. The landing page alone makes you want to use it.

Installation

npx skills add jakubkrehel/make-interfaces-feel-better --skill make-interfaces-feel-better

5. Thermo-Nuclear Code Quality Review: the audit that forgives nothing

The fifth one is the Thermo-Nuclear Code Quality Review from the Cursor team.

The name is deliberately over the top, and that's exactly the point: a merciless audit of your code quality.

It checks:

• maintainability and overall structure
• the famous 1,000-line rule (a file that blows up is a signal)
• spaghetti code and tangled dependencies
• code-judo (flipping complexity to simplify it)

It's the skill I run when I've built fast with AI and want to make sure I didn't leave a ticking bomb in the codebase. AI moves fast, but it accumulates technical debt if you don't watch it. This skill is your safety net.

Installation

npx skills add https://github.com/cursor/plugins --skill thermo-nuclear-code-quality-review

How I combine them

Here's the general idea of my workflow:

You don't have to use all of them every time. But just Grill me + APEX already completely transforms how you code with AI.

Going further

If you want to learn how to use these skills to build apps from scratch with AI, I put together 3 free skills to automate your mobile applications: mlv.sh/fm.

And if you want to go all-in on APEX and AI agents, it's in my AI Blueprint course.

Now go test these skills. The best way to understand what they change is to run them on your own project. 🚀