Claude Skills for GitHub

Claude skills for GitHub are ready-made procedures that absorb the routine around a repository: they write commit messages in your team's format, assemble a pull request description from the diff, run a first-pass review, and work out why a build failed.

The clearest payoff is in pull request descriptions. Developers rarely spend time on them — the body ends up as "fixes" or a bare ticket link, and the reviewer has to reconstruct intent from the diff. A skill builds the description from the actual changes: what moved, why, and what to check first. Review gets measurably faster without demanding extra discipline from the author.

The second scenario is a failed build. The skill reads the CI log, isolates the root cause out of a cascade of errors, and proposes a fix instead of handing a person a thousand lines of raw output.

The collection below covers commits, pull requests, code review and CI/CD work.

Skills in this collection

• ci-cd-and-automation — ci-cd-and-automation is a Claude Code skill that automates the setup and modification of CI/CD pipelines, ensuring every change passes mandatory quality gates before reaching production. The skill covers a complete verification sequence: lint (eslint, prettier), type check (tsc --noEmit), unit tests (jest/vitest), build, database integration tests (PostgreSQL via GitHub Actions services), E2E tests (Playwright/Cypress), and security audit via npm audit. It provides ready-to-use GitHub Actions configurations for basic CI, Prisma-based integration tests, PR preview deployments, and feature-flag deployment strategies. Designed for developers setting up a new project pipeline, adding automated checks, debugging CI failures, or establishing a reliable continuous integration and delivery workflow.
• Git-воркфлоу и версионирование кода — git-workflow-and-versioning is a Claude Code skill that structures git practices across the full development lifecycle: atomic commits, trunk-based development with short-lived branches (1–3 days), semantic versioning, conventional commit messages, and changelog authoring at release time. It covers branch naming conventions (feature/, fix/, chore/, refactor/), commit types (feat/fix/refactor/test/docs/chore), and explains how to use git worktrees so multiple AI agents can work on separate branches in parallel without interfering. The recommended target is roughly 100 lines per commit or PR, with changes over 1,000 lines split into smaller pieces. Useful for teams that need a legible history, safe rollbacks, and a reviewable workflow when AI-generated code is produced at high speed.
• Пошаговая реализация вертикальными слайсами — incremental-implementation is a Claude Code skill that delivers changes in thin vertical slices, keeping the codebase in a working, testable state after every step. It is designed for any change touching more than one file, new feature implementation, refactoring, or any moment when writing more than ~100 lines without a test becomes tempting. The increment cycle is fixed: implement the smallest complete piece → test → verify → commit with a descriptive message → move to the next slice. Three slicing strategies are supported: vertical slices (a full end-to-end path through the stack per increment), contract-first (parallel backend and frontend development from a shared API contract), and risk-first (highest-uncertainty piece tackled first). Five built-in rules — simplicity first, scope discipline, one logical change per commit, keeping the project compilable, and making each increment independently revertable — make the skill particularly valuable for teams that practice agile, continuous delivery workflows.
• Вывод устаревшего кода и миграция — deprecation-and-migration is a Claude Code skill that manages the full lifecycle of retiring outdated code — from the initial deprecation decision through safe user migration to verified removal of the old system. It provides a structured decision framework with a checklist to evaluate migration scope and maintenance cost, distinguishes between advisory and compulsory deprecation, and covers the Strangler and Adapter patterns for incremental cutover. Built-in templates cover deprecation notices, per-consumer migration steps, the Churn Rule (infrastructure owners must migrate their users), and design-time planning so new systems are easier to sunset later. Ideal for engineering teams replacing legacy APIs, consolidating duplicate implementations, sunsetting unused features, or reducing the ongoing overhead of code that no longer earns its keep.
• Инструментирование кода для наблюдаемости в production — observability-and-instrumentation is a Claude Code skill that instruments code so production behavior is visible and diagnosable through structured logging, metrics, distributed tracing, and alerting. It applies RED (Rate, Errors, Duration) for request-driven services and USE (Utilization, Saturation, Errors) for resources, enforces correlation ID propagation across every request boundary, and guards against PII leaking into telemetry pipelines. The process starts by defining the exact questions an on-call engineer will ask, then selects the right signal type — logs answer "why", metrics answer "how often", traces answer "where" — before writing any instrumentation, using OpenTelemetry as the vendor-neutral foundation. Intended for teams who want to diagnose production incidents through telemetry queries rather than log archaeology, and who treat observability as a first-class deliverable shipped alongside every feature.
• Упрощение и рефакторинг кода — code-simplification is a Claude Code skill that refactors code for clarity and maintainability without altering its behavior. It targets situations where working code has grown harder to read or extend: deeply nested logic, functions exceeding 50 lines, chained ternaries, boolean flag parameters, or duplication introduced by merges and time-pressured patches. The skill follows five principles — exact behavior preservation, adherence to project conventions, clarity over cleverness, avoiding over-simplification, and scoping changes to recently modified code. Before any edit, it applies Chesterton's Fence: understand why the code is structured as it is before deciding to change it. Useful for code reviews, technical-debt sessions, and preparing modules for new feature work.
• Оптимизация производительности приложения — performance-optimization is a Claude Code skill that optimizes application performance across frontend, backend, queries, and databases using a structured measure-first workflow. It guides Claude through establishing a baseline with Lighthouse, Chrome DevTools, and real-user data via the web-vitals library, identifying the actual bottleneck, applying a targeted fix, verifying the result, and adding monitoring to guard against regressions. The skill includes Core Web Vitals reference thresholds (LCP ≤ 2.5s, INP ≤ 200ms, CLS ≤ 0.1), a symptom-to-cause diagnostic tree, and concrete fix patterns for N+1 queries, unbounded data fetching, and image optimization. It is intended for projects with load-time budgets, API response SLAs, or declining Web Vitals scores — any situation where guessing is costlier than profiling.
• Безопасный деплой в продакшн с поэтапным роллаутом — shipping-and-launch is a Claude Code skill that guides production deployments with pre-launch checklists, feature flags, staged rollouts, and rollback strategies built in from the start. It provides a structured checklist across six areas — code quality, security, performance, accessibility, infrastructure, and documentation — along with a feature flag lifecycle from DEPLOY (flag OFF) through gradual rollout to CLEAN UP within two weeks of full release. A decision-threshold table covers error rate, P95 latency, client JS errors, and business metrics to determine whether to advance, hold, or roll back at each canary stage (5 % → 25 % → 50 % → 100 %), with 24–48-hour monitoring windows at every step. Designed for developers and DevOps engineers shipping significant changes, data migrations, or beta launches who need every release to be reversible, observable, and incremental.
• Проектирование API и публичных интерфейсов — api-and-interface-design is a Claude Code skill that guides the design of stable, well-documented interfaces — REST and GraphQL endpoints, module boundaries, component props, and any public contract between parts of a system. It builds on three foundational ideas: contract-first design (define the interface before implementing it), Hyrum's Law (every observable behavior becomes a dependency regardless of what you document), and the One-Version Rule (extend rather than fork to avoid diamond dependency problems). The skill covers consistent error semantics with HTTP status codes and structured error bodies, boundary validation rules including mandatory parsing of third-party API responses, prefer-addition-over-modification patterns for backward-compatible evolution, and naming conventions for REST resources and response fields. It suits teams designing new APIs, splitting frontend and backend responsibilities, or safely evolving existing public interfaces.
• Упаковка MCP-сервера в бандл .mcpb — build-mcpb is a Claude Code skill that guides developers through packaging a local MCP server together with its Node or Python runtime into a single installable .mcpb file. The bundle is a zip archive containing a `manifest.json`, server code, and vendored dependencies — end users install one file with no need for Node, Python, or any toolchain on their machine. The skill covers manifest structure (schema v0.4), launch configuration via `mcp_config`, install-time user settings in `user_config` with native UI controls like directory pickers, and the build pipeline using `npx @anthropic-ai/mcpb pack` for both Node and Python targets. It applies when the server must access the local filesystem, drive desktop apps, or call OS-level APIs — cases where a remote HTTP server is not an option. Security is explicitly the developer's responsibility: MCPB provides no sandbox, so path validation and privilege scoping must be handled in server code.
• github-actions-templates — github-actions-templates is a Claude Code skill that generates production-ready GitHub Actions workflows for automated testing, building, and deploying applications. It covers four core patterns: matrix builds across Node.js 18/20 and Python 3.9–3.12 on ubuntu, macos, and windows runners; Docker image builds with push to ghcr.io using GitHub Actions Cache for faster pipelines; Kubernetes deployments via AWS EKS with rollout verification; and filesystem vulnerability scanning with Trivy. The skill also supports reusable workflows via workflow_call, proper permissions scoping, secrets management, and approval gates for production environments. It is aimed at developers and DevOps engineers who need to set up a reliable CI/CD pipeline on GitHub Actions while following security best practices and keeping build times low.
• gitlab-ci-patterns — gitlab-ci-patterns is a Claude Code skill that helps build GitLab CI/CD pipelines with multi-stage workflows, dependency caching, and distributed runners for scalable automation. It provides ready-to-use patterns for Docker image builds via docker-in-docker with pushes to GitLab Registry, Kubernetes deployments using kubectl across staging and production environments, Terraform pipelines covering validate, plan, and apply stages, and security scanning with GitLab SAST, Dependency-Scanning, and Trivy. The skill also covers per-branch and per-job caching strategies, dynamic child pipelines, and manual approval gates before production. It is aimed at teams automating testing, building, and deployment on GitLab, adopting GitOps practices, or looking to optimize the performance of existing CI/CD pipelines.
• Проектирование мультиоблачной архитектуры — multi-cloud-architecture is a Claude Code skill that provides a decision framework for designing and operating architectures across AWS, Azure, GCP, and OCI. It includes service comparison tables covering compute, storage, and database categories, four architectural patterns — Single Provider with DR, Best-of-Breed, Geographic Distribution, and Cloud-Agnostic Abstraction — plus a four-phase migration strategy from assessment to optimization. To reduce vendor lock-in, the skill recommends a portable stack built on Kubernetes, PostgreSQL, S3-compatible storage, Apache Kafka, Redis, Prometheus/Grafana, and Terraform as the infrastructure abstraction layer. It is aimed at engineers designing multi-cloud systems, selecting best-of-breed services, managing cross-provider costs, or planning cloud migrations.
• Оптимизация Bazel-сборок в монорепозитории — bazel-build-optimization is a Claude Code skill that helps optimize Bazel builds for large-scale monorepos, covering remote caching and remote execution setup, custom Bazel rule authoring, and build issue debugging. It explains core Bazel concepts — targets, packages, labels, rules, and aspects — and provides production patterns for a standard workspace layout with WORKSPACE.bazel, .bazelrc, and BUILD.bazel files. Concrete templates and worked examples are stored in references/details.md. The skill is aimed at teams configuring Bazel for enterprise codebases, migrating from other build systems, or looking to speed up CI/CD pipelines through shared build artifact caching and reproducible builds.
• Параллельная разработка фич в мультиагентной команде — parallel-feature-development is a Claude Code skill that coordinates parallel feature development using file ownership strategies, conflict avoidance rules, and integration patterns for multi-agent implementation. It covers three ownership models—by directory, by module, and by architectural layer—and enforces a cardinal rule of one owner per file, with clear guidance on extracting interface contracts in TypeScript so agents can build against each other's APIs before they are ready. Three integration patterns are provided: vertical slices, horizontal layers, and a hybrid approach, along with single-branch and multi-branch workflows suited to teams of different sizes. The skill also includes troubleshooting scenarios for common blockers such as shared-file conflicts, mid-stream decomposition changes, and early-finishing agents waiting on dependencies.
• Паттерны архитектуры бэкенда: Clean, Hexagonal, DDD — architecture-patterns is a Claude Code skill that implements proven backend architecture patterns — Clean Architecture, Hexagonal Architecture, and Domain-Driven Design — to produce layered codebases with clear dependency rules, interface definitions, and test boundaries. It covers the full range of DDD tactical patterns (aggregates, value objects, repositories, domain events), Clean Architecture's inward-only dependency rule, and the ports-and-adapters model that lets you swap PostgreSQL for DynamoDB without touching the domain core. Worked examples include in-memory repository adapters that make every use-case test runnable as a plain unit test with no database or Docker, plus guidance on resolving circular imports caused by use cases importing concrete adapters instead of abstract ports. Use this skill when designing a new microservice from scratch, untangling business logic from ORM models or HTTP concerns in a monolith, or establishing bounded contexts before splitting a system into independent services.
• Terraform — библиотека модулей для мультиоблачной инфраструктуры — terraform-module-library is a Claude Code skill that guides the creation of reusable Terraform modules for AWS, Azure, GCP, and OCI infrastructure following infrastructure-as-code best practices. Each module follows a consistent layout: main.tf, variables.tf, outputs.tf, versions.tf, an examples/ directory, and a tests/ directory with Terratest files written in Go. Built-in patterns cover VPC, EKS, RDS, S3 on AWS; VNet, AKS, and Storage on Azure; GKE and Cloud SQL on GCP; and VCN, OKE, and Object Storage on OCI. The skill is designed for platform and DevOps teams who need to standardize multi-cloud provisioning, enforce input validation with Terraform validation blocks, apply consistent resource tagging, and compose modules — for example, wiring an RDS module to outputs from a VPC module.
• Гибридные облачные сети: VPN и выделенные каналы — hybrid-cloud-networking is a Claude Code skill that configures secure, high-performance connectivity between on-premises infrastructure and cloud platforms using VPN and dedicated connections. It covers AWS (Site-to-Site VPN up to 1.25 Gbps per tunnel, Direct Connect up to 100 Gbps), Azure (VPN Gateway, ExpressRoute up to 100 Gbps), GCP (HA VPN with 99.99% SLA, Cloud Interconnect), and OCI (IPSec VPN with redundant tunnels, FastConnect). The skill includes Terraform examples for each provider, BGP routing configuration, hub-and-spoke and multi-cloud hybrid network diagrams, and CLI troubleshooting commands for AWS, Azure, and OCI. It is aimed at teams building hybrid cloud architectures, extending data centers to the cloud, meeting compliance requirements, or implementing active-active setups with automatic BGP failover.
• Напоминание о пересборке TypeScript в локальном форке — local-build-reminder is a Claude Code skill that automatically prompts developers to run `npm run build` after editing TypeScript files when operating from a local OMC fork. In local mode — identifiable by the `L` suffix in the `[OMC#X.Y.ZL]` HUD indicator — Claude Code serves compiled JavaScript from `dist/` rather than TypeScript source from `src/`, so any `.ts` edits are silently ignored until a rebuild occurs. The skill triggers in four scenarios: after a `src/**/*.ts` edit, when the developer wonders why a change has no effect, before restarting Claude Code with unbuilt modifications, or when an OMC command is expected to reflect new TypeScript behavior. It stays silent for `.mjs`, `.cjs`, `.md`, and `.json` files (loaded directly from disk), for sessions not running OMC locally, and whenever `tsc --watch` or `npm run dev:full` is already handling incremental rebuilds in the background.
• Оптимизация затрат в облаке AWS, Azure, GCP — cost-optimization is a Claude Code skill that reduces cloud spending across AWS, Azure, GCP, and OCI through resource rightsizing, tagging strategies, reserved instances, and cost analysis. It covers the full cost management lifecycle — from setting up budget alerts and cost dashboards to selecting the right pricing models: Reserved Instances, Savings Plans, and Spot/Preemptible instances with discounts up to 90%. The skill includes ready-to-use Terraform examples for S3 lifecycle policies, AWS Budgets, and Auto Scaling, plus architecture patterns such as serverless-first, multi-tier storage, and environment-appropriate database sizing. Built for engineers and DevOps teams looking to audit infrastructure costs, cut cloud bills, or roll out cost governance policies across a multi-cloud environment.
• Диагностика и починка oh-my-claudecode — omc-doctor is a Claude Code skill that diagnoses and fixes oh-my-claudecode installation issues by running six sequential checks. It inspects the installed plugin version against the latest on npm, scans both profile-level and project-level settings.json for legacy hooks that cause duplicate execution, checks for obsolete bash hook scripts, verifies that CLAUDE.md contains OMC markers and that its version aligns with the plugin cache, confirms Ruby is available for Ralph workflows, and detects stale plugin cache entries. All ~/.claude paths respect the CLAUDE_CONFIG_DIR environment variable. The skill is aimed at developers troubleshooting oh-my-claudecode setups — especially after updates that leave version drift, missing configuration markers, or leftover legacy hooks behind.
• deployment-pipeline-design — deployment-pipeline-design is a Claude Code skill that designs multi-stage CI/CD pipelines with approval gates, security scanning, and deployment orchestration across multiple environments. It produces pipeline stage definitions with job dependencies and caching strategy, annotated rollout configurations (canary weights, blue-green switchover, rolling parameters), deep readiness probe setups, post-deployment smoke test scripts, and automated rollback triggers keyed to metric degradation. Supported deployment targets include Kubernetes, ECS, VMs, serverless, and PaaS; compatible monitoring sources cover Prometheus, Datadog, and CloudWatch. The skill's reference documentation addresses common failure modes such as a stalled Argo Rollouts canary caused by an inconclusive AnalysisTemplate, a production approval gate waiting indefinitely due to missing reviewer assignment, and database schema mismatches after a service rollback. Teams migrating platforms, implementing progressive delivery, or aiming to reduce mean time to recovery will find this skill most useful.
• Блокировка обхода git-хуков в Claude Code — block-no-verify-hook is a Claude Code skill that configures a PreToolUse hook to intercept and block --no-verify and --no-gpg-sign flags in git commands before they execute. The hook is defined in .claude/settings.json with a Bash matcher: it inspects the $TOOL_INPUT environment variable using a grep regex and exits with code 2 when a bypass flag is detected inside a git command, causing Claude Code to reject the tool call entirely. This prevents AI agents from skipping pre-commit hooks that enforce linting, formatting, test runs, and security scanning, as well as GPG commit-signing policies. The configuration can be applied per-project or globally via ~/.claude/settings.json, and the regex pattern is straightforward to extend with additional flags such as --force. It is intended for teams that need reliable quality gates when using Claude Code or similar AI coding agents.
• Установка и настройка oh-my-claudecode — omc-setup is a Claude Code skill that installs, refreshes, or repairs oh-my-claudecode through a single canonical setup flow. On invocation it parses flags: `--local` and `--global` run Phase 1 only, targeting the project-level `.claude/CLAUDE.md` or the global `~/.claude/CLAUDE.md` respectively; `--force` skips the existing-configuration check and reruns the full wizard from scratch. When setup has already been completed — detected via `.omc-config.json` — the skill prompts the user to choose between updating CLAUDE.md only, rerunning the full wizard, or cancelling. All configuration mutations go exclusively through `scripts/setup-claude-md.sh`, which resolves the plugin cache, verifies the compiled-source handshake, and fails closed on any coordinator protocol or exit-status disagreement. Intended for developers setting up OMC via a marketplace plugin, npm global install, or a locally checked-out repository.

FAQ

Can Claude Code open pull requests on GitHub by itself?

Yes, when the environment has GitHub access configured — through the official CLI or through the GitHub MCP server. The skill is not responsible for access but for content: what goes into the title and body, and what ends up on the review checklist.

Why use a skill for commit messages when Conventional Commits exist?

Conventional Commits define the format, not the substance. A skill records what your team considers worth explaining in a commit body: which changes need a stated reason, how to reference issues, and where one commit should have been two.

All Claude Code skills