awesome-skills: Production-Ready Claude Code Skills

Production-ready Claude Code Skills with design rationale, quantitative evaluation, golden test fixtures, and end-to-end engineering workflow integration.

A curated system for AI skill engineering — not just a prompt collection. Built for Claude Code and applicable to any AI coding assistant, this project covers the full loop from reusable skill methodology to skill-specific design rationale to quantitative evaluation and real software engineering workflow integration.

• 33 production-ready Claude Code skills: Go, testing, security, CI/CD, database, cache, infrastructure, research, docs, planning
• 41 installable skills in total: 33 production-ready skills + 8 multi-agent Go review components used by the orchestration architecture
• 46 paired design rationale docs (EN + ZH), one explanation track for each skill
• 64 paired evaluation reports (EN + ZH) with quantitative metrics
• 364 golden test fixtures + 65 Python test files for deterministic regression
• Testing skills: unit-test · tdd-workflow · api-integration-test · e2e-test · fuzzing-test
• Delivery pipeline: go-makefile-writer → git-commit → create-pr → go-ci-workflow → go-code-reviewer → security-review

Quick Start

Option 1 — Install with the skills CLI (recommended)

Works with Claude Code, Cursor, GitHub Copilot, and 15+ other agents:

# Install a single skill globally
npx skills add johnqtcg/awesome-skills --skill <skill-name> -g

# Install a curated set
npx skills add johnqtcg/awesome-skills --skill go-review-lead systematic-debugging unit-test -g

# Install all 41 skills at once (33 production-ready + 8 multi-agent review components)
npx skills add johnqtcg/awesome-skills --all -g

Browse and search skills interactively:

npx skills find

Install scope note:

• The repository exposes 29 installable skills in total.
• The 33 production-ready skills are the fully documented set with rationale, evaluation, and output examples.
• The additional 8 skills are reusable Go review orchestration components for the multi-agent review architecture. They are installable and regression-tested, but are not counted as standalone production-ready skills yet.

Option 2 — Install manually

1. Browse the skill list below and find one relevant to your workflow
2. Copy the skills/<name> directory into your project:
   • Project-level: .claude/skills/<name>
   • User-level (all projects): ~/.claude/skills/<name>
3. In Claude Code, the skill activates automatically when the task matches

To understand the skill design methodology:

• English: bestpractice/README.md
• Chinese: bestpractice/README.zh-CN.md

To understand why a specific skill is designed the way it is:

• English: rationale/index.md
• Chinese: rationale/index.zh-CN.md

Overview

Main documentation entry points:

• methodology: bestpractice/README.md
• skill-specific design explanation: rationale/index.md

The core goal of this project is not to show how to write prompts. It is to answer four harder questions:

1. How should a high-quality skill be designed?
2. How do those design principles show up in the structure, gates, and tradeoffs of a specific skill?
3. How do you prove that it actually works?
4. How do you integrate it into daily engineering workflows instead of leaving it as a demo?

Highlights

1. Five-layer traceable architecture

The project is organized as a rare end-to-end chain:

bestpractice/ → rationale/ → skills/ → evaluate/ → outputexample/

Those five layers are not just grouped content. They form a traceable knowledge loop:

• methodology explains how a skill should be designed
• rationale explains how those principles are carried through in a specific skill
• skill examples show the actual executable artifact
• review reports test whether the skill is actually good
• output examples prove what it can produce in real tasks

That structure makes the project substantially stronger than a typical prompt or skill example project, because readers can move from general principles to design logic to execution artifact to measured outcomes.

2. rationale - clarifies each skill's design

Each skill has design docs in English and Chinese, such as rationale/google-search/design.md and rationale/google-search/design.zh-CN.md. They explain:

• what problem the skill is meant to solve
• why its workflow, gates, structure, and output format are designed that way
• why common alternatives fall short
• what makes the final design worth paying attention to

That turns the project into more than a set of copyable examples. It also becomes a body of design logic that readers can study, question, and reuse.

3. General methodology drives skill design

The highest-leverage assets here are bestpractice/ and rationale/, not the raw number of skills under skills/. The methodology is deliberately language-agnostic and platform-agnostic: mandatory gates, anti-examples, honest degradation, progressive disclosure, output contracts, and quantitative evaluation can be reused far beyond this project.

In other words, the project is teaching people how to build professional skills, not just handing out a bag of ready-made prompts.

4. A quantitative evaluation framework

bestpractice/Evaluation.md turns “is this skill good?” into a quantitative question across three dimensions:

• trigger accuracy
• real-task performance
• token cost-effectiveness

The value of that framework is visible in the paired review reports under evaluate/. Concrete examples include:

• go-code-reviewer: +36 percentage points in subtle-scenario signal-to-noise, with 347x developer-time ROI
• unit-test: +38.4 percentage points in assertion pass rate
• google-search: +74.1 percentage points in assertion pass rate

That is much stronger than saying “these skills seem useful,” because it gives readers traceable numbers, evaluation process, and iteration evidence.

5. A regression system built for engineering maintenance

This project does not rely on “use one LLM to judge another LLM” as its primary guardrail. Instead, it uses deterministic regression assets:

• 132 golden JSON fixtures
• 29 Python test files
• contract tests for required gates, outputs, and structure
• golden-scenario tests for real task coverage

Those checks run quickly, are versionable, and are easy to diff and rerun. That design choice reflects strong engineering judgment: critical quality constraints should live in deterministic scripts wherever possible, not only in natural-language instructions.

6. Skills are designed to compose into real workflows

The backend-oriented skills do not just work in isolation. They line up into an engineering pipeline:

go-makefile-writer → git-commit → create-pr → go-ci-workflow → go-code-reviewer → security-review

The project also includes review reports, workflow examples, and output artifacts that show this is not a paper design. It is a workflow system that can be reused and validated in real engineering practice.

7. A view of knowledge: tacit -> explicit -> executable

Underneath the concrete files is a stronger idea: useful engineering knowledge should move through three layers:

• tacit experience in an expert's head
• explicit rules in documentation
• executable constraints in a skill, script, or test

That progression is one of the most important ideas in the project. It reframes skills as a way to turn unstable personal intuition into shared, inspectable, and enforceable capability.

Project Structure

.
├── bestpractice/        # Skill best-practice docs, in Chinese and English
├── rationale/           # Skill-specific design rationale, in Chinese and English
├── skills/              # High-quality skill examples written with those best practices
├── evaluate/            # Skill review reports, in Chinese and English
├── outputexample/       # Real output examples
├── README.md            # README document
├── README.zh-CN.md
└── LICENSE

The five core directories serve these roles:

Recommended Reading Path

If this is your first time in the project, this order works best:

1. Start with bestpractice/README.md to build the overall picture
2. Read the design rationale for a specific skill, for example rationale/google-search/design.md
3. Open the skill itself, for example skills/google-search/SKILL.md
4. Read its review report, for example evaluate/google-search-skill-eval-report.md
5. Then look at its real output, for example outputexample/google-search/ai-bubble-or-platform-shift-march-2026.pdf

If you prefer Chinese, start from bestpractice/README.zh-CN.md.

Documentation System

bestpractice/ is the methodology entry point for the whole project:

• Fundamentals.md
• Advanced.md
• Evaluation.md
• Iteration.md
• Integration.md
• Architecture.md

These documents mainly answer:

• why skills matter as a key abstraction for AI coding assistants
• what design patterns high-quality skills should follow
• how to evaluate the real value of a skill quantitatively
• how to improve a skill systematically when misses or quality issues show up
• how to integrate skills into engineering workflows instead of leaving them inside a single chat
• how to scale heavy skills with Multi-Agent architecture when attention starts to dilute

Skill Design Docs

rationale/ is where the project explains the design of each skill. It ties the general principles in bestpractice/ to the concrete implementations under skills/.

Each design doc focuses on one skill and explains:

• the concrete problem the skill is trying to solve
• why its gates, structure, references, and output format are designed the way they are
• why common alternatives tend not to work as well
• what the main strengths of the design are

Representative examples:

• rationale/google-search/design.md
• rationale/update-doc/design.md
• rationale/go-code-reviewer/design.md

Skill Examples

All high-quality skills in this project live under skills/, with each skill centered on its own SKILL.md. For the design explanation behind any specific skill, read the paired rationale doc under rationale/<name>/. The skills are not isolated capabilities. They can be grouped by use case, and the backend-oriented skills can work together as a full quality pipeline.

Backend Development: a complete quality pipeline

The value of the backend-related skills is not just that each skill is useful on its own. They can connect end-to-end and form an engineering workflow from coding to merge:

Coding
  ↓
Write / fix tests
  (unit-test · tdd-workflow · api-integration-test · e2e-test · fuzzing-test)
  ↓
make fmt / make lint (local quality checks generated by go-makefile-writer)
  ↓
git commit (git-commit skill: secret scan + quality gates + standardized message)
  ↓
git push
  ↓
create PR (create-pr skill: multiple gates + structured PR body)
  ↓
CI triggered
  ├── make ci (format + tests + lint + coverage + build)
  ├── make docker-build (container image validation)
  ├── Claude Code Review (go-code-reviewer skill: automated code review)
  └── govulncheck / security checks (security-review skill focuses on risk models)
  ↓
Human review + merge

The key skills in that pipeline are:

Testing and Validation

These skills move code from “written” to “verified.” Together they cover unit tests, TDD, integration tests, E2E tests, fuzzing, and complex debugging.

For a full example, see: https://github.com/johnqtcg/issue2md (.github/workflows/ci.yml)

Database, Cache & Infrastructure

These skills cover production-safe schema migrations across multiple databases, caching strategy design, monitoring and alerting setup.

Search, Research, and Reports

These skills are suited for information gathering, fact-checking, comparison, and formal research output.

Technical Docs and Writing

These skills focus on turning engineering knowledge into maintainable documents that teams can reuse directly.

Tool Execution and Task Automation

These skills focus more on getting a task executed than on code quality itself.

Structured Thinking

This skill turns scattered facts and intuition into a structure an audience can absorb quickly.

US Equity Analysis (multi-agent system)

A stock-analysis-lead orchestrator drives a seven-layer fundamental "X-ray" of a single US-listed stock by dispatching six vertical equity-research skills as parallel agents, then synthesizing a buy/hold/sell verdict. The skills compose as a system, mirroring the go-review-lead multi-agent pattern. Scope is single-stock US-equity fundamental analysis only — not trading signals, technical analysis, options, crypto, ETFs, or non-US listings.

Review Reports and Output Examples

What makes this project different from a typical “skills example project” is that it does not just show the skills. It also shows:

1. why a skill was designed that way
2. why a given skill is good
3. what it actually produced in real tasks

You can read them side by side:

• design rationale: rationale/
• review reports: evaluate/
• output examples: outputexample/

Typical examples:

• google-search
  • rationale: rationale/google-search/design.md
  • review: evaluate/google-search-skill-eval-report.md
  • output: outputexample/google-search/ai-bubble-or-platform-shift-march-2026.pdf
• unit-test
  • rationale: rationale/unit-test/design.md
  • review: evaluate/unit-test-skill-eval-report.md
  • output: outputexample/unit-test/
• yt-dlp-downloader
  • rationale: rationale/yt-dlp-downloader/design.md
  • output screenshots: outputexample/yt-dlp-downloader/

Governance

If you want to contribute or need project governance details, start here:

• Contribution guide: CONTRIBUTING.md
• Security policy: SECURITY.md
• Code of conduct: CODE_OF_CONDUCT.md

Who This Is For

• people who want to systematically learn how to write high-quality skills
• people who want to turn Claude Code / Agent capabilities into reusable assets
• people who want to study the full loop of methodology + rationale + skill + review + output example
• people who want to integrate AI capability into real engineering workflows rather than stop at prompt demos

License

This project is licensed under MIT. See LICENSE.