Ruff plugins

Enforce code quality and security checks after every change, automate git commits and pushes with conventional messages, generate structured task checklists, guide incremental refactoring, and apply systematic debugging—all within Claude Code.

Automatically refactor Python code for idiomatic style and performance, and add type hints to files using modern Python 3.10+ syntax. Ensures behavior preservation with tests and linting via ruff.

Guides Python developers on using Astral tools: manage projects and dependencies with uv (including pip/poetry migrations and uvx scripts), lint/format/fix code with Ruff (replacing Flake8/Black/isort via pyproject.toml), and type-check with ty (mypy/Pyright migrations, LSP config). Activates on uv.lock or tool configs.

Profile Python performance bottlenecks with cProfile/py-spy, analyze pytest test suites for quality/coverage, check async code for issues/patterns, lint/fix with ruff, optimize algorithms/memory, generate unit/integration tests, and package/publish projects using uv/pyproject.toml.

End-to-end Python library creation and distribution: from project scaffolding with modern tooling (uv, ruff, pytest), through API and CLI design, documentation with Sphinx, packaging with pyproject.toml, security auditing, and automated release management with semantic versioning and PyPI publishing.

Establishes opinionated Python 3.11+ engineering standards with SOLID principles, strict typing, pytest testing, ruff linting; automates TDD workflows, routes to specialists for CLI apps (Typer/Rich/Textual), web APIs (FastAPI/Flask/Django), data pipelines, packaging, code reviews, and PyPI CI/CD deployment.

Automate full linting pipelines for Python projects: discover linters from pyproject.toml or package.json, format code with prettier, lint with ruff/mypy/bandit/eslint, resolve root causes via agents, and verify architecture post-fixes. Invoke /lint on files/directories or use in orchestrators for task completion.

Build modern Python web apps with Django and FastAPI, define SQLAlchemy models and Alembic migrations, write pytest tests, debug errors, and review code quality using specialized agents that orchestrate database tasks and full codebase reviews.

Extend Claude Code with specialized AI agent skills for structured brainstorming, multi-agent orchestration, cross-model code review, git operations, Python tooling (uv, ruff, ty), TUI design patterns, and Tilt-based Kubernetes development workflows.

Provides an agent-first cognitive substrate for long-term knowledge management across Claude Code sessions, with automated session rituals, code quality analysis, schema migration drafts, documentation proposals, and a full release pipeline including PR automation and pre-flight checks.

Audit and auto-configure project infrastructure to enforce standards for CI/CD workflows, Dockerfiles, pre-commit hooks, linting, testing frameworks, security scans, feature flags, and documentation across JavaScript/TypeScript, Python, Rust, Go, and infrastructure projects using CLI flags like --check-only and --fix.

Enforce AI-First SDLC with zero technical debt by automating validation pipelines, compliance checks, and git workflows for Python, JavaScript, Go, and Rust projects. Includes pre-commit hooks, PR gatekeeping, CI/CD generation, and agent-driven code reviews.

Streamline Python project workflows: initialize and manage dependencies, Python versions, and tools with uv; lint, format, and detect dead code with ruff and vulture; type check rapidly with ty or basedpyright; run advanced pytest suites with fixtures, parametrization, and coverage; integrate into VSCode, pre-commit, and GitHub Actions; build and publish packages to PyPI.

Automate end-to-end best practices for scientific Python projects: initialize reproducible pixi environments with conda/PyPI deps, enforce code quality via ruff/mypy/pre-commit, build pytest numerical tests, create distributable Hatchling packages, and generate Sphinx/MkDocs docs with NumPy-style docstrings and Diataxis structure.

Build production Python 3.13+ projects with async FastAPI apps, pytest testing, uv packaging, Ruff linting, GitHub Actions CI/CD, Cloudflare Workers deployment, and Modal serverless for GPU-accelerated video pipelines using OpenCV and FFmpeg.

Provides end-to-end Python 3.11+ CLI development with Typer/Rich, TDD via pytest, modern type hints, packaging, CI/CD pipelines, and code review — from project scaffolding through deployment.

Run an adversarial multi-agent pipeline where generator agents produce code and documentation, discriminator agents validate them, and iterative feedback drives convergence toward production-ready quality.

Automate end-to-end maintenance of Python/ML open-source projects on GitHub: triage and analyze issues/PRs/discussions, resolve PR conflicts with attributed fixes, conduct multi-agent code reviews for quality/security/performance, prepare release artifacts/changelogs/migration guides, and optimize GitHub Actions CI/CD pipelines.

Audit Python code for vulnerabilities by combining static scans from Bandit, pip-audit, Safety, Ruff S-rules, and detect-secrets with LLM-powered analysis detecting logic flaws, auth bypasses, race conditions, injections, path traversal, and secrets exposure.

Clone untrusted Python dependencies from GitHub, decompose them into verifiable sub-packages via test-driven evaluation, generate focused pytest unit tests, rewrite imports, and iteratively implement secure from-scratch replacements to mitigate supply chain attacks.

Bootstrap Claude Code with 17 specialized agents, skills, and hooks to audit/evolve .claude/ configs, engineer/refactor Python code via TDD, profile/optimize ML workloads, generate docs/tests, design systems, diagnose issues, and manage workflows professionally.

Summon Python specialists to scaffold production Django/FastAPI projects with uv/Docker/PostgreSQL, enforce Mypy/PEP8/security reviews, audit codebases for multi-agent parallelization, implement Celery tasks/WebSockets, and generate pytest strategies—all using 2025 patterns and official docs.

Auto-format Python files with Ruff after file write or edit operations, ensuring consistent code formatting without manual steps

Execute structured humans-in-the-loop idea-to-code workflows: plan ideas, enforce TDD and incremental development, resolve git conflicts, debug CI failures on GitHub Actions, optimize Dockerfiles, apply design patterns, manage test infrastructure, and commit with prechecks using specialized skills, commands, and hooks.

Develop, test, debug, review, and migrate Keboola Python components for data pipelines—including extractors, writers, apps—with AI skills for config schemas (conditional fields, UI), code quality (Ruff, architecture), local datadir/pytest/VCR testing, uv/pyproject.toml upgrades, Docker builds, and platform context via MCP/Datadog.

Automatically observes coding sessions to generate project conventions, next-step suggestions, and codebase skills. Integrates runtime hooks that auto-commit, simplify code, deduplicate tests, apply biome/ruff formatting, capture learnings, and prompt context-aware suggestions after each user interaction.

Integrate Codacy code quality and security analysis into your Claude Code workflow: run local static analysis, query issues and findings, enrich pull request reviews, configure project settings, and set up test coverage reporting.

Enforce consistent formatting and AI-friendly conventions across your project: structured git commits, day-grouped changelogs, pseudo-XML AI instructions, and linting for Markdown, Python, and Rust.

Run AI-powered OpenStack code reviews against Gerrit/Zuul CI or local git history, producing structured reports with dead code detection, security auditing, style compliance checks, and documentation conversion.

Orchestrate AI coding agents through automated loops for end-to-end feature development: brainstorm and plan interactively, create GitHub issues/PRs, implement code, perform iterative simplify/code/security reviews, wait for CI/CD, fix issues, and repeat until clean and merge-ready. Generate and run custom StateGraph workflows from natural language prompts with quality gates and diagram previews.

Orchestrate multi-agent code review and development workflows with automated PR triage, commit drafting, and parallel test/lint execution, plus cross-session memory for conventions and preferences.

Orchestrate AI agent teams to dynamically plan multi-step Django projects with task dependencies and parallel execution, delegate implementation of models/views/serializers/admin/URLs following best practices, and validate via pytest tests, mypy checks, ruff linting, Django system checks, and migrations.

Audit Python test suites for inverted pyramids, coverage gaps, flakiness, distribution imbalances, and anti-patterns; diagnose root causes like race conditions or dependencies; review test code quality; set up CI/CD pipelines with progressive testing stages on GitHub Actions, GitLab, or Jenkins.

Perform thorough reviews of Python tests in code or projects using a standard checklist that evaluates isolation, mocks, execution time, flakiness, and naming clarity to uphold high testing standards.

Run Python unittest tests using the rut test runner as a pytest alternative, detecting and executing only changed tests via --changed, generating coverage reports, applying TDD principles, and streamlining debug workflows through comprehensive CLI options.

Scaffold opinionated Django projects with one-file-per-model organization, Ninja APIs via domain-grouped routers and Pydantic schemas, Unfold admin with HTMX and Tailwind, pytest tests using factory_boy, Dynaconf config, uv deps, and Docker setup. Delegate code reviews to the agent to enforce patterns after changes.

Build and audit production-grade Python packages with best practices for project structure, tooling (pyproject.toml, Ruff, mypy), testing (pytest, CI matrices), CI/CD (GitHub Actions, trusted publishing), documentation (MkDocs, Diataxis), API design (sync/async, pluggy), packaging (wheels, sdists, cibuildwheel), versioning (SemVer, changelogs), security (Sigstore, Dependabot), and developer experience (one-command setup, Makefile).

Enforce strict code quality conventions across Python, TypeScript, and Go codebases — naming precision, casing rules, import discipline, declaration ordering, symmetry, dead code elimination, and magic value refactoring. Audit repositories or files for violations and generate fix reports.

Run adaptive autonomous SDLC workflows that orchestrate agent teams to implement Python features via enforced TDD/BDD cycles with pytest-bdd scaffolding, git worktree isolation for parallel tasks, Beads CLI for dependency-tracked issue management, ruff/mypy/pytest verification pipelines, documentation updates, PR creation, and automated merges.

Run integrated Python TDD quality checks in your editor: execute pytest tests targeting 90%+ coverage, mypy strict typing, Black/isort formatting, and ruff linting for instant static analysis and code health enforcement during development.

Automate full GitHub PR preparation from any Python or Node.js branch: detect project type, set up/validate CI workflows, run local CI (linting with Ruff, type checks, tests, builds) with smart error recovery, generate Mermaid diagrams of file changes and CI results, create conventional PRs with summaries and test plans, then push, PR, optionally merge or release packages.

Run a multi-agent CI/CD preflight pipeline for Python packages that executes 8 sequential quality gates—linting with ruff/mypy, pytest tests/coverage, cross-platform compatibility, multi-version testing (3.9-3.13), security scans, API stability checks, and packaging validation—stopping on failure and auto-creating a GitHub PR with reports and diagrams on success.