iTranslated by AI
Custom Skills for Claude Code in Web Frontend Development
Introduction
In my previous introduction article, I mentioned that I use Claude Code almost every day for my work.
Since then, while continuing to use it daily, I have become particularly hooked on the feature called Skill. I have created and am using a few custom-made Skills tailored to my own work, and they are quite convenient—so much so that I have started rolling them out to my team as well.
In this article, I will write about what a Skill is, introduce the Skills I actually use in my work, how to create them, and the workflow for rolling them out to the team.
What are Claude Code Skills?
Skills are a mechanism that allows you to teach Claude Code procedures for specific tasks or domain knowledge. In short, they are like cheat sheets for Claude Code.
By placing them as a Markdown file (SKILL.md), Claude Code will automatically refer to the appropriate Skill according to the task.
skill-name/
├── SKILL.md # Skill body (required)
├── scripts/ # Execution scripts (optional)
└── references/ # Reference documents (optional)
There are two locations where you can place them, and their usage differs:
-
User-level (
~/.claude/skills/): Personal use only. Can be used in any project. -
Project-level (
project/.claude/skills/): Team sharing. Committed to the repository so everyone can use it.
Introducing the Skills I Use
I will categorize and introduce the Skills I am currently using.
Code Generation Skills
API-related File Generation Skill
When adding a new API endpoint, by simply saying "Add an API for ~," it will automatically handle the batch generation of files for each layer + editing of existing files. The key is that it doesn't just create new files, but also automates the editing required to register and connect them to existing code. It even includes the generation of tests and mock data builders.
Routine tasks that used to take over 30 minutes by hand can now be finished in a few minutes.
Page Component Generation Skill
My work project uses a dual architecture where a modern environment (Vue 3) and a legacy environment (Vue 2) coexist. When creating a new page, it handles everything from generating files for both environments to routing configuration and Web Component registration—all in one go, with batch generation + editing of existing files.
Since it's easy to miss steps when manually handling the bridge between legacy and modern setups, having it handled by a Skill provides a sense of security.
UI Component Generation Skill
This automatically generates Vue 3 components and Storybook files. Since it reads the design from a Figma URL and translates it into code, the implementation process from design has become much smoother.
Workflow Skills
PR Review Worktree Creation Skill (add-pr-worktree)
When starting a PR review, simply passing the PR number or URL creates a worktree for the review and automatically completes the installation of dependent packages.
/add-pr-worktree 123
# or
/add-pr-worktree https://github.com/owner/repo/pull/123
Setting up the review environment is instantaneous, which has lowered the psychological barrier to saying, "Let's review this." Furthermore, after creating the worktree, I combine it with a custom agent for reviews. I plan to introduce custom agents in detail in another article, as I have done quite a bit of trial and error with them.
Worktree Deletion Skill (remove-worktree)
Once the review is finished, you can simply say "Review complete" to clean up the worktree and return to the original repository. It checks for uncommitted changes, so there is no need to worry about accidentally deleting work-in-progress code.
I use add-pr-worktree and remove-worktree as a set, which has made the PR review workflow much more comfortable.
Pre-release QA Issue Creation Skill
This is a Skill that automatically creates issues for requests to the QA team before a release. It collects issues from Milestones, automatically categorizes them into additional features, bug fixes, development environment improvements, etc., creates a summary issue for the QA team, and even handles registration to the Project board.
It's a low-key but important routine task before release. Categorization errors were common when done manually, but since delegating it to a Skill, those have disappeared.
How to Create Skills
Creating a Skill is actually not that difficult. Anthropic provides an official tool called skill-creator, which is a "Skill for creating Skills." For installation and detailed usage, the following articles are helpful:
- The Easiest Way to Create Agent Skills (Claude Code + skill-creator)
- The Complete Guide to Anthropic's Official "skill-creator"
The process for creation is roughly as follows:
- Explain the task you want to perform to Claude Code.
-
skill-creatorgenerates a draft of theSKILL.md. - Actually try using it and adjust the parts that don't work well while consulting with the AI.
There is no need to aim for a perfect Skill from the start; I believe the mindset of growing it while using it is important. If you use it a few times and think, "I want it to do this a little differently," you can just consult with the AI and adjust the SKILL.md each time.
The Flow to Pushing Custom Skills to a Project for Work
I will introduce the flow until I roll out a Skill to the team.
Step 1: Create and test at the User-level first
First, create the Skill in ~/.claude/skills/ and go through trial and error in your own environment. It's okay for it to be rough at this stage. An "it works for now" level is sufficient.
After actually using it a few times in your work, you will pick up on things like "this step in this Skill is slightly off every time" or "it would be better to have this information included as well," and adjust accordingly.
Step 2: Share with the team and get feedback
Once it reaches a usable level, share it with the team along with instructions on how to use it. Something like, "I created this Skill, would you like to try it?"
Often, when other members actually use it, they find areas for improvement that I hadn't noticed myself. Once you get feedback, incorporate it to make improvements.
Step 3: Move to Project-level and push
Once it is finished to a level where the whole team can use it, move it from ~/.claude/skills/ to project/.claude/skills/ and commit it to the repository. This makes the same Skill available to everyone on the team.
Future Outlook
- I want to cultivate Skills that are still at the User-level, move them to the Project-level, and increase the development efficiency of the entire team.
- I want to become capable of creating Skills that work efficiently (use fewer tokens).
I believe that Skills are things to be nurtured. Adjusting to changes in work, and continuing to use and improve them little by little. I believe that this accumulation will change the development experience for the entire team.
Conclusion
Since I started using Skills, the time and psychological burden of routine tasks have been significantly reduced, and the time available for actual development has gradually increased. It's also a big deal that I've acquired the intuition of "I should turn that tedious procedure into a Skill."
That said, I still lack confidence in the internal accuracy of my Skills, so I hope to master that through repeated trial and error!
Discussion