Code Quality

A comprehensive guide to Test-Driven Development (TDD) that enforces the red-green-refactor cycle. Provides strict workflows for writing tests before implementation, common rationalizations to avoid, and testing anti-patterns to watch for when creating mocks or test utilities.

This skill provides a comprehensive verification workflow for Claude Code sessions. It runs build verification, type checking, linting, test suites with coverage, basic security scans for leaked secrets, and diff reviews to ensure code quality before creating pull requests.

This skill enforces test-driven development principles by guiding developers through TDD workflows. It provides comprehensive patterns for unit tests, integration tests, and E2E tests with examples using Jest, Vitest, and Playwright, along with mocking strategies and coverage requirements.

This skill provides comprehensive coding standards and best practices for TypeScript, JavaScript, React, and Node.js development. It covers principles like KISS, DRY, and YAGNI, along with practical guidance on variable naming, error handling, async patterns, React components, API design, and testing standards.

This skill provides comprehensive guidance for setting up and configuring ShellCheck, a static analysis tool for shell scripts. It covers installation, configuration files (.shellcheckrc), common error codes and fixes, CI/CD integration patterns, and best practices for maintaining shell script quality.

This skill reviews your frontend UI code against Vercel's Web Interface Guidelines. It fetches the latest rules from GitHub and checks your specified files for compliance with accessibility, performance, and semantic HTML best practices, outputting findings in a concise file:line format.

This skill helps maintain and improve CLAUDE.md files in your repositories. It audits existing files against quality criteria, provides detailed scoring reports, and suggests targeted improvements to ensure Claude Code has optimal project context for future sessions.

A comprehensive guide for fuzzing Rust projects using cargo-fuzz with libFuzzer backend. Covers installation, harness writing, sanitizer integration, coverage analysis, and provides real-world examples for finding bugs in Rust code.

This skill guides users through creating production-quality Semgrep rules for detecting security vulnerabilities and bug patterns. It follows a test-first approach: write test cases, analyze AST structure, write the rule, and iterate until all tests pass. Supports both taint mode for data flow analysis and pattern matching for syntactic detection.

This skill systematically assesses codebase maturity using Trail of Bits' Building Secure Contracts framework. It evaluates 9 categories including arithmetic safety, access controls, complexity management, documentation, and testing, producing a detailed scorecard with ratings (0-4) and actionable improvement recommendations.

This skill provides comprehensive TypeScript development guidelines including strict compiler configuration, ESLint setup with type checking, Jest testing patterns, GitHub Actions CI/CD workflows, and pre-commit hooks. It documents best practices and anti-patterns to help maintain high code quality in TypeScript projects.

Guides developers through analyzing existing repositories to understand their structure, conventions, and tech stack. Provides step-by-step instructions for setting up development guardrails like pre-commit hooks, linters, formatters, and commit message validation without disrupting existing patterns.

A methodology skill that helps prevent semantic code duplication by maintaining a CODE_INDEX.md capability index. It provides guidelines for checking existing code before writing new functions, documenting files and functions properly, and periodically auditing for duplicate functionality.

This skill provides comprehensive guidance for software development following Clean Architecture and Domain-Driven Design principles. It covers code style rules, naming conventions, anti-patterns to avoid, and emphasizes a library-first approach where developers should leverage existing solutions before writing custom code.

A constitution validation skill that creates project governance rules by exploring your codebase to discover actual patterns and conventions. It supports three rule levels (L1 critical, L2 blocking, L3 advisory) and generates compliance reports to enforce security, architecture, code quality, and testing standards.

Safe Refactoring provides a structured methodology for improving code quality without changing functionality. It includes a code smells catalog, refactoring patterns reference, and enforces behavior preservation through mandatory test validation before and after each change.

Use when Code implementation and refactoring, architecturing or designing systems, process and workflow improvements, error handling and validation. Provide tehniquest to avoid over-engineering and apply iterative improvements.

Use when implementing any feature or bugfix, before writing implementation code - write the test first, watch it fail, write minimal code to pass; ensures tests actually verify behavior by requiring failure first

Ultimate Bug Scanner (UBS) is a comprehensive static analysis tool that automatically scans your code for bugs, security issues, and code quality problems. It integrates with Claude Code via hooks to run scans on file saves and blocks dangerous git commands like 'git reset --hard' or 'rm -rf' to prevent accidental data loss.