New: 97,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Code Quality

by waybarrios in waybarrios/opencode-power-pack

Agents should invoke this skill for code reviews, linting/formatting setup, maintainability checks, complexity concerns, warning cleanup, coding standards, or quality gates in Rust, TypeScript…

MITAuto-check passedDevelopment

Install Code Quality

skills CLI
$ npx skills add waybarrios/opencode-power-pack --skill code-quality -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install waybarrios/opencode-power-pack code-quality --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/waybarrios/opencode-power-pack.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/code-quality .claude/skills/code-quality && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
code-quality
GitHub stars
533
Token cost
~1.8k tokens
SKILL.md length
643 words
Files
1
Skills in repo
32
Repo updated
First seen
Licence
MIT

At a glance

Agents should invoke this skill for code reviews, linting/formatting setup, maintainability checks, complexity concerns, warning cleanup, coding standards, or quality gates in Rust, TypeScript…

  • Works in 4 steps: Run static analysis: Linters, type… → Review against checklist:… → Check complexity metrics: Cyclomatic <… → …
  • Tasks that involve Code quality
  • SKILL.md covers Quick Start, Linting Configurations, Code Review Checklists and Complexity Metrics, plus 2 more sections
  • Calls cargo

What it does

Code Quality is an agent skill from waybarrios/opencode-power-pack. Agents should invoke this skill for code reviews, linting/formatting setup, maintainability checks, complexity concerns, warning cleanup, coding standards, or quality gates in Rust, TypeScript, Python, shell, and mixed repos.

Its SKILL.md is about 1.8k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Development, covering Code quality, Linting and formatting and Code review. It works with Rust, TypeScript and Python. The repository describes itself as: 54 rigorous skills for Codex, OpenCode, and Pi: code review, security audit, feature development, frontend design, MCP tools, Hugging Face ML/training, and more. The licence is MIT.

When your agent uses it

  • Tasks that involve Code quality
  • Tasks that involve Linting and formatting
  • Tasks that involve Code review

Example prompts

  • “Use the code-quality skill to agent should invoke this skill for code reviews, linting/formatting setup, maintainability checks, complexity…”
  • “/code-quality”

Requirements

  • Python 3

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

  1. Run static analysis: Linters, type checkers, formatters
  2. Review against checklist: Language-specific items below
  3. Check complexity metrics: Cyclomatic < 25, data flow < 25
  4. Report findings: Structured output with severity and recommendations

What it can do on your machine

Read from SKILL.md and the folder at commit 9dccb6d. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • cargo

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Code Quality loads about 1.8k tokens when it runs. Until then it costs about 60 tokens; SKILL.md has 643 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~60
When it runs · the whole SKILL.md, loaded when a task matches
~1.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from waybarrios/opencode-power-pack at commit 9dccb6d, republished under its MIT licence (© waybarrios). 643 words, ~1,794 tokens.

Download SKILL.mdSave it as .claude/skills/code-quality/SKILL.md (or your agent's skills folder).
name
code-quality
description
Agents should invoke this skill for code reviews, linting/formatting setup, maintainability checks, complexity concerns, warning cleanup, coding standards, or quality gates in Rust, TypeScript, Python, shell, and mixed repos.
license
MIT (modified; see UPSTREAMS.json)

Code Quality

Structured code review and quality enforcement across common tech stacks. Checklists, linting strategies, and metrics to keep codebases healthy.

Quick Start

Run a Code Quality Check
  1. Run static analysis: Linters, type checkers, formatters
  2. Review against checklist: Language-specific items below
  3. Check complexity metrics: Cyclomatic < 25, data flow < 25
  4. Report findings: Structured output with severity and recommendations

Linting Configurations

Rust — Clippy Config

Standard clippy configuration (in Cargo.toml or .clippy.toml):

toml
[lints.clippy]
cognitive_complexity = "warn"
pedantic = { level = "deny", priority = -1 }
nursery = { level = "deny", priority = -1 }
unwrap_used = "deny"

Standard commands:

bash
cargo fmt
cargo clippy --all-targets --all-features -- -D warnings
cargo check
cargo test -- --test-threads=1

Key rules to enforce:

  • No .unwrap() in non-test code (use ? or .expect("reason"))
  • All public items have rustdoc (#[warn(missing_docs)])
  • #[must_use] on functions that return values that should be checked
  • When using #[allow(...)], always add a comment explaining why
  • If no good explanation exists for #[allow(...)], fix the issue instead
TypeScript — ESLint + Strict Mode

Recommended tsconfig.json strictness:

json
{
  "compilerOptions": {
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true,
    "exactOptionalPropertyTypes": true
  }
}

Key rules to enforce:

  • No any — use unknown and type guards instead
  • No // @ts-ignore — fix the type issue or use // @ts-expect-error with explanation
  • Prefer const over let, never use var
  • Use discriminated unions for state modeling
  • Explicit return types on exported functions
Python — Ruff + Mypy

Recommended pyproject.toml:

toml
[tool.ruff]
target-version = "py312"
line-length = 88

[tool.ruff.lint]
select = ["E", "F", "W", "I", "N", "UP", "ANN", "B", "A", "C4", "DTZ", "ISC", "PIE", "PT", "RET", "SIM", "TCH", "ARG", "PTH", "ERA"]

[tool.mypy]
strict = true
warn_return_any = true
warn_unreachable = true

Key rules to enforce:

  • Type hints on all public functions and methods
  • Docstrings on all public classes, functions, and methods
  • Use pathlib.Path over os.path
  • Use uv as package manager
  • No bare except: — always catch specific exceptions

Code Review Checklists

Universal Checklist (All Languages)

Correctness:

  • Does the code do what it claims to do?
  • Are edge cases handled (empty collections, null/None, zero, negative)?
  • Are error paths handled gracefully?
  • Are there any off-by-one errors?

Clarity:

  • Can you understand the code without the PR description?
  • Are variable/function names descriptive and consistent?
  • Are complex sections commented with "why" (not "what")?
  • Is the code self-documenting where possible?

Architecture:

  • Does this change respect existing module boundaries?
  • Is the change at the right abstraction level?
  • Are dependencies reasonable (not pulling in a huge lib for one function)?

Testing:

  • Are new functions/methods covered by tests?
  • Do tests cover edge cases and error paths?
  • Are tests readable and maintainable?

Security (flag for a security follow-up if concerns found):

  • No hardcoded secrets or credentials
  • User input is validated before use
  • No SQL injection, XSS, or path traversal vectors
Rust-Specific Checklist
  • cargo fmt applied
  • cargo clippy clean (pedantic + nursery)
  • No .unwrap() outside tests
  • Error handling uses ? with proper error types
  • Public items have rustdoc comments
  • #[allow(...)] includes explanatory comment
  • New functions have unit tests
  • Cyclomatic complexity < 25 per function
  • Data flow complexity < 25 per function
Show full SKILL.md (242 more words)Show less
TypeScript/React-Specific Checklist
  • No any types
  • Strict mode compliance
  • Components have clear prop types
  • Hooks follow rules of hooks
  • No unnecessary re-renders (check memo/callback usage)
  • Bundle impact considered for new dependencies
Django/Python-Specific Checklist
  • Type hints present on public interfaces
  • Ruff + mypy clean
  • No N+1 queries (use select_related/prefetch_related)
  • Migrations are reviewed and reversible
  • No business logic in views (use service layer)

Complexity Metrics

Cyclomatic Complexity

Measures the number of independent paths through code. Recommended threshold: < 25.

ComplexityRisk LevelAction
1-10LowSimple, well-structured code
11-20ModerateConsider simplification if growing
21-24HighRefactoring recommended
25+ViolationMust refactor before merge

How to reduce:

  • Extract helper functions for each branch
  • Use early returns / guard clauses
  • Replace complex conditionals with lookup tables or pattern matching
  • Use strategy pattern for variant-dependent behavior
Data Flow Complexity

Measures how many variables interact within a function. Recommended threshold: < 25.

How to reduce:

  • Extract pure functions that take fewer parameters
  • Group related parameters into structs/objects
  • Split functions that transform data in multiple stages
Measurement Tools
LanguageToolCommand
Rustcargo clippy (cognitive_complexity)Built into clippy config
TypeScripteslint-plugin-sonarjsConfigure complexity rule
Pythonradonradon cc <file> -s -a
PythonruffRule C901 (mccabe complexity)

Review Output Format

When delivering a code review:

markdown
## Code Review: [PR/File/Module]

**Date:** YYYY-MM-DD

### Summary
[1-2 sentences: overall quality assessment]

### Findings

| # | Severity | File | Line(s) | Finding | Suggestion |
|---|---|---|---|---|---|
| 1 | High | src/app.rs | 45-67 | Cyclomatic complexity 28 (limit: 25) | Extract match arms into helper functions |
| 2 | Medium | src/ui.rs | 120 | Unwrap without context | Use `.expect("reason")` or `?` |

### Positive Observations
[What's well-written — acknowledge good code]

### Metrics
- Linter: [clean / N warnings]
- Tests: [pass / fail]
- Complexity: [within limits / violations noted above]

### Security Notes
[Items to flag for follow-up, if any]

Integration

  • Can run linters, formatters, and type checkers without asking, per the project's AGENTS.md/CLAUDE.md execution policies.
  • Cross-reference: this pack's code-reviewer skill for adversarial review of a focused change set, and design-patterns for fixing complexity violations through better structure.

© waybarrios, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/code-quality of waybarrios/opencode-power-pack.

Open the folder on GitHubat commit 9dccb6d

Compare with similar skills

Code Quality next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Code Quality compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Code Quality this skillwaybarrios/opencode-power-pack533—~1.8kAutomated safety check: PassMIT
Cross-Language Coding Standardszereight/gitlab-mcp2k1 repos~1.4kAutomated safety check: PassMIT
Code Reviewerjewbetcha/opentrace1162 repos~1.1kAutomated safety check: NotesMIT
Coding Agentmastra-ai/mastra29k—~2.3kAutomated safety check: PassCustom licence
Strict Programming Practicescode-yeongyu/oh-my-openagent70k—~9.5kAutomated safety check: PassCustom licence
Code Review Excellenceandrew-yangy/gru-ai155—~1.7kAutomated safety check: NotesMIT

Similar skills

  • Cross-Language Coding Standards

    zereight/gitlab-mcp

    Shared reference for naming, function size, complexity and error handling rules that reviewer agents apply across TypeScript, Python, Go, Rust, Java, C# and Swift.

    2k GitHub starsUsed in 1 repo~1.4k tokens
    DevelopmentAuto-check passed

  • Code Reviewer

    jewbetcha/opentrace

    Comprehensive code review skill for TypeScript, JavaScript, Python, Swift, Kotlin, Go.

    116 GitHub starsUsed in 2 repos~1.1k tokens
    DevelopmentAuto-check: notes

  • Coding Agent

    mastra-ai/mastra

    Authoring playbook for building agents that write, edit, review, or refactor code.

    29k GitHub stars~2.3k tokensUpdated today
    DevelopmentAuto-check passed

  • Strict Programming Practices

    code-yeongyu/oh-my-openagent

    Applies strict, type-first coding rules for Python, Rust, TypeScript and Go, loading the matching language reference before the agent writes or edits any code.

    70k GitHub stars~9.5k tokensUpdated today
    DevelopmentAuto-check passed

  • Code Review Excellence

    andrew-yangy/gru-ai

    Provides comprehensive code review guidance for React 19, Vue 3, Rust, TypeScript, Java, Python, and C/C++.

    155 GitHub stars~1.7k tokensUpdated 7 mo ago
    DevelopmentAuto-check: notes

  • Code Quality

    notque/vexjoy-agent

    Code quality: cleanup, linting, formatting, quality gates. An agent skill from notque/vexjoy-agent.

    435 GitHub stars~1.5k tokensUpdated 4 days ago
    DevelopmentAuto-check: notes

More from waybarrios/opencode-power-pack

All 32 skills in this repo

  • Hf Cloud Sagemaker Iam Preflight

    waybarrios/opencode-power-pack

    Verify or select a SageMaker execution role before creating models, endpoints, or training jobs.

    533 GitHub stars~1.6k tokensUpdated yesterday
    Auto-check passed

  • Huggingface LLM Trainer

    waybarrios/opencode-power-pack

    Train or fine-tune language models with TRL or Unsloth on Hugging Face Jobs, including SFT, DPO, GRPO, reward models, and GGUF conversion.

    533 GitHub stars~3k tokensUpdated yesterday
    Auto-check passed

  • Huggingface Vision Trainer

    waybarrios/opencode-power-pack

    Train object-detection, image-classification, or SAM segmentation models on Hugging Face Jobs.

    533 GitHub stars~2.7k tokensUpdated yesterday
    Auto-check passed

  • Codeql

    waybarrios/opencode-power-pack

    Run CodeQL database creation and security queries, add data-extension models, or process CodeQL SARIF.

    533 GitHub starsUsed in 2 repos~3.7k tokens
    Auto-check passed

  • Semgrep

    waybarrios/opencode-power-pack

    Run Semgrep static analysis across a codebase, optionally using Semgrep Pro for cross-file taint analysis.

    533 GitHub stars~2.4k tokensUpdated yesterday
    Auto-check passed

  • Insecure Defaults

    waybarrios/opencode-power-pack

    Detects fail-open insecure defaults (hardcoded secrets, weak auth, permissive security) that allow apps to run insecurely in production.

    533 GitHub starsUsed in 2 repos~1.3k tokens
    Auto-check passed

Works with

Categories

Questions about Code Quality

What does Code Quality do?

Agents should invoke this skill for code reviews, linting/formatting setup, maintainability checks, complexity concerns, warning cleanup, coding standards, or quality gates in Rust, TypeScript…. Code Quality is an agent skill from waybarrios/opencode-power-pack. Agents should invoke this skill for code reviews, linting/formatting setup, maintainability checks, complexity concerns, warning cleanup, coding standards, or quality gates in Rust, TypeScript, Python, shell, and mixed repos.

When should I use Code Quality?

Code Quality fits situations like: tasks that involve Code quality; tasks that involve Linting and formatting; tasks that involve Code review.

How do I install Code Quality in Claude Code?

Run `npx skills add waybarrios/opencode-power-pack --skill code-quality -a claude-code`. Or copy the skill folder (skills/code-quality in waybarrios/opencode-power-pack) into .claude/skills/code-quality in your project. Claude Code loads it when a task matches its description.

How do I install Code Quality in Codex?

Run `npx skills add waybarrios/opencode-power-pack --skill code-quality -a codex`. Or copy the skill folder (skills/code-quality in waybarrios/opencode-power-pack) into .agents/skills/code-quality in your project. Codex loads it when a task matches its description.

Can I use Code Quality in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add waybarrios/opencode-power-pack --skill code-quality -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/code-quality, .gemini/skills/code-quality, .github/skills/code-quality and .opencode/skills/code-quality in your project.

What does Code Quality need to run?

Going by SKILL.md and its folder, Code Quality needs the command-line tools its instructions call (cargo). Our summary lists: Python 3.

Does Code Quality access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Code Quality safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Code Quality use?

Code Quality is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Code Quality use?

About 1.8k tokens (SKILL.md is roughly 7.2k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Code Quality?

Skills that share tags, products or a category with Code Quality: Cross-Language Coding Standards (zereight/gitlab-mcp, 2k stars), Code Reviewer (jewbetcha/opentrace, 116 stars), Coding Agent (mastra-ai/mastra, 29k stars) and Strict Programming Practices (code-yeongyu/oh-my-openagent, 70k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Code Quality?

waybarrios (a GitHub user) maintains it in waybarrios/opencode-power-pack, which has 533 GitHub stars. The repository holds 32 skills in this directory. The repository was last updated on October 6, 2026.

Source: waybarrios/opencode-power-pack on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.