On October 16, 2025, Anthropic released Agent Skills, a new way to extend Claude's capabilities with specialized, procedural knowledge. Think of it as giving your AI assistant a set of expert guidebooks, each skill packages up best practices and domain expertise that Claude can apply automatically.
The use cases quickly became clear: analyze documents with PDF or Excel skills, create beautiful presentations using your brand guidelines, visualize data for stakeholder presentations, or follow your team's specific coding standards. Skills turn one-off instructions into reusable capabilities.
Recently, Vercel introduced `skills` , a CLI for installing and managing skill packages for agents. Now you can browse skills.sh to see what's trending or check the top 10 on the leaderboard. Or head to skillsmp , the agent skills marketplace, to find exactly what you need.
Today, we'll try out these skills and see how they perform in a real scenario. I'll use Claude Code as my agent, but you can follow along with any AI agent you prefer.
The skills we'll test are:
- api-design-principles to create a simple API
- code-review-excellence to review the result
This gives us a complete workflow: build something with best practices baked in, then get professional-level code review, all automated.
Install the Skills
I'll assume you already have your AI agent of choice installed and ready to go.
Use this command to install skills from Vercel along with the skills set from
`wshobson`
(thank you for these!):
npx skills add wshobson/agents
You'll be prompted to install the skills CLI if you don't have it yet. Then you'll see a list of available skills to install. Pick what we need: api-design-principles and code-review-excellence. Or go ahead and install all of them if you want to experiment later. Continue through the process as shown in the picture below.
The installation is quick. Just a few seconds and the skills are now ready to use. Behind the scenes, these skills are being added to your agent's context, giving it specialized knowledge it can reference automatically.
Try Out the Skills
I created an empty folder called foods-api, cd into it, and used claude to spin up Claude Code. You can do the same, just swap out that last command if you're using a different agent like codex or gemini cli.
I kept the prompt simple to see how well the skill guides the agent, but you can get way more sophisticated with this. The api-design-principles skill supports advanced patterns like Resource Collection Design, HATEOAS, versioning strategies, and more. Check out the full SKILL.md at
this link
to see everything available.
Here's my prompt:
Build food api using this skill /api-design-principles
Right away, the agent asks intelligent questions: which tech stack would I prefer, what database to use, and which resources to manage. This isn't just template generation, it's applying the skill's knowledge to understand requirements properly.
After submitting my configuration, I let Claude Code do its thing. You'll need to keep an eye on it since it will ask for permissions along the way. You can review each action before approving it, which is good practice.
It took about 3 minutes and 30 seconds to scaffold this complete API. Not bad for a production-ready foundation.
Examining the Results
After the agent finished cooking, I took a look at what we got. I have to say, it's pretty impressive. You get a well-structured project with systematic design principles baked in from the start, not just boilerplate, but thoughtful architecture.
The project includes:
- Clear separation of concerns with routes, middleware, database layers, and utilities
- RESTful routing with versioned endpoints (
/api/v1/) - Parameterized SQL queries preventing SQL injection
- SQLite with WAL mode and foreign keys enabled
- Pagination utility with sensible defaults
- Composable validation middleware
Run npm run start to test the API:
Looking good. The API responds properly, and it even includes pagination out of the box. The skill really delivered on creating a well-architected foundation.
Code Review with Skills
Now here's where it gets interesting. We could manually review the codebase ourselves, or we can use another skill to do a professional-level review for us.
I didn't even write a prompt, just invoked the skill using /code-review-excellence inside Claude Code.
The review that came back was extensive and detailed. It organized findings by severity, highlighted the codebase's strengths, and identified specific issues with file paths and line numbers.
The review starts by acknowledging what's done well like parameterized queries, clean structure, proper use of SQLite features. Then it dives into required changes and suggestions.
Required Changes flagged security and robustness issues:
- Internal error details leaking to clients in the error handler
- No request body size limit, leaving the server vulnerable to memory exhaustion
- Missing validation on query parameters that could return silent failures instead of proper errors
- Issues with falsy value handling using
||instead of??
Suggestions included design considerations:
- Whether DELETE endpoints should be truly idempotent
- A note about dynamic SQL construction being safe due to allowlisting, but worth documenting
- Missing test suite
- Schema creation running on every app startup
- Seed script deletes happening outside the transaction
The review even included a Questions section asking about design decisions like whether category_id: 0 is ever valid, plans for authentication, and CORS support.
This is the kind of thorough, structured feedback you'd expect from a senior developer doing a code review. The skill doesn't just point out problems, it explains the implications, provides code examples, and differentiates between critical security issues and optional improvements.
You can fix these issues yourself, or copy the feedback and let the AI handle the improvements. I'd recommend reviewing the changes either way to understand what's being modified and why.
Conclusion
The key benefits of using skills are:
- Specialized agents: Tailor capabilities for domain-specific tasks with expert-level knowledge
- Reduced repetition: Create reusable patterns once, apply them automatically across projects
- Composable capabilities: Combine skills to build complex workflows that handle entire processes
You wouldn't want to repeatedly provide the same detailed guidance across multiple conversations, right? That's where skills shine. They capture that expertise once and make it instantly available.
From what we tested today, you can create powerful workflows for developer tasks by combining skills strategically. The api-design-principles skill gave us a solid foundation with versioned endpoints, proper database configuration, and clean architecture. Then code-review-excellence caught real issues like security vulnerabilities, edge cases, and design considerations with the kind of detail you'd expect from an experienced code reviewer.
The combination compressed what would normally be hours of work and multiple review cycles into a few minutes, while maintaining quality standards and catching issues early.
If you want to create your own skills, check out:
- The cookbook with examples and templates
- Claude API documentation for the complete specification
The skills ecosystem is just getting started, and there's huge potential here. Whether you're automating repetitive tasks, enforcing team standards, or building complex multi-step workflows, skills give you a way to package up expertise and make it reusable.
Give it a try and see what workflows you can build.