AI writes code faster and faster, but I want it to slow down a little

Recently I saw Addy Osmani open-source a project called agent-skills.

At first I thought it was yet another tool to "make AI better at writing code." After looking into it, I realized it's different.

What it really tries to solve isn't "whether AI can write code," but another, more practical problem:

AI writes code too fast.

So fast that it often starts modifying files before it has thought things through.
So fast that it generates a full implementation before you've confirmed the requirement boundaries.
So fast that it says "done," but when you run the tests, you find things aren't that simple.

After using AI for programming for a while, you gradually notice a very subtle problem:

The most dangerous thing about AI isn't that it can't write code.
It's that it starts writing too confidently.

What we lack isn't code, but engineering habits

In the past, when we asked AI to write code, it often went like this:

"Help me build a login feature."
"Help me fix this bug."
"Help me optimize this page."

Then AI gets very enthusiastic.

It starts reading files, changing code, and giving you a bunch of stuff that looks complete.

But in real development, a reliable engineer usually doesn't work like that.

An experienced person will most likely ask a few questions first:

Login via phone number or email?
Need a verification code?
Lock account after how many failed attempts?
Any third-party login?
How to handle compatibility with old user data?
How to prompt for API errors?
Which scenarios do tests cover?

These questions sound tedious, but this is engineering experience.

Many projects go wrong not because a single line of code was written incorrectly, but because things weren't thought through clearly from the start.

This is where agent-skills gets interesting.

It doesn't teach AI to "write faster," but teaches AI to "hold on, follow the engineering process first."

What is agent-skills?

You can think of it as a set of work habit packages for AI programming assistants.

Inside are many skills, each corresponding to a development scenario.

For example:

spec-driven-development: Write the spec first, don't start building immediately.
planning-and-task-breakdown: Break complex requirements into small tasks.
test-driven-development: Figure out how to verify first, then implement.
code-review-and-quality: Check for risks like a code review.
debugging-and-error-recovery: When fixing bugs, locate the cause first; don't change things blindly.
frontend-ui-engineering: When doing frontend work, pay attention to interaction, state, and responsiveness.
web-performance-optimization: Check performance, don't optimize based on gut feeling.
launch-and-deployment: Do a release checklist before going live.

The value of this set of things isn't in how cool the names are, but in how it turns a lot of "senior engineers' muscle memory" into processes that AI can follow.

How to use it?

If you just want to install quickly, you can use this command:

npx skills add addyosmani/agent-skills

If you want to see what skills are inside first:

npx skills add addyosmani/agent-skills --list

If you only want to install one, like code review:

npx skills add addyosmani/agent-skills --skill code-review-and-quality

If you use Codex, you can install like this:

codex plugin marketplace add addyosmani/agent-skills

If you use other AI programming tools, you can directly check the relevant documentation for installation agent-skills

After installation, you can directly invoke a specific skill in the conversation.

For example, instead of directly saying:

Help me build a points system

You can switch to:

@spec-driven-development Help me sort out the functional specification for a points system

At this point, AI's job isn't to write code immediately, but to first break down the requirements clearly.

Then you can continue:

@planning-and-task-breakdown Break down development tasks based on this spec

Then at the implementation stage:

@test-driven-development Write tests for adding and deducting points first, then implement the logic

After writing:

@code-review-and-quality Review this change, focusing on edge cases and data consistency

This workflow sounds a bit slower, but it's genuinely closer to normal development.

Especially when the feature is slightly more complex, slowing down first actually makes things faster later.

A few scenarios I think are most worth using

The first scenario is building new features.

Previously, we easily let AI write code directly. Now a better way is to let it write a spec first.

For example, if you want to make a coupon feature, don't start by saying "help me write a coupon system." That statement is too broad, and AI can only guess.

You can let it use spec-driven-development to sort out:

What types of coupons are there?
Who can issue them?
Who can claim them?
Can they be stacked?
Should the coupon be returned after a refund?
How to handle expiration?
How to handle inventory concurrency?

Once these questions come out, you'll find: the real work hasn't started yet, but many pitfalls have already surfaced.

The second scenario is fixing bugs.

Many AI bug-fixing approaches are like "see where it's red, change that place."
But in real projects, the bug is often not just a problem with that surface-level line.

At this time, using debugging-and-error-recovery is better. It guides AI to first reproduce the problem, narrow the scope, check logs, find the root cause, and then fix it.

The third scenario is code review.

I now feel that having AI do reviews is more likely to deliver value than having it write code directly.

Because review doesn't require it to create from nothing, but lets it find problems based on existing code.

For example, you can say:

@code-review-and-quality Check if this change has any hidden risks, especially focusing on permissions, exception handling, and test gaps

This kind of task is very suitable for AI.

It might not always be right, but it can often remind you of some easily overlooked edge cases.

Who is this suitable for?

If you're only letting AI write one-off scripts, you might not need such a complete process.

But if you're working on a long-term maintenance project, or you've already started deeply integrating AI into your development workflow, I think it's very worth trying.

Especially these types of people:

Independent developers.
You don't have a full team to review, test, and check for you, so let AI take on more process checks.

Small teams.
Team standards haven't been fully established yet; you can first borrow this set of skills to get basic engineering actions running.

Heavy AI programming users.
If you use tools like Codex, Cursor, or Claude Code every day, you'll quickly discover: prompts aren't better when shorter; process is the key.

The one thing I truly like about it

What moves me most about agent-skills isn't how many commands it provides, nor how many tools it supports.

It's that it acknowledges one thing:

The problems with AI programming can't be solved solely by stronger models.

Models are important, of course.
But workflow is equally important.

A very strong AI, without process constraints, can also mess up a project.
A less impressive AI, placed into a good workflow, can instead produce value stably.

This is actually very similar to people.

A junior programmer doesn't lack the ability to write code, but doesn't know when to stop and think.
Doesn't know where requirements are ambiguous.
Doesn't know how a small change will affect other areas.
Doesn't know what tests should prove.
Doesn't know what to check before going live.

And these are precisely part of engineering capability.

What agent-skills does is make these capabilities explicit.

Finally

We used to always say that AI would make programming faster.

But I increasingly feel now that what's truly important isn't faster, but more stable.

Fast lets you write a lot of code in a day.
Stable lets you dare to change that code next month, and still maintain it half a year later.

agent-skills isn't the kind of dazzlingly cool tool that catches your eye.

It's a set of simple working methods: think clearly first, then act; verify first, then finish; review risks first, then go live.

This sounds plain and unremarkable.

But in software engineering, many things that truly work are just like this.

They just make errors happen a little less often, and let projects go a little further.

GitHub address agent-skills