Ruff plugins

Scaffold and develop production-ready Python projects with FastAPI, Django, async patterns, type safety, testing, and observability. Includes code generation, linting, profiling, packaging, and deployment guidance.

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.

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.

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.

Conduct comprehensive, multi-domain code reviews with automated blast radius analysis, architecture assessment, API surface evaluation, bug detection, test suite quality checks, and language-specific audits for Rust, shell, and math-heavy code. Orchestrate specialized reviews and enforce commit policies.

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.

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.

End-to-end toolkit for creating, packaging, and distributing professional Python libraries: from project setup with modern tooling (uv, ruff, pytest, GitHub Actions) through API design, CLI building, documentation (Sphinx/ReadTheDocs), testing, security auditing, and PyPI publishing with release management.

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 and maintain Python 3.11+ CLI applications with Typer/Rich, following TDD workflows with pytest, modern type hints, and pyproject.toml packaging. Includes code review, debugging, test analysis, CI/CD setup, and documentation generation.

Enforce code and documentation quality across your project with automated markdown linting, multi-agent code review (SOLID, security, performance), Python development guidance, codebase analysis, and self-healing post-edit hooks.

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.

Manage a persistent, agent-first cognitive substrate across Claude Code sessions — ingest raw notes via 20 fungal verbs, auto-assimilate at session boundaries, run schema migrations, sweep stale references, author craft proposals, and orchestrate full release pipelines with pre-flight gates and CI monitoring.

Run configurable code reviews with adjustable tone (harsh/constructive), enforce project standards via auto-generated Technical.md, and automate the full shipping workflow from review through PR creation and auto-merge. Includes live browser QA via Chrome for finding bugs, UX issues, and accessibility problems.

Enforce an AI-first SDLC with zero technical debt by running validators, compliance checks, and testing pipelines before commits and PRs. Automates branch naming, change proposals, code review, release packaging, and CI/CD workflow generation across Python, JS, Go, and Rust projects.

Enables AI-assisted ideation, planning, coding, code review, git, Kubernetes, TUI design, and Python packaging/linting/type-checking via specialized agent skills with persistent memory and multi-agent orchestration.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Convert CLAUDE.md rules into automated code checks using ESLint, Prettier, Biome, Ruff, and GitHub Actions workflows. Run verifications to confirm passes, then remove implemented rules to optimize agent context and cut token usage in AI interactions.

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 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.

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.

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.

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).

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.

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.

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.