ruslan-korneev
9 verified skills27 total stars
plugins/python/skills/ruff-patterns
# Ruff Patterns Knowledge about the ruff linter and patterns for solving errors. **ZERO noqa policy** — always look for the proper solution. ## Triggers Use this skill when the user: - Asks "how to configure ruff" - Gets a ruff error and wants to understand how to fix it - Wants to migrate from black/isort/flake8/pylint - Asks about a specific rule (E501, F401, etc.) ## Main Principle: NEVER USE NOQA **Every ruff error has a proper solution.** Using `# noqa` is: - Hiding the problem, not so
tools3
plugins/fastapi/skills/alembic-patterns
# Alembic Patterns Alembic migration patterns with automatic handling of problematic types. ## Triggers Use this skill when the user: - Creates an Alembic migration - Gets errors during migration - Works with enum, array, nullable changes ## Main principle: Automatic fixing Alembic does not always correctly generate downgrade. The plugin automatically: - Adds enum deletion in downgrade - Warns about nullable changes without data migration - Checks the order of FK operations ## Enum types
tools3
plugins/tech-lead/skills/architecture-patterns
# Architecture Patterns System-level architecture patterns for Python backend projects (FastAPI + SQLAlchemy 2.0). ## Triggers Use this skill when the user: - Designs a new system or major feature - Asks about project structure or module boundaries - Makes data modeling decisions - Designs API contracts - Evaluates architectural trade-offs - Creates or reviews Architecture Decision Records (ADR) - Needs to modernize legacy code ## Abstraction Levels | Plugin | Level | Focus | |--------|----
tools3
plugins/python/skills/clean-code-patterns
# Clean Code Patterns Clean code principles for Python. Code should read like well-written prose. ## Triggers Use this skill when: - Code is hard to read or understand - Function/class does too much - Refactoring is needed - Code review revealed issues - Questions about SOLID, DRY, KISS ## SOLID More details: `${CLAUDE_PLUGIN_ROOT}/skills/clean-code-patterns/references/solid.md` ### S — Single Responsibility ```python # Bad — class does everything class UserService: def create_user(se
tools3
plugins/fastapi/skills/fastapi-patterns
# FastAPI Patterns Best practices and patterns for FastAPI projects with SQLAlchemy 2.0 and dependency-injector. ## Triggers Use this skill when the user: - Creates a new FastAPI project or module - Asks about FastAPI application structure - Works with SQLAlchemy models and repositories - Configures Dependency Injection - Creates DTOs (Pydantic models) ## Layer Architecture ``` Router → Service → Repository → Database ↓ ↓ ↓ DTO DTO Model/DTO ``` - **Router** —
tools3
plugins/linear/skills/linear-api
# Linear API Skill Manage Linear issues, boards, and cycles. Uses **Linear MCP** for standard operations and **plugin commands** for unique features. ## When to Use This Skill Use this skill when the user wants to: - View a kanban board of current tasks (`/linear:board`) - Manage sprints/cycles and track velocity (`/linear:cycle`) - Archive or delete issues (`/linear:delete`) - Edit or delete comments (`/linear:comment`) - Auto-enrich issues with code context (issue-enricher agent) **For sta
tools3
plugins/python/skills/pytest-patterns
# Pytest Patterns Quality testing patterns with pytest for FastAPI projects. **TDD-first approach**. ## Triggers Use this skill when the user: - Wants to write tests - Asks about pytest, fixtures, mocks - Wants to set up testing for FastAPI - Uses TDD approach ## Main Principle: TDD 1. **Red** — write a failing test 2. **Green** — write minimal code 3. **Refactor** — improve while keeping tests green ## What Makes a Good Test ### 1. Clear Name ```python # ✅ Good — describes what, when, a
tools3
plugins/python/skills/typing-patterns
# Python Typing Patterns Python type annotation patterns without `type: ignore`. Always the correct solution. ## Triggers Use this skill when the user: - Gets mypy/pyright errors - Asks about Python type annotations - Wants to add type hints - Works with generics, protocols, TypeVar ## Main Principle: NEVER type: ignore Every type error has a correct solution. `type: ignore` is: - Masking potential bugs - Disabling type checking - Technical debt More details: `${CLAUDE_PLUGIN_ROOT}/skills/
tools3
plugins/tech-lead/skills/code-review
# Code Review Skill This skill should be used when the user asks for "code review", "review my changes", "review this PR", "check my code", "pre-merge review", "review diff", or mentions reviewing code quality, implementation correctness, or preparing changes for merge. ## Overview Code review following the **Review Pyramid** methodology — a prioritized approach that focuses on what matters most. ## The Review Pyramid ``` ▲ /|\ 5. Code Style (Nit) ← Least important,
tools3