For this special feature, four companies actively advancing Claude Code adoption — Dinii, Inc., dip Corporation, LayerX Inc., and Timee, Inc. — shared the top 5 Claude Code Skills most used inside their organizations.
Review, QA, and Analysis Skills Are the Most Used at Every Company
Analyzing the responses from the four companies, common trends emerged.
- PR review and QA Skills rank at the top across companies — a pattern of encoding rules and procedures that differ by organization and team, such as commit conventions and release processes, into Skills.
- BigQuery-based data analysis Skills ranked high at 3 of the companies. At one of them, PdMs and analysts use them at roughly twice the rate of engineers — "roles that don't write SQL" are the main players.
That said, the further adoption progresses, the more challenges come into view. "Individuals can use it, but we can't quite roll it out across the whole organization" and "we can't quite connect AI adoption to productivity gains" are voices we hear often.
We hope this article helps your organization drive AI adoption and deliver results at scale.
Now, let's look in detail at what Skills each company built, why they built them, and how they changed the way Claude Code is used.
Dinii, Inc.: The most-used Claude Code Skill is production data investigation, making first-line incident triage something anyone can take on
At Dinii, which develops an All in One Restaurant Cloud specialized for the restaurant industry, every team in the development organization uses Claude Code daily. Here we introduce their top 5 most-used Skills, the background behind why they built them, and the changes that emerged after adoption.
The Team & Product Featured in This Article
Dinii develops and provides an All in One Restaurant Cloud specialized for the restaurant industry. Built around mobile ordering, POS registers, and CRM, its product scope has expanded into cashless payments, reservation management, attendance and labor management, and business management.
The scope measured for this article is the engineers in the development organization that builds these products. They are divided into teams by experience domain — in-store experience, P/L, and new customer acquisition — and every team uses Claude Code daily.
Dinii uses Claude Code company-wide, not only in the development organization, but in keeping with the theme of this feature, this article focuses on usage within the development organization.
Top 5 Skills
Ranked by number of users, the Claude Code Skills most used within Dinii's development organization are as follows.
| rank |
Skill name |
Overview |
| 1 |
Production data investigation (bigquery) |
A Skill for investigating and analyzing data in each environment — production, staging, and others — from BigQuery. During incident investigations and report creation, it builds and runs queries from natural-language requests. Connection targets per environment and cost-management premises are built in. |
| 2 |
Log search & analysis (cloud-logging) |
A Skill for searching and analyzing Google Cloud Logging via the gcloud CLI. When investigating errors or application behavior, it assembles the appropriate log filters and searches across them. |
| 3 |
AI code review (rai-review) |
A code review pipeline in which AI reviews PR diffs in multiple stages, following perspectives and rules managed per repository, and verifies its findings before returning them. The same review can be invoked locally, from CI, or from scheduled runs. |
| 4 |
Cross-project error search (sentry) |
A Skill for searching across the error monitoring tool Sentry. It runs searches, analyses, and root-cause investigations of errors spanning projects from natural-language requests. |
| 5 |
Release branch identification (identify-release-branch) |
Based on the operational rules for release branches cut weekly, this Skill determines which branches are currently on production and beta, and which branch a fix PR should target. |
Measurement period: 2026/04/14 - 07/16
Note: Claude Code's OpenTelemetry events are aggregated into BigQuery, and skill_activated events are deduplicated as "1 prompt × 1 skill = 1 activation," then joined against the employee master to extract engineering roles only for in-house measurement. Ranking by activation count places some heavy users' personal Skills at the top, so this ranking is by number of users, which reflects how far a Skill has spread through the organization (Anthropic-standard and Claude Code built-in Skills, as well as company-wide general-purpose Skills such as daily reports and evaluations, are excluded).
Why They Built These Skills
Production investigation Skills (bigquery / cloud-logging / sentry): embedding investigation premises into Skills to end person-dependence
First-line investigation of incidents and inquiries requires looking across BigQuery data, Cloud Logging logs, and Sentry errors. But there was a lot of prerequisite knowledge involved — connection targets per environment, how to write log filters, query cost management — and investigation had become dependent on a handful of members.
So they embedded each tool's prerequisite knowledge into Skills, making it possible to investigate safely from natural-language requests. The bigquery Skill, for example, runs a query only after estimating scan volume and cost.
"Have the AI investigate first" became the standard move during on-call and incident response, and first-line investigation became something anyone can take on.
AI code review (rai-review): clearing mechanical findings before human review
Waiting on review tended to be a bottleneck in development lead time, and the fact that the perspectives and depth of reviews varied by reviewer was a concern.
rai-review is a pipeline in which AI reviews PR diffs in multiple stages, following perspectives and rules managed per repository, and verifies its findings before returning them. The same review can be invoked during local development, from CI after a PR is created, or from scheduled runs.
Rather than replacing human review, its role is to "clear the mechanical findings before human review" — and it is embedded in the development flow to the point of ranking first in activation count among all Skills.
Release branch identification (identify-release-branch): putting person-dependent release knowledge into a Skill so anyone can handle releases safely
Dinii cuts a release branch every week, and runs a mainline model in which fixes made after a release are put into the release branch and CI automatically syncs them to the newer branch. Judging "which branch should this fix target" therefore required knowledge of the release cycle, and getting it wrong risked fixes slipping into the wrong release or creating rework.
identify-release-branch determines, from the operational rules of the release cycle and the current branch situation, which branches are on production and beta and where a fix PR should be merged.
By putting person-dependent release knowledge into a Skill, anyone can now handle releases safely.
How Claude Code Usage Changed After Adopting Skills
The way Claude Code is used expanded from "generating code" to "the development flow in general." Skills have reduced the variability in work quality caused by how instructions are phrased, standardizing aspects that used to depend on individual experience.
The biggest shift is in investigation work. First-line investigation of incidents and inquiries used to be concentrated among members familiar with the relevant area; because the Skills carry the prerequisite knowledge and guardrails, anyone (not only SWEs) can now take it on.
Beyond that, a culture has taken root of contributing excellent procedures as Skills rather than letting them end as individual ingenuity, and routing every step of the development flow through AI has become the standard.
◆ Written by: Junya Kimura (Tech Lead & Engineering Manager, Dinii, Inc.)
dip Corporation: Standardizing the five stages of the development flow across the team with Claude Code Skills, cutting reviewer cognitive load
The Team & Product Featured in This Article
The Core Engineering Department (hereafter "CE Department") maintains an in-house development support platform that underpins the department's development process. I am assigned as its lead, responsible for building and operating the platform and rolling it out across the department. The platform is run like internal OSS, so members other than the lead can also participate in improvements through Issues and PRs.
With Claude Code at the center of the development flow, everything from Issue creation to work plan drafting, Phase-by-Phase implementation, PR creation, and review response is organized as an ordered Skill pipeline. The Skills are distributed as shared assets of the department rather than local personal settings, keeping the same Skills running across multiple projects.
Top 5 Skills
| rank |
Skill name |
Overview |
| 1 |
Issue creation (creating-issue) |
Handles GitHub Issue creation and GitHub Project field setup in one go. Issue granularity and required fields are aligned to the department standard. |
| 2 |
Idea sparring (sparring-idea) |
Advances a dialogue starting from an Issue or idea, generating and converging meeting notes. Raises everyone's understanding to the same level before moving to implementation. |
| 3 |
Work plan creation (creating-workplan) |
Generates a Phase-structured work plan in XML. Lays the foundation for implementation to proceed in units of "1 Phase = 1 PR." |
| 4 |
Implementation to PR creation (executing-plan, first half) |
Implements exactly one incomplete Phase and handles everything through convention-compliant commits and PR creation. |
| 5 |
Review response (executing-plan, second half) |
Handles replying to and resolving review comments via an internal step handler. |
Operation period: 2026/04/27 - 07/16
executing-plan is a consolidation, still in progress, of what used to be independent Skills for "commit," "PR creation," and "review response." By folding processing into the unit of a Phase, the pipeline is deliberately evolving toward narrowing the points where humans judge and operate.
The merge operation alone is kept out of this pipeline and always executed manually by a human. The judgment is to place a clear boundary — between the range where AI acts autonomously and the range where humans take responsibility for decisions — right on the PR operation.
Why They Built These Skills
Rather than having individuals freely combine Skills and compete on productivity, we have invested the past several months in establishing a state where whoever on the team uses them goes through the same Skills in the same order. What we can present as the result is precisely these five stages everyone passes through in the same order.
The moment individual productivity rose, the bottleneck moved to human review
With AI agents in members' hands, individual work speed certainly increased. At the same time, however, the bottleneck of the development flow moved from "the time individuals spend writing code" to "the time other members spend reviewing."
Suppose member A raises their understanding with sparring-idea, splits the work into Phases with creating-workplan, and creates a PR with executing-plan. If member B, who receives that PR, has no experience going through the same pipeline as A, neither the criteria nor the speed of review will match. It became clear that a structure where only A gets faster ultimately does not raise the throughput of the whole team.
No matter how much individual Skill mastery you stack up, you get stuck if A and B are not on the same rails. That is why the CE Department invested its time not in individual productivity but in creating a state where the team goes through Skills with the same premises, in the same order.
Even with the same Claude Code, output quality wavers depending on who uses it
There was another trigger. While using Claude Code on a project we were expanding into, we noticed that Claude was operating without knowing our development pipeline existed. When you pose a question from a blank slate, the answer is heavily swayed by the context of the moment and how the individual phrases the question.
Even using the same Claude Code at the same company, quality wavers depending on who uses it. This was not a problem individuals could solve by trying harder — it required distributing Skills together with the documents they presuppose (conventions, design guidelines, terminology definitions) across the department. In parallel with building the Skill pipeline, we also put in place a mechanism to distribute the shared documents the Skills reference across the department.
How Claude Code Usage Changed After Adopting Skills
Since running the Skill pipeline across the whole department, the biggest change developers feel is that "you no longer have to memorize the rules." Recently, when I tried to run multiple tasks in parallel, Claude stopped me because it violated an operational rule. Even without knowing where that rule was written down, the Skills carry and enforce the conventions, so issues are prevented before they affect reviews or production.
Another change is that the criteria for adding or retiring Skills switched from individual convenience to team value. Even when someone finds a "Skill that only helps me," whether to include it in the department's shared Skills is now judged by how many people it affects and the value it can deliver. Cases of actively deciding "convenient, but not adopted" are increasing.
A state is now established where development runs at the department's baseline quality as long as you go through the Skills in order, and the cognitive load on reviewers has clearly dropped. Rather than teaching everyone how to use the Skills, we create a state where working along the Skills naturally aligns you with the department standard. That is where the CE Department stands today.
Because the same pipeline is distributed to multiple projects, improvements born at one site have started to be imported back into other projects. It is a cycle that emerged precisely because we committed fully to team-level AI adoption.
◆ Written by: Daichi Ito (Core Engineering Department, dip Corporation)
LayerX Inc.: The most-used Claude Code Skill is automated PR review, reducing review round-trips and lead time
The Team & Product Featured in This Article
The LayerX Fintech Business Unit develops investment services for individuals. About 7 product development engineers work full-stack across frontend, backend, and infrastructure. Claude Skills are built into the development flow, driving AI adoption centered on day-to-day implementation, review, and QA.
Top 5 Skills
| rank |
Skill name |
Overview |
| 1 |
Automated PR review (claude-code-pr-review) |
A Skill that fetches GitHub PR diffs and has specialized agents automatically review them from multiple angles — comment accuracy, test coverage, error handling, type design, code quality, complexity — returning findings in a structured form. |
| 2 |
QA checklist generation (qa-sheet) |
A Skill that analyzes the diff between the current branch and main, identifies QA perspectives from the changes (happy paths, branch coverage, regressions, edge cases, layout), and auto-generates a QA checklist in TSV format ready to paste into Google Sheets. |
| 3 |
BigQuery analysis assistant (bq-analysis) |
A Skill that analyzes the data platform with read-only queries. Executes KPI aggregation, funnel analysis, ad effectiveness, user behavior analysis, and more according to rules, returning business insights. |
| 4 |
Release PR creation (release-pr) |
A Skill that executes the full workflow of creating a release PR from the feature branch to main. Consistently guides QA sheet checks, Notion release record creation, collecting staging PR links, PR creation, and appending URLs. |
| 5 |
Code simplification review (simplify) |
A Skill that surfaces cleanup proposals for changed code from the perspectives of reuse, simplification, efficiency, and abstraction level, and applies the fixes directly. Specialized in quality improvement, not bug hunting. |
Measurement period: 2026/06/01 - 06/30
Why They Built These Skills
Automated PR review (claude-code-pr-review): systematizing review perspectives to eliminate quality variance
Review quality depended on each reviewer's experience and workload, perspectives slipped through the cracks, and code review quality varied. Especially in financial products, "silently swallowed errors" and "drift between documentation and implementation" can lead to serious defects, so the aim was to systematize review perspectives rather than rely on people alone.
Specialized agents were split by perspective — "comment accuracy," "unit test coverage," "type design," "code complexity" — in a configuration that automatically runs reviews of consistent depth per PR.
The technical and organizational background was to reduce reviewers' first-pass load while codifying review perspectives as an organizational standard.
QA checklist generation (qa-sheet): auto-generating QA checklists from diffs to end person-dependence
Creating QA checklists used to be done by QA engineers reviewing specifications and writing them out from QA knowledge and experience, which posed workload problems. There was also a structural issue: when implementers wrote QA items for their own changes, they skewed toward happy paths, easily missing conditional branches and regression checks on existing features. Formats also varied by person, adding review and sharing costs.
So the approach became to mechanically extract change types, affected screens, and branches from the diff, generate QA cases along a perspective template, and output TSV that can be pasted straight into a spreadsheet. The goal is to standardize person-dependent QA design and compress creation effort.
BigQuery analysis assistant (bq-analysis): consolidating tacit knowledge so anyone can analyze on correct premises
In data analysis, even "choosing the right data source" required expertise. For example, when seeking a certain piece of data, without knowing the on-the-ground conventions — which column of which similar-looking table to reference, whether or not to exclude churned users — there was a danger of producing plausible but wrong data.
Having people verify this tacit knowledge every time was inefficient, and the bar for anyone outside the analysis team to pull ad-hoc numbers was high.
So schema definitions, business definitions, prohibitions, and pre-execution checklists were consolidated into the Skill, aiming for a state where anyone can write queries on correct premises.
Release PR creation (release-pr): turning omission-prone release preparation into a standard flow
Release work was a process with many steps prone to omissions — "Is the QA sheet in place?" "Did we prepare the data for release approval?" When carried out in a person-dependent way, there was a risk of missing release records or dropping PRs that should have been included, compromising traceability.
Even with a runbook, working through it manually every time was burdensome, and completeness varied by person.
So the standard flow from branch checks to PR creation and record updates was turned into a Skill that guides and auto-executes the necessary steps in order, allowing release preparation to be completed at the same quality no matter who does it.
Code simplification review (simplify): automating simplification cleanups before merge
Before adoption, release preparation depended on individual memory and manual work, and skipped steps (release approval data not created, PR links not collected) occurred sporadically.
After adoption, steps proceed in a fixed order, so release PRs are now created with the necessary records and links in place, stabilizing release traceability.
Members who haven't memorized the procedure can complete preparation by following the guide, which also makes it easier to hand off and distribute release duties. "Variability in work depending on how instructions are given" has decreased, lowering both the psychological load of release preparation and the verification cost at review time.
How Claude Code Usage Changed After Adopting Skills
Automated PR review (claude-code-pr-review): systematized review perspectives reduced quality variance
Before adoption, the depth and perspectives of review comments varied by reviewer, and some didn't get as far as tests or error handling.
After adoption, a consistent baseline of perspective checks runs the moment a PR is created, letting reviewers delegate mechanically catchable findings and focus on discussions of design and domain validity.
As a result, the kind of findings "you don't notice until told" are resolved in advance, reducing review round-trips and lead time to merge. With perspectives verbalized and shared, the review standard itself has taken root as the team's common language — another major change.
QA checklist generation (qa-sheet): auto-generating QA checklists from diffs to end person-dependence
Before adoption, creating QA checklists took a solid block of time each time, and the granularity and coverage of perspectives depended on the person in charge.
After adoption, a draft is generated quickly from the diff, so the work shifted from "writing from scratch" to "reviewing and reinforcing the generated result." Perspectives like branch coverage and regression checks are now included as standard, reducing post-release misses like "we hadn't checked that branch."
The unified output format has made sharing and review smoother, achieving both shorter QA preparation lead times and a higher quality floor at the same time.
Code simplification review (simplify): automating simplification cleanups before merge
Before adoption, simplification-type findings got mixed into review comments with lowered priority, tending toward a state of "noticed but never fixed."
After adoption, simplification perspectives can be pulled out and cleaned up automatically before commit or review, so redundant code gets tidied before merge.
With bug detection and quality improvement split into separate Skills, they can be used according to purpose, and review comments have less noise, allowing focus on essential discussions. As a result, code readability and reusability are maintained continuously, and the burden of after-the-fact refactoring has dropped.
◆ Written by: Kentaro Takahashi (VPoE, LayerX Fintech Business)
Timee, Inc.: The most-used Claude Code Skills are data analysis, with PdMs and analysts using them at twice the engineer rate
The Team & Product Featured in This Article
Timee develops and operates "Timee," a gap-work service that matches "the hours people want to work" with "the hours businesses need workers." The product development organization has adopted Claude Code organization-wide, embedding AI across the entire development cycle — implementation, review, testing, and data analysis.
Over the last 30 days, roughly 200 members have used Claude Code. About 80% of them use some Skill, and Skills are taking root not as individual ingenuity but as "a shared team pattern."
Top 5 Skills
| rank |
Skill name |
Overview |
| 1 |
Data analysis (BigQuery, etc.: bq-analysis / bq-studio / query-production and others — 20 Skills) |
Just state your analysis goal in natural language, and it runs end to end: table exploration, SQL construction, execution, and interpretation. Domain glossaries and KPI definitions are built into the Skills, handling company-specific data structures. (Uses: 1,546) |
| 2 |
Git operations & commits (git-commit / commit / branch-prefix and others — 28 Skills) |
Automates operations that comply with project-specific commit message conventions and branch naming rules. 28 Skills exist, customized per team and repository. (Uses: 620) |
| 3 |
Testing & quality assurance (rspec / rubocop / steep-check and others — 16 Skills) |
Runs RSpec tests, RuboCop static analysis, and Steep type checking directly from Claude Code, and on failure goes as far as error analysis and fix proposals. Includes test design Skills based on the QA handbook. (Uses: 462) |
| 4 |
PR creation & code review (pr-create / code-review / android-code-review and others — 24 Skills) |
Generates PR descriptions by organizing change intent and impact scope from code diffs, and automates review perspective checks. Individually optimized for backend and mobile repositories. (Uses: 335) |
| 5 |
Design & handbooks (design-doc / backend-handbook / qa-handbook and others — 35 Skills) |
Turns Design Doc creation, story refinement, and referencing/executing the backend development handbook into Skills. Structures organizational knowledge as Skills, preventing design decisions from becoming person-dependent. (Uses: 237) |
Measurement period: 2026/06/07 - 07/07
Note: Rankings are based on usage counts. Since multiple Git and Ruby Skills would rank individually, they were aggregated by genre so the overall picture of usage is easier to see.
Why They Built These Skills
Data analysis (bq-analysis): toward an organization where you can touch data without writing SQL
At Timee, BigQuery is used daily for measuring the effect of initiatives and monitoring KPIs. However, members who could write SQL were limited. Even simple aggregations like "I want to see last week's repeat rate by region" required PdMs and business planners to file requests to engineers, and the wait time was a bottleneck for decision-making.
The bq-analysis Skill was built to resolve this. Just state your analysis goal in natural language, and everything from table identification to SQL construction, execution, and interpretation runs end to end. Domain glossaries and KPI formulas are built into the Skill so company-specific data structures are handled correctly.
As a result, with 1,546 uses — the most of any genre — it became the most used Skill in the organization across all roles.
Looking at users by role, engineers (43%) are the largest group by headcount. However, looking at usage rates relative to each role's population, the trend changes. 44% of PdMs and 41% of data analysts use it — roughly twice the rate of engineers (22%). Designers also use it at a comparable level of 22%.
Roles that don't write SQL gaining direct access to data eliminated the wait on engineer requests and sped up decision-making — that is what this skew in usage rates reflects.
PR creation & code review: achieving both review quality and speed
At PR creation time, feedback that lowered review efficiency — "the intent of the change can't be read," "unclear whether there are tests" — occurred chronically. Review perspectives also varied by reviewer, and multi-person reviews had become the norm to reduce the risk of oversights.
The pr-create Skill automatically organizes change intent, impact scope, and test presence from code diffs to generate the PR description, and the code-review Skill performs advance checks along review perspectives (bugs, performance, security, etc.).
A notable point is having different Skill variants for backend and mobile (Android). By incorporating platform-specific perspectives — such as the pr-create-android and android-code-review Skills — they also address platform-specific issues that generic review Skills can't fully catch. About 50 people use them, which we believe is raising the floor of review quality across the organization.
Design & handbooks: structuring tacit knowledge into "executable knowledge"
Backend development involves many design decisions. Knowledge in experienced members' heads — "design guidelines for async processing," "timing of legal checks," "table design patterns" — had its issues. Even when compiled as documentation, it went unread, or judging how to apply it to a given situation was difficult.
The backend development handbook and QA handbook package this knowledge as Claude Code Skills. Launching the Skill during the design phase delivers an experience where design direction is organized interactively while referencing the relevant handbook sections. By changing documentation from "something you read" into "something you use," it is improving the organization's design quality and accelerating onboarding.
Users are primarily engineers (about 66%). However, by usage rate relative to each role's population, data analysts (24%), PdMs (20%), and QA (20%) are also at high levels, and non-engineer roles account for about 30% of users. PdMs check backend constraints when refining stories, data analysts grasp the intent behind table designs — it is used as "domain knowledge supplementation" across roles. Skills that handle design documents themselves, like Design Doc, also appear to be spreading to PdMs, designers, and frontend engineers.
How Claude Code Usage Changed After Adopting Skills
Before Skills were put in place, how Claude Code was used varied from member to member, and even the entry point — "what to ask for, at what granularity" — was person-dependent. What organizing by genre revealed is that the effect of Skills shows along two axes: "standardization of development workflows" and "expansion of the user base."
The three genres of PR creation, testing, and Git were placed in repositories as project-common Skills, enabling the whole team to work in the same patterns, so development flow quality no longer depends on individuals. Meanwhile, data analysis becoming the top genre is proof that Claude Code usage has spread to PdMs and business planners who don't write SQL.
Currently, about 80% of the roughly 200 people using Claude Code use some Skill on a daily basis.
Behind the 35 Skills in use in the design & handbook genre is the initiative that turned the backend/QA handbooks from "documents you read" into "Skills you launch." Through this, Skills are starting to function as a means of increasing the reproducibility of tacit knowledge as well.
Usage measurement with OpenTelemetry continues, and an operational cycle of judging adoption and revisiting Skills is also taking root.
◆ Written by: Miki Hayashi (AgentHarnessGroup, AI & Data Division, Timee, Inc.)
Why Not Analyze Yours Too?
Reading through each company's Skills, you can see that none of them were complete from the start. They were all built around on-the-ground challenges and refined while observing their effects and how they were used. It is likely this steady accumulation that is lifting AI adoption across entire organizations. There is no single right answer for building out Skills — polishing them starting from how they are actually used at your company may seem like a detour but is the fastest path.
So — at your company, which Skills are used, and how much? As a first step, we've prepared a free analysis prompt that analyzes the number and content of Skills used in your personal environment. Based on your Claude Code logs, you can check which Skills you use most and spot trends for improvement.
Get the free analysis prompt here
Analyze your own (Claude Code's) local usage logs and create a Top 5 ranking of the Claude Code Skills I use most.
## Premises and cautions
- The analysis targets only the local logs (*.jsonl) under `~/.claude/projects/`. Only read files — never send their contents anywhere or modify them
- Depending on log retention settings, the full history may not be available. Clearly state in the results the period you were actually able to aggregate
## Steps
### 1. Extract usage records (target period: last 30 days)
Skill usage is recorded in the logs in two formats, so extract both.
- Records of the user manually launching with `/skill-name`: the `<command-name>` tag inside user messages
- Records of the AI launching automatically: tool_use with `"name":"Skill"` inside assistant messages (input.skill is the Skill name)
Reference commands (adjust to your environment if they don't work):
CUTOFF=$(date -v-30d +%Y-%m-%d 2>/dev/null || date -d '30 days ago' +%Y-%m-%d)
# Manual launches by the user
grep -h '<command-name>' ~/.claude/projects/*/*.jsonl \
| awk -v c="$CUTOFF" -F'"timestamp":"' '{split($2,a,"T"); if (a[1] >= c) print $0}' \
| grep -oh '<command-name>/[^<]*</command-name>' \
| sed -E 's|<command-name>/([^<]*)</command-name>|\1|'
# Automatic launches by the AI
grep -h '"name":"Skill"' ~/.claude/projects/*/*.jsonl \
| awk -v c="$CUTOFF" -F'"timestamp":"' '{split($2,a,"T"); if (a[1] >= c) print $0}' \
| grep -oh '"name":"Skill","input":{"skill":"[^"]*"' \
| sed -E 's|.*"skill":"([^"]*)"|\1|'
### 2. Normalization and exclusions
- Normalize the `plugin-name:skill-name` format to the skill-name part, and sum counts treating manual launches and AI automatic launches as the same Skill
- Exclude Claude Code built-in commands (clear / compact / config / cost / doctor / help / login / logout / mcp / model / permissions / plugin / resume / status / copy / usage, etc.) since they are not Skills. Also treat entries with no Skill definition file that look like core feature names as exclusion candidates, and note any exclusions in a footnote
- Exclude obvious noise picked up from this analysis session's own records (such as `[^`)
### 3. Get overviews
For each Skill in the Top 5, find its definition file, read the frontmatter description, and summarize it in 1-2 sentences in English.
- Personal: ~/.claude/skills/<skill-name>/SKILL.md
- Project: each repository's .claude/skills/<skill-name>/SKILL.md and .claude/commands/<skill-name>.md
- Plugin: **/skills/<skill-name>/SKILL.md and **/commands/<skill-name>.md under ~/.claude/plugins/
If no definition is found, infer from the context of the logs where the Skill was used and mark it "(inferred)".
### 4. Output the results
Output in Markdown in the following format.
Measurement period: YYYY/MM/DD - YYYY/MM/DD
| rank | Skill name | Overview |
|---|---|---|
| 1 | **skill-name** | Description of the Skill. (Uses: N) |
| 2 | ... | ... |
Finally, provide an "Analysis summary and insights" section covering:
- Analysis summary: total Skill usage count, number of distinct Skills used, and the ratio of manual to AI automatic launches
- Insights: usage characteristics readable from the skew in usage (development vs. non-development, etc.) and suggestions for Skills worth building or improving next
If you'd like to analyze organization-wide or team-level usage trends, or the impact of AI adoption initiatives before and after, you can analyze them for free with our product "Findy AI+" — please give it a try.
Findy AI+ is a platform for standardizing and maximizing generative-AI-powered development, such as Claude Code, across your entire organization. By visualizing which Skills are used, by whom, and how much, it becomes easier to judge both where to grow results and where to cut costs.
And, as with this article, we've prepared a one-week-only free trial of Findy AI+ to help you visualize and improve your Skills usage — so please take this opportunity to visualize yours.
Maximize the results of AI adoption and optimize costs. We hope this article becomes a starting point for thinking about that first step.
