by affaan-m
terminal-ops is an evidence-first repo execution skill for terminal work. Use it to run commands, inspect git state, debug CI or builds, and make narrow fixes with proof of what changed and what was verified. This terminal-ops guide helps reduce guesswork for Code Editing and repo operations.
by affaan-m
rust-patterns is a practical guide for idiomatic Rust development, covering ownership, error handling, traits, concurrency, module boundaries, and backend-focused design choices for safer, cleaner code.
by affaan-m
repo-scan is a cross-stack source audit skill that classifies files, detects embedded third-party libraries, and helps you judge what is core, duplicated, or dead weight. It is useful for repo-scan for Code Review, legacy migrations, and refactor planning. See repo-scan install and repo-scan usage guidance in the skill.
by affaan-m
pytorch-patterns helps you write, review, and debug PyTorch code with device-agnostic patterns, reproducible experiments, and explicit tensor handling. Use the pytorch-patterns skill for cleaner training loops, model refactors, and practical PyTorch guidance.
by affaan-m
The python-patterns skill helps you write, review, and refactor Python code with idiomatic patterns, readable structure, type hints, and practical exception handling. Use it for new code, package/module design, or cleaner refactors that preserve behavior and follow Python conventions.
by affaan-m
plankton-code-quality is a write-time code quality system for Claude Code. It formats, lints, and can trigger Claude-powered fixes after each file edit, helping catch issues during editing instead of after commit or CI. Ideal for the plankton-code-quality skill, guide, and Code Editing workflows.
by affaan-m
perl-patterns is a modern Perl 5.36+ skill for writing, reviewing, and refactoring idiomatic code. Use this perl-patterns guide to guide code generation, simplify legacy boilerplate, and keep modules, signatures, and error handling maintainable.
by affaan-m
nuxt4-patterns is a Nuxt 4 skill for hydration safety, route rules, lazy loading, and SSR-safe data fetching. Use the nuxt4-patterns skill to make better Frontend Development decisions, reduce mismatches, and apply the right pattern for each page or component.
by affaan-m
kotlin-patterns helps you write and review idiomatic Kotlin using null safety, immutability, sealed hierarchies, coroutines, extension functions, and DSL builders. Use this kotlin-patterns skill for Kotlin-native code generation, refactoring, and Gradle Kotlin DSL decisions with less guesswork.
by affaan-m
dart-flutter-patterns is a practical Dart and Flutter skill for frontend development, covering null safety, immutable state, async composition, widget structure, state management, GoRouter navigation, Dio networking, testing, and clean architecture. Use the dart-flutter-patterns guide to choose production-ready patterns for new features and refactors.
by affaan-m
cpp-coding-standards is a C++ coding standards guide based on the C++ Core Guidelines. Use it for writing, reviewing, and refactoring modern C++ with a focus on safety, clarity, maintainability, RAII, type safety, and good design. Ideal for cpp-coding-standards for Code Review and practical team decisions.
by garrytan
The investigate skill guides systematic debugging and root-cause analysis for broken, flaky, or unexpected behavior. Use it for code review, incident triage, bug fixes, and "it worked yesterday" cases when you need evidence before changing code. It follows a four-phase workflow: investigate, analyze, hypothesize, implement.
by garrytan
Review skill for pre-landing PR review. Use it to check diffs against the base branch for SQL safety, trust-boundary issues, shell injection, enum completeness, and other structural risks. Best for a review guide that helps agents flag real defects fast with less guesswork than a generic prompt.
by mattpocock
migrate-to-shoehorn helps you replace `as` casts in TypeScript tests with @total-typescript/shoehorn for safer partial fixtures. Use this migrate-to-shoehorn skill when you need to clean up cast-heavy test data, follow the migrate-to-shoehorn guide, or standardize migrate-to-shoehorn for Test Automation.
by mattpocock
The zoom-out skill helps an agent step back from a narrow code question and map the broader system, including related modules, callers, and project vocabulary. It is best for Code Editing workflows when you need context before making a change, especially in unfamiliar repos or subsystems.
by mattpocock
request-refactor-plan helps turn a vague refactor request into a detailed plan with tiny commits, repo verification, scope boundaries, test coverage review, and a GitHub issue. Use it for refactoring RFCs, incremental change plans, and safer implementation prep.
by wshobson
python-type-safety is a focused skill for adding safer Python type hints, generics, protocols, and checker-friendly patterns for mypy or pyright in real code and code generation workflows.
by wshobson
dependency-upgrade is a skill for planning major dependency upgrades with semver review, compatibility analysis, staged rollout, and testing. Use it to audit npm or yarn packages, inspect dependency trees, resolve conflicts, and guide safer framework or library upgrades in Code Editing workflows.
by github
The add-educational-comments skill adds teaching-focused comments to a specified code file while preserving structure and behavior. It can ask for a file if missing, adapts to reader level, and follows clear line-growth limits for educational code editing.
by vercel-labs
vercel-react-native-skills is a React Native and Expo skill for performance-minded frontend development. Use it to improve list rendering, animations, navigation, UI patterns, state management, and native module setup. It includes practical rules, install guidance, and usage patterns for working through mobile app bottlenecks with less guesswork.
by pbakaus
The optimize skill diagnoses and fixes UI performance issues across loading speed, rendering, animations, images, and bundle size. Use it when you need a structured optimize guide for performance optimization, with measurement-first troubleshooting for slow, laggy, or janky web experiences.
by addyosmani
incremental-implementation helps you ship changes in thin, testable slices for multi-file edits, refactors, and new features. Use this incremental-implementation skill when a task is too large to finish safely in one pass. It works well for code editing, because each step stays working, reviewable, and easier to verify.
by addyosmani
code-simplification helps refactor working code for clarity without changing behavior. Use it when code is correct but harder to read, maintain, or extend, especially for nested logic, long functions, repeated rules, and cleanup after shipped features.
by tanweai
p7 is a senior-engineer execution skill for code generation under P8 supervision. It handles scoped subtasks with a plan-first workflow: solution design, impact analysis, code changes, and a 3-question self-review. Best for bounded implementation work, not broad architecture or ideation.
