Claude Skills for Teams

Claude skills for teams are SKILL.md files you commit to a shared repository so that Claude behaves the same way for every developer on the project. One person writes down how your team formats pull requests, writes documentation or plans work, and Claude applies it identically for everyone — no verbal agreements, no reminders during review.

The difference shows up at onboarding and at review. A new developer clones the repository and immediately inherits the team's commit style, issue structure and code conventions instead of spending a week discovering unwritten rules. Review loses an entire class of comments — "we don't write it that way here" — because the code arrives already matching the standard.

Because skills live in git next to the code, they are versioned like any other file: a rule can be argued in a pull request, reverted, or branched. That is the practical difference from settings kept in each person's local interface, which never transfer between people and vanish when someone changes machines.

The collection below covers planning, task orchestration between agents, and documentation — the areas where team members drift apart from each other most often.

Skills in this collection

• Очистка и полировка пользовательских текстов — clean-user-facing-text is a Claude Code skill that audits and rewrites authorized natural-language text, removing suspicious invisible Unicode characters while preserving every fact, number, name, citation, and requirement. It is designed for use in Cursor when polishing articles, manuscripts, reports, documentation, emails, product copy, UI text, Markdown, or HTML prose. The workflow has two stages: a deterministic Unicode pass using bundled Python scripts (`inspect_text.py` and `clean_text.py`), and a prose rewrite that varies clause order, sentence rhythm, and connectors to replace formulaic phrasing with direct, natural wording. Code blocks, commands, paths, identifiers, formulas, verbatim quotations, and required disclosures are never modified. The skill does not support code-only tasks and explicitly does not claim detector evasion or proof of human authorship.
• Разбивка задач на подзадачи с планом — planning-and-task-breakdown is a Claude Code skill that decomposes large tasks into ordered, verifiable subtasks with explicit acceptance criteria. It operates in a strict two-phase flow: a read-only planning phase that analyzes the spec and codebase, followed by writing an implementation plan to `tasks/plan.md` and a task list to `tasks/todo.md` or an external tracker such as GitHub Issues, Jira, or Linear. Each task includes a description, testable acceptance criteria, verification commands, dependencies, and a scope estimate (XS–L); anything XL must be split further. Work is organized into vertical slices — each delivering a complete, testable feature path — with mandatory checkpoints every two to three tasks. The skill is designed for situations where a requirement feels too large to start, scope needs to be estimated, or work must be distributed across multiple agents or sessions.
• Маршрутизация навыков по фазам разработки — using-agent-skills is a Claude Code skill that acts as the meta-layer governing how every other agent skill is discovered and invoked during a development session. It provides a decision tree mapping each development phase to the appropriate skill — from early-stage idea interviews and spec-driven development through incremental implementation, testing, code review, git workflow, CI/CD, and shipping. Beyond routing, the skill enforces six non-negotiable operating behaviors across all phases: surfacing assumptions before implementation, stopping to resolve contradictions rather than guessing, pushing back on flawed approaches instead of complying silently, enforcing simplicity, maintaining strict scope discipline, and requiring verified evidence that a task is complete. Teams and solo developers use it to build a repeatable, senior-engineer-quality workflow with Claude Code and prevent common failure modes such as unchecked assumptions, scope creep, and skipped verification steps.
• Ведение архитектурных решений (ADR) — documentation-and-adrs is a Claude Code skill that records architectural decisions and captures the context future engineers and agents need to understand the codebase. It is designed for moments when choosing between competing technical approaches, changing a public API, shipping user-facing features, or preserving reasoning that would otherwise be lost over time. The core artifact is an Architecture Decision Record (ADR): documents stored in `docs/decisions/` with sequential numbering, covering Context, Decision, Alternatives Considered, and Consequences, following the lifecycle PROPOSED → ACCEPTED → SUPERSEDED. Before generating a new ADR, the skill inspects the repository for existing conventions — directory, file format, numbering scheme, and section headings — and matches them rather than imposing its own template. Inline documentation guidance is also included, emphasizing comments that explain *why* rather than restating what the code already shows.
• Проработка идей через дивергентное мышление — idea-refine is a Claude Code skill that turns vague ideas into sharp, actionable concepts through structured divergent and convergent thinking. It runs as an interactive dialogue across three phases: restating the idea as a "How Might We" problem statement, asking up to five sharpening questions, and generating 5–8 variations through lenses like inversion, simplification, audience shift, and 10x scaling. In the convergent phase, the skill clusters resonant directions, stress-tests each against user value, feasibility, and differentiation, and explicitly surfaces hidden assumptions that could kill the idea. The final output is a markdown one-pager — saved to `docs/ideas/[idea-name].md` on confirmation — covering Problem Statement, Recommended Direction, Key Assumptions, MVP Scope, and a "Not Doing" list. It suits product managers and developers who need to pressure-test a concept before committing to a plan.
• Разработка по спецификации до написания кода — spec-driven-development is a Claude Code skill that produces a structured specification before any code is written, turning vague requirements into a shared source of truth agreed upon by the engineer and stakeholder. The workflow runs through four gated phases — Specify, Plan, Tasks, Implement — each requiring explicit human approval before proceeding. When a single request bundles several independently testable capabilities, an optional Phase 0 Scope Check kicks in: Claude proposes a capability map with a module table, dependency direction, and build order, then recurses through the full four-phase cycle for each module. The resulting spec document covers objective and acceptance criteria, full executable build and test commands, project structure, code style illustrated with real snippets, testing strategy, and a three-tier boundary system (always do / ask first / never do). Teams use this skill when starting a new project or feature, working from incomplete requirements, or facing architectural decisions that touch multiple files or modules.
• Разработка по официальной документации — source-driven-development is a Claude Code skill that grounds every implementation decision in official documentation rather than potentially stale training data. It follows a four-step process: detecting the exact stack versions from dependency files (package.json, requirements.txt, go.mod, and others), fetching the specific documentation page from an authority hierarchy (react.dev, docs.djangoproject.com, MDN, web.dev, and similar), implementing code against the documented API signatures, and citing sources directly in code comments so users can verify every pattern. When official sources conflict with each other or with existing project code, the skill surfaces the discrepancy and presents options instead of silently picking one. It is built for developers where correctness matters — especially when writing boilerplate, handling forms, routing, state management, or authentication with any framework or library.
• Уточнение намерений перед работой — interview-me is a Claude Code skill that extracts what the user actually wants rather than what they think they should ask for, conducting a one-question-at-a-time interview until confidence reaches ~95%. It targets requests missing at least one of: who the user is, why they want it, what success looks like, or what the binding constraint is — typical of underspecified asks like "build me X" without further context. At each step Claude writes a hypothesis with an explicit confidence percentage, then poses a single focused question paired with its own guess at the answer, waiting for the user's reaction before continuing. This structure surfaces Claude's assumptions, prevents premature planning, and avoids the switching costs of building the wrong thing. When confidence is high enough, the skill produces a concise restatement of intent in the user's own words for confirmation. It applies only in live, interactive sessions before any plan, spec, or code exists — not in CI pipelines, scheduled runs, or autonomous loops.
• Локальные конфиг-файлы плагинов с YAML-frontmatter — plugin-settings is a Claude Code skill that documents the `.claude/plugin-name.local.md` pattern for storing per-project plugin configuration and state using YAML frontmatter combined with a markdown body. Files live in the project root, stay out of version control, and are user-managed — the skill covers file structure, parsing techniques, and three common usage patterns. Frontmatter supports typed fields such as strings, booleans, numbers, and lists, while the markdown section holds prompts, task descriptions, or additional instructions for agents and commands. Included bash snippets use `sed` and `awk` to extract frontmatter fields, with ready-made templates for hooks, commands, and agents — including toggling hook activation without restarting and coordinating multi-agent swarm state. Aimed at Claude Code plugin authors who need flexible, project-scoped configuration driving adaptive behavior across hooks, commands, and agents.
• Шаблон пользовательской slash-команды для Claude Code — example-command is a Claude Code skill that serves as a reference template for building custom slash commands using the `skills/<name>/SKILL.md` layout. It documents every supported frontmatter field — `name`, `description`, `argument-hint`, `allowed-tools`, and `model` — and shows how to handle required and optional arguments via the `$ARGUMENTS` variable. The skill is pre-approved to use the Read, Glob, Grep, and Bash tools. Functionally it is identical to the legacy `commands/example-command.md` format; only the file structure differs. Developers creating their own Claude Code plugins or slash commands can use this as a ready-made starting point instead of piecing together the syntax from documentation.
• Шаблон для создания скилла Claude Code — example-skill is a Claude Code skill that serves as a reference template for building new plugin skills, covering their structure, file layout, and frontmatter format. The core SKILL.md file documents required and optional directory contents — including README.md, references/, examples/, and scripts/ subdirectories — along with frontmatter fields (name, description, version, license) and guidelines for writing effective trigger descriptions. It activates when a user asks to demonstrate skill format, create a skill template, or discusses plugin development patterns. Developers looking to build their own Claude Code skills will find clear explanations of how skills differ from commands and agents, plus concrete examples of trigger phrases that reliably invoke a skill.
• Hookify — создание правил автоматизации — writing-rules is a Claude Code skill that guides creating and configuring Hookify rules — markdown files with YAML frontmatter that define patterns to watch for and messages to display when those patterns match. Rules are stored as `.claude/hookify.{rule-name}.local.md` files and support four event types: `bash` for shell commands, `file` for edit and write operations, `stop` for agent completion, and `prompt` for user input. The skill covers all frontmatter fields (`name`, `enabled`, `event`, `action`, `pattern`), both simple and multi-condition formats, matching operators (`regex_match`, `contains`, `equals`, `starts_with`, and others), and practical regex examples for dangerous commands, debug code, and sensitive file paths. It's aimed at developers who want to automate warnings, checklists, and enforcement steps inside their Claude Code workflow.
• Аудит и улучшение CLAUDE.md файлов — claude-md-improver is a Claude Code skill that audits and improves CLAUDE.md files across an entire repository so Claude Code receives accurate, up-to-date project context. It operates in five phases: discovery of all CLAUDE.md, .claude.local.md, and nested variants via Glob and Bash; quality assessment of each file against six weighted criteria — commands/workflows, architecture clarity, non-obvious patterns, conciseness, currency, and actionability — scored A through F; generation of a detailed per-file report with a breakdown table; targeted diff-format improvement proposals with explanations; and Edit-based updates applied only after explicit user approval. The skill is designed for developers who want to fix stale build commands, document monorepo package relationships, or capture environment setup that Claude keeps missing — essentially turning CLAUDE.md maintenance into a structured, reviewable process.
• Создание slash-команд для Claude Code — command-development is a Claude Code skill that guides the creation of slash commands — reusable Markdown-based prompts with YAML frontmatter, dynamic arguments ($ARGUMENTS, $1, $2), and optional bash execution for runtime context. It covers file layout across .claude/commands/ (project-scoped) and ~/.claude/commands/ (user-scoped) directories, frontmatter fields including description, allowed-tools, model, argument-hint, and disable-model-invocation, and the critical principle that commands must be written as directives to Claude rather than messages to the user. Developers and teams who want to standardize recurring workflows, share complex prompts across a project, or quickly invoke multi-step instructions will find this skill directly applicable.
• Аналитика сессий Claude Code в HTML-отчёте — session-report is a Claude Code skill that analyzes session transcripts from ~/.claude/projects and produces a self-contained interactive HTML report covering token usage, cache efficiency, subagents, skills, and expensive prompts. The bundled analyze-sessions.mjs script collects data for a configurable window — 24h, 7d, 30d, or all time — and outputs a JSON with sections for overall, by_project, by_subagent_type, by_skill, cache_breaks, and top_prompts. The skill copies a bundled template (with pre-built JS/CSS for sorting, bars, and drill-downs), injects the JSON blob, then fills an anomalies block with 3–5 findings expressed as percentages of total tokens and an optimizations block with 1–4 actionable suggestions tied to specific projects or prompts. It's built for developers and teams who need visibility into Claude Code spending, want to spot cache-hit rates below 85%, or identify subagent calls averaging over 1M tokens per invocation.
• Интерактивная страница статуса проекта — project-artifact is a Claude Code skill that generates and publishes a tabbed HTML status page for projects too large to fit in a single update — migrations, launches, research efforts, or any initiative with parallel workstreams. The output is a self-contained HTML file (all styles and the tab-switcher script inlined, no external hosts) published via the built-in Artifact tool to a private `https://claude.ai/code/artifact/<uuid>` URL that owners can share with teammates. Tab selection is opinionated: Overview and Workstreams are always present; Attention, Background, Plan, Risks & Open Questions, and Decisions/FAQ each appear only when there is substantive content to fill them. Per-project config lives in `${CLAUDE_PLUGIN_DATA}/artifacts/<slug>/`, enabling refreshes that redeploy to the same URL and report only what changed. For PR-driven software projects, the skill reads `swe.md` and pulls live state via `gh pr list`, `gh pr view`, and `git log` — no manual copy-pasting required.
• Генератор интерактивных HTML-площадок — playground is a Claude Code skill that generates self-contained interactive HTML playgrounds — a single file with a controls panel on one side, a live preview on the other, and a prompt output at the bottom with a copy button. It selects the appropriate template from six built-in options — design-playground, data-explorer, concept-map, document-critique, diff-review, and code-map — and builds the playground accordingly. All CSS and JS are inlined with no external dependencies; a single state object drives both the preview and the prompt, updating instantly on every control change. The prompt output is written as a natural-language instruction that mentions only non-default choices and includes enough context to act on without seeing the playground. Ideal for UI design exploration, data and query building, code review, and learning — any scenario where the input space is visual or structural and hard to express as plain text.
• Структурированное планирование задач разработки — plan is a Claude Code skill that builds comprehensive, actionable work plans through intelligent interaction before any implementation begins. It supports four modes: interview (structured requirements gathering for vague requests), direct (immediate planning when the task is already well-defined), consensus (an automated Planner→Architect→Critic loop with RALPLAN-DR structured deliberation, switchable to deliberate mode for high-risk changes like auth, data migrations, or public API modifications), and review (Critic evaluation of an existing plan). The skill auto-detects which mode fits the request, asks exactly one question at a time during interviews, and pre-fetches codebase facts via an `explore` agent before prompting the user. Quality gates require 80%+ of claims to cite a file and line, and 90%+ of acceptance criteria to be testable. It suits engineers who need to scope an ambiguous feature, align on architecture across perspectives, or get a structured critique of a plan they've already drafted.
• Проверка готовности кода к слиянию — merge-readiness is a Claude Code skill that acts as a post-task explainability gate: it generates a human-readable report on a change and then quizzes the team to verify they can explain why the change exists, what changed, what tradeoffs were made, and what risks were considered before merge approval is requested. Three depth profiles are supported — quick (correctness threshold ≥ 0.70, up to 3 MCQs), standard (≥ 0.80, up to 5 MCQs), and deep (≥ 0.90, up to 8 MCQs) — covering five required dimensions: why, change, tradeoff, risk, and team. Questions are presented one per round via AskUserQuestion; scoring is handled objectively by the runtime hook (`mcq.ts`), not by AI heuristics. Session state persists to `.omc/state/merge-readiness-state.json` for resume safety. Passing the gate never replaces tests, code review, or maintainer approval — it only confirms the team can explain the change.
• oh-my-claudecode — справочник агентов и оркестрации — omc-reference is a Claude Code skill that serves as the built-in oh-my-claudecode reference: a catalog of 19 agents with model routing (haiku/sonnet/opus), tool documentation, a skills registry, and a structured commit protocol. It auto-loads when delegating to agents, using OMC tools, orchestrating teams, or invoking skills — keeping CLAUDE.md lean while detailed reference stays available on demand. The skill covers every agent role (explore, analyst, planner, architect, debugger, executor, verifier, and more), state and notepad commands, project memory, LSP and AST tools, and a five-stage team pipeline. The skills registry includes both workflow skills (autopilot, ralph, ultrawork, ralplan, deep-interview, ai-slop-cleaner) and utility skills. Built for developers who need centralized orchestration documentation without bloating the session prompt.
• Pre-mortem анализ продукта перед стартом — before-you-build is a Claude Code skill that runs a compact pre-mortem review before a founder, product manager, or developer starts building a landing page, MVP, SaaS app, internal tool, agent workflow, or major feature. It evaluates seven risk areas — demand, positioning, monetization, retention, trust, distribution, and feature adoption — and returns a concise, decision-oriented output. Each review identifies a risk verdict (low, medium, or high), the single assumption most likely to break the project, the smallest useful validation signal to find first, and an explicit list of what should not be built yet. The skill is designed to surface weak evidence early without blocking progress, keeping the focus on the narrowest build scope that is safe to start.
• Параллельный запуск AI-агентов в tmux — omc-teams is a Claude Code skill that spawns N CLI worker processes in tmux panes to execute tasks in parallel across multiple agent types. It supports claude, codex, gemini, antigravity, grok, and cursor workers — cursor is accepted for executor-style tasks only. The command takes a worker count (1–10), an agent type, and a task description, such as `/omc-teams 2:codex "review auth module for security issues"`; the skill decomposes work into independent, file-scoped subtasks to prevent write conflicts. A tmux binary or cmux surface (via CMUX_SURFACE_ID) is required, along with the relevant CLI tool for each chosen agent. It suits teams looking to parallelize code review, module implementation, or UI redesign across different AI runtimes simultaneously.
• Saga — распределённые транзакции без двухфазного коммита — saga-orchestration is a Claude Code skill that implements saga patterns for managing distributed transactions and long-running business workflows without two-phase commit. It covers both orchestration and choreography approaches, producing a saga definition with ordered steps, action commands, and compensation commands for each participant service — all idempotent and guaranteed to publish a result event even on rollback. Per-step timeout configuration, state machine metrics, stuck saga detection, and DLQ recovery are included out of the box. The skill targets engineers coordinating multi-service transactions across inventory, payment, and shipping, building atomic rollback for travel booking systems (hotel, flight, car rental), or debugging production sagas stuck in a COMPENSATING state where compensation steps never complete. It integrates with durable message brokers such as Kafka, RabbitMQ, and SQS, and pairs naturally with the cqrs-implementation and event-store-design skills.
• Настройка HUD строки состояния Claude Code — hud is a Claude Code skill that configures the HUD (Heads-Up Display) statusline as part of the Oh My ClaudeCode ecosystem. It handles installation, repair, and switching between three display presets: minimal (essentials only), focused (branch, agents, context, todos — the default), and full (multi-line output with per-agent details). Running `/oh-my-claudecode:hud setup` automatically checks for `~/.claude/hud/omc-hud.mjs`, creates the wrapper script from the canonical template if missing, and writes the `statusLine` field into `~/.claude/settings.json`. The skill respects the `CLAUDE_CONFIG_DIR` environment variable and handles cross-platform path differences between Unix and Windows. It suits developers who want a persistent at-a-glance view of their Claude Code session — current branch, context load, background tasks, and active agents — without switching windows.

FAQ

How do I share a Claude Code skill with my team?

Put the skill folder containing SKILL.md into the project repository — usually under .claude/skills/ — and commit it. Claude Code picks up skills from the repository for everyone who has cloned it, so there is nothing to distribute or install separately.

How is a skill different from instructions in CLAUDE.md?

CLAUDE.md is always active and describes the project as a whole. A skill is a self-contained procedure for one kind of task: it loads when that task comes up and stays out of the context window the rest of the time. In practice teams use both — project rules in CLAUDE.md, repeatable procedures as skills.

All Claude Code skills