Pytest plugins

Enforce test-driven development, structured debugging, and code review workflows in Claude Code. Plan features in granular tasks, execute them in isolated worktrees with parallel subagents, and verify completeness with automated checks before merging.

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.

Generate production-ready stateful CLI harnesses for GUI applications from local paths or GitHub repos, implementing Click CLI with REPL/JSON support, pytest unit/E2E tests, and docs. List installed harnesses, refine coverage gaps, run tests to verify functionality, and validate against standards.

Enforce strict red-green-refactor TDD cycles: generate failing tests, implement minimal passing code, then refactor while keeping tests green. Includes AI-powered code review for security and quality.

Implement a complete QA and testing workflow: set up A/B tests with hard gates, automate browser testing with Playwright/Puppeteer, enforce code review checklists and TDD, debug systematically, and fix failing tests using pytest patterns.

Centers Python backend development around async patterns, FastAPI, Django, and modern tooling, providing architectural guidance, testing strategies with pytest, and production best practices for scalable APIs and services.

Manage Python projects via structured tracks for features, bugs, refactors: initialize context artifacts like product.md and tech-stack.md, create detailed specs and phased plans, implement tasks with strict TDD workflow using pytest coverage and git commits, monitor status, revert commits, and validate artifacts for consistency.

Evaluate and improve LLM applications by instrumenting agents, chatbots, and RAG pipelines with DeepEval tracing, generating test suites, running evaluations, and exporting traces to Confident AI for observability and iterative refinement.

Autonomously optimize code files by measurable metrics through iterative experiments: set up target file, eval command, and loop intervals (10min-monthly); AI edits code, commits to git branches, evaluates with Python, keeps improvements. Resume, run manually, or check dashboard status.

Spawn parallel AI subagents in isolated git worktrees to compete on tasks like code optimization, refactoring, test writing, or bug fixing. Evaluate results using pytest metrics or LLM judging on git diffs, rank agents, and merge the top performer into your base branch.

Semi-automated research assistant for academic ML/AI research and software development, enabling literature review with Zotero integration, paper writing with Nature/NeurIPS templates, experiment analysis with statistical validation, and Obsidian-based project knowledge management, plus code quality enforcement and CI workflows.

Automatically generate production-ready unit tests from source code files or snippets in JavaScript/TypeScript (using Jest, Vitest, or Mocha), Python (pytest), Java (JUnit 5), and Go. Auto-detects frameworks, covers happy paths, edge cases, boundaries, errors, and provides mocks for robust testing.

Detect and rewrite AI-generated Korean text to sound human-written, using a multi-phase pipeline that scans for 40+ AI-typical patterns across 10 categories, preserves content, and validates semantic equivalence.

Set up new or migrate existing Python projects using uv for dependency/environment management, ruff for linting/formatting, mypy for type checking, and pytest for testing, while enforcing shell restrictions for security.

Automate overnight software development by configuring Git hooks for TDD enforcement with tests and lints, then run Claude autonomously for 6-8 hours to build features that pass all checks by morning.

Automate full Databricks lakehouse lifecycle: build Delta Lake ETL pipelines with medallion architecture and Auto Loader, engineer ML workflows via MLflow and Feature Store, deploy jobs/pipelines with Asset Bundles and GitHub Actions CI/CD, secure via Unity Catalog RBAC, optimize costs/performance, troubleshoot errors, and monitor with system tables.

Track regression tests across code releases by mapping git commits to pytest or Jest tests, tagging markers for suites, flagging coverage gaps, generating pass/fail reports with flaky detection, viewing history, and enforcing runs in CI/CD pipelines.

Generate test reports by parsing JUnit XML, Jest JSON, pytest results, and coverage data into Markdown/HTML formats with metrics, failures, slowest tests, trends, and CI annotations. Aggregate results across frameworks for summaries and exports in HTML, PDF, or JSON.

Analyze test coverage reports from Jest/nyc, pytest, Go test, and JaCoCo across JavaScript, Python, Go, and Java projects to identify untested code paths, branch gaps, low-coverage files, enforce thresholds, and generate detailed reports with targeted test recommendations.

Orchestrate multi-agent coding workflows with context-aware task decomposition, parallel subtask execution, automated code review, and TDD test generation.

Provision and manage isolated test environments using Docker Compose and Testcontainers for databases, caches, queues like PostgreSQL, MySQL, Redis, DynamoDB. Generate docker-compose files, env vars, seed data scripts, startup scripts, and cleanup code to enable reliable, reproducible testing without local setup conflicts.

Generate test doubles—mocks, stubs, spies, fakes—for unit testing by analyzing code dependencies. Produces implementations, fixtures, example tests, and rationale. Works across JavaScript (Jest, Vitest, Sinon), Python (pytest, unittest.mock), Go (gomock), and more frameworks.

Generate realistic test data for users, products, orders, technical fields, and custom schemas to populate fixtures, factories, seeds, edge cases, and databases in JS/TS/Python/Ruby apps using Faker.js, Fishery, pytest fixtures, and factory patterns.

Orchestrate complex test workflows across Jest, Vitest, pytest, Playwright, and Cypress with parallel execution, test sharding, dependency management, flakey retries, affected test selection, and result aggregation in GitHub Actions or GitLab CI. Generate optimized configs for CI/CD pipelines.

Automate database testing workflows by generating test suites with data factories, transaction wrappers for automatic rollback, schema validation, assertions, cleanup, fixtures, migrations, integrity checks, and performance monitoring across PostgreSQL, MySQL, MongoDB, SQLite, Redis using Prisma, Drizzle, Jest, Pytest.

Generate and execute comprehensive test suites for REST and GraphQL APIs directly from OpenAPI specs, automating request generation, schema/response validation, CRUD coverage, auth handling, error/performance checks, idempotency tests, with reporting in Jest, pytest, Supertest, or REST-assured.

Create and manage snapshot tests for UI components and data using Jest, Vitest, or pytest to catch regressions. Analyze test failures with intelligent diff reviews, selectively update snapshots for intentional changes, validate and organize snapshot files, then generate detailed analysis reports.

Integrate SerpApi into Python and Node.js/TypeScript apps to extract structured search data from Google, Bing, YouTube, Shopping, News, and Maps. Automate setup, auth, cost-free local testing with pytest/Vitest fixtures, Redis caching, rate limiting, proxy deployment to Vercel/GCP/Fly.io, security hardening, production checklists, SEO monitoring, and legacy migrations via 18 Claude Code skills.

Build, deploy, optimize, secure, and troubleshoot Python pipelines exporting Clari revenue forecasts, quotas, CRM data, and adjustments to Snowflake, BigQuery, or PostgreSQL. Includes CI/CD integration, API debugging, cost/performance tuning, local mocks, schema migrations, rate limit handling, and production checklists.

Enforces Test-Driven Development by detecting the test framework, installing a reporter, and outputting test results. Blocks file writes with forbidden terms and enforces semantic rules via bash guards and LLM prompt checks.

Enforce TDD and SDD workflows with AI-driven agents that scaffold projects, generate tests, debug failures, reverse-engineer docs, and orchestrate batch task execution from design plans.

Delegate specialized AI agents to automate code reviews on git diffs, security audits for APIs and auth per OWASP, debugging of errors and incidents, test generation with Jest/pytest, performance profiling, and quality assurance across dev workflows.

Automate aiobotocore GitHub workflows for botocore syncing: bump versions with pyproject.toml bounds and CHANGES entries, classify bumps and override drifts, port sync tests to async pytest counterparts, create PRs with templates and checklists, synthesize PR reviews into asked/done/outstanding action plans, detect Pyright errors, and post inline code quality findings.

Generate unit tests for functions, classes, or modules using your project's Jest or Pytest framework. Automatically mocks dependencies, follows conventions, runs tests, and reports count plus coverage to accelerate testing workflows.

Profile API endpoints to measure latencies and detect bottlenecks like N+1 queries or missing indexes, then run benchmarks on functions and modules with vitest or pytest for ops/sec, memory usage, comparisons, and prioritized optimization suggestions with impact estimates.

Run a phased performance investigation workflow that establishes baselines, maps code paths, profiles hotspots with flame graphs, generates and tests hypotheses via benchmarks, logs evidence, and synthesizes recommendations with decisions for Node/JS, Python, Rust, Go, Java projects.

Generate and run unit tests for functions and classes across Jest, Vitest, or Pytest, mocking dependencies, covering happy paths, edge cases, errors, and providing coverage summaries. Create integration tests using Docker to simulate real database, API, and queue interactions with full verification.

Delegate complex Python tasks to an expert agent that optimizes performance on large datasets via profiling, refactors synchronous code to async/await patterns, implements advanced design patterns with decorators and metaclasses, and ensures quality through pytest testing and mypy type checking.

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.

Execute end-to-end feature development via phased AI waves—DISCOVER products with JTBD interviews, DISCUSS requirements and UX journeys, DESIGN architectures with C4 diagrams, DEVOPS infrastructure with Terraform/K8s, DISTILL BDD tests, DELIVER TDD code—enforced by 23 agents, automated reviews, and quality gates for production-ready outputs.

Build, audit, and optimize Claude Code plugins using structured workflows for skill/hook authoring, TDD validation, quality scoring, security compliance, and performance analysis across plugin, project, and global scopes.

Run autonomous full-stack dev workflows in Claude Code: generate PRDs/specs via interviews, execute Ralph/autodev loops for overnight PRD implementation with git branching/testing/committing, parallelize tasks across 12 agents (architect, frontend-dev, code-reviewer), build React/Tailwind/shadcn UIs and FastAPI backends, TDD/E2E test/verify/review code, automate git commits/PRs, and audit harness health.

Orchestrate end-to-end QA automation across Playwright and Selenium — generate, execute, and debug UI, API, and accessibility tests, plan regression suites with ISTQB-aligned artifacts, and heal flaky tests via delegated specialist agents.

Delegate complex Python tasks to a specialized expert agent for performance optimization via profiling, refactoring synchronous code to async/await patterns, implementing advanced design patterns with decorators and metaclasses, pytest testing, and mypy type checking.

Optimize Claude Code sessions by detecting/removing codebase bloat, dead code, and AI-generated hygiene issues; manage token budgets/context windows with MECW principles and subagent delegation; monitor CPU/GPU usage before intensive tasks; automate safe git-backed cleanups and audits.

Automate Git-centric development workflows: generate conventional commit messages from changes, prepare PRs with quality gates and self-reviews, fix review feedback across steps from triage to validation, consolidate ephemeral docs into permanent ones, update tests and tutorials, bump versions with changelogs, and manage dependencies in Python/JS/Rust/Go repos.

Delegate complex Python code tasks to a specialized agent that optimizes performance via profiling, refactors synchronous code to async/await, implements advanced design patterns with decorators and metaclasses, writes pytest tests, and applies mypy type checking.

Provides foundational infrastructure patterns and pipeline building blocks for Claude Code plugins: authentication, supply-chain security audits, error recovery, testing standards, quota tracking, service registration, document ingestion, and git-platform detection. Includes CLI commands for plugin cache refresh and attestation-based trust verification.

Orchestrate a fleet of 11 AI-powered QE agents to automate comprehensive quality engineering: generate unit/integration/E2E tests for Jest/Vitest/Playwright/Pytest, perform sublinear coverage analysis and gap prioritization, run chaos/resilience experiments on Docker/K8s, guide TDD workflows, benchmark performance, enforce git/CI quality gates, detect flakiness/security issues, and produce reports.

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.

Orchestrate full SDLC lifecycle phases from Inception through Transition using 58 AI agents and 170+ components to automate requirements, architecture evolution, testing orchestration, security gates, deployments, incident response, and project reporting via workflows, phase transitions, and quality checks.

Execute structured, evidence-driven engineering workflows in Claude Code across 5 phases (Investigate, Design, Implement, Verify, Ship) using 15 skills and 8 specialist agents that enforce TDD, root-cause analysis, architecture/UX/security reviews, dependency audits, PR preparation, and incremental shipping with pasted test outputs, logs, and diffs as proof before advancing.

Orchestrate an opinionated agent team that ships features through PM/SWE/Tester sub-agents with progressive-disclosure specs, day/night pipelines, automated PR management, CI monitoring, and structural refactoring for Python/TypeScript/Go monorepos.

Build and maintain Playwright + pytest test suites using a Page Object Model governance framework: generate PageObjects and tests from live DOM, replace fragile selectors with stable ones, and diagnose failures by jumping directly to the failing page without login. The agent enforces POM patterns, configures browsers, and analyzes test results with automated fix workflows.

Generate complete, tested Python CLIs for closed-source web apps by capturing HTTP traffic with Playwright, reverse-engineering APIs, implementing Click commands with CRUD wrappers, running pytest suites, and validating against standards via a single pipeline command.

Test REST and GraphQL HTTP APIs in TypeScript/JavaScript projects using Supertest and Vitest or in Python projects using httpx and pytest. Validate requests and responses, implement authentication flows, and verify error handling directly in your code.

Orchestrate plan-first AI development with parallel autonomous agents in isolated git worktrees. Plan multi-step tasks, enforce TDD for implementations, dispatch foragers for bugs and features, execute in batched sessions with checkpoints, verify builds/tests/lints, and run systematic code reviews before merging.

Automate the full development lifecycle — from requirements gathering and multi-layer testing to PR creation, code review, and merge — using 145+ slash commands, an agent orchestrator with tmux-based workers, and multi-model AI analysis across Gemini, Cerebras, and Claude.

Extend Claude Code with recursive language model orchestration for managing large codebase context: routes queries across multiple LLM providers, partitions context into sub-queries, and detects hallucinations via epistemic verification. Includes performance benchmarks, code review, and trajectory analysis.

Guides startup founders through idea validation, competitive research, hypothesis testing, customer interviews, surveys, and MVP design—all stored locally with structured artifacts and automated analysis.

Enforce a specification-first development workflow: decompose requirements into atomic specs, run automated gates, evolve specs via agent cycles, and use pair programming (Navigator-Driver) with independent test generation.

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.

Perform safe, reviewable agent-driven development using RPEQ workflow: research codebase with parallel agents for structure, patterns, and analysis; generate unambiguous execution plans; execute incrementally with atomic git commits, quality gates, and deployments; conduct QA for risks and correctness. Specialized agents handle TDD Python implementation, refactoring, security orchestration, and docs maintenance.

Engineer robust ETL pipelines: clean messy CSVs/Parquet, infer schemas, profile datasets, detect anomalies, validate quality with Pydantic/Pandera/Great Expectations, implement incremental patterns, generate dbt models/SQL migrations/tests, and orchestrate autonomous backfills/pipeline testing via agents and CLI commands.

Run, generate, debug, and harden software tests using pytest, Playwright, Jest, Cypress, and more; scan OpenAPI specs for OWASP API Top 10 vulnerabilities and solve CAPTCHAs via an AI visual solver

Automate full-cycle agentic coding workflows in Claude Codebases: classify GitHub issues into chores/bugs/features, generate plans/specs, implement/review/fix code with tests, track KPIs, and ship PRs to main using 89 skills and 34 specialized agents for Zero-Touch Engineering.

Build, extend, debug, test, and deploy FastMCP 3.x Python MCP servers with provider/transform architecture (CodeMode, Tool Search), MultiAuth/PropelAuth, Pydantic validation, async patterns, nginx proxy, background tasks, and client SDK integration. Invoke tools via CLI on HTTP/STDIO servers and run local reference implementations for rapid prototyping.

Enforce Python code quality with a verified-issue workflow: review FastAPI routing, SQLAlchemy database patterns, PostgreSQL queries, pytest tests, and general Python type safety, using parallel linters (ruff, mypy) and multi-step verification to eliminate false positives.

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.

Run a structured ML experimentation loop: from EDA and pipeline declaration to evaluation, smoke testing, and audit-driven backlog generation. Use skrub DataOps graphs, skore reports, and a prescribed Python stack to keep experiments reproducible and documented.

Use pytest with advanced patterns (markers, custom assertions, coverage) and fixtures with various scopes, plus leverage the plugin ecosystem (pytest-cov, pytest-mock). Automated hooks log file writes and web fetches to a knowledge base for enhanced testing workflows.

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 Unity editor workflows — building, debugging, profiling, asset management, UI testing, and scene construction — entirely from the command line via the unity-cli tool, without leaving Claude Code.

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.

Delegate codebase tasks to a coordinated team of AI agents that automatically test, review, debug, secure, refactor, document, optimize performance, set up CI/CD, audit dependencies, and perform bulk search-replace across JavaScript, Python, Rust, and Go projects, with intelligent routing to subagents based on issue severity.

Execute unit/integration/E2E tests across Python (pytest), JS/TS (Vitest/Jest), Rust (cargo), Go projects with quick/fail-fast/full runs, coverage, reports, and Playwright browser automation. Analyze test quality for smells/gaps, run property/mutation testing, and consult TDD strategies for effective suites.

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.

Automate comprehensive API quality assurance for REST APIs, GraphQL, and microservices, running functional, performance, load, security, regression, contract, and automation tests to validate robustness before deployment.

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.

Delegate Python 3.12+ project setup, code optimization, debugging, web app development with FastAPI/Django/Flask, async patterns, pytest/hypothesis testing, AI/ML workflows, and packaging to an expert agent using modern tools like ruff/pyright/uv.

Scaffold open-source research software projects with community health files, GitHub templates, and onboarding docs; validate documentation quality via linting, link checks, and setup testing; assess handoff readiness with health reports on docs, CI/CD, and tests.

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.

Automate documentation, test generation, and prompt optimization within Claude Code sessions — maintain CLAUDE.md files from git changes, generate tests with Jest/Vitest/Pytest/Cypress/Playwright, and refine prompts for AI models using chain-of-thought and few-shot techniques.

Automates a spec-driven development loop that transforms rough ideas into structured specifications, implements tasks with TDD and behavioral guardrails, traces bugs back to spec gaps, and enables multiplayer collaboration with knowledge graph integration.

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.

Test REST and GraphQL APIs in TypeScript/JavaScript with Supertest/Vitest or Python with httpx/Pytest, handling auth, validation, and errors. Enforce contracts via Pact for consumer-provider agreements and OpenAPI spec validation to detect breaking changes in CI pipelines.

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 full SDLC workflows for Python/JavaScript/TypeScript/Go projects using an 8-agent pipeline that orchestrates research, planning, TDD test generation, code implementation, reviews, security audits, and auto-updates docs on commits while enforcing PROJECT.md alignment and best practices.

Hunt bugs in Python codebases, modules, files, or functions with Hypothesis property-based testing. Analyze code to propose properties, generate and run pytest tests, then triage failures to identify root causes.

Drive Python development workflows: plan tasks with structured scopes, build TDD-first features, refactor via test coverage audits, investigate-debug with evidence gathering and regressions, fix bugs minimally, and run multi-agent code reviews across architecture, security, and quality.

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.

Delegate specialized AI subagents to handle code reviews across languages, generate comprehensive API docs for REST/GraphQL/gRPC, perform QA audits and build test automation frameworks with Playwright/Cypress/Pytest, optimize system performance, architect scalable LLMs, develop TypeScript apps, create dev tools, and coordinate multi-agent teams using Drucker principles.

Run structured AI-driven agile development workflows using 100+ skills and 22 agents: initialize projects, create PRDs/epics/stories/GDDs, implement code with tests via engineer/QA agents, sprint planning/status/retrospectives, architecture/design, and reviews for software or games.

Build production-ready Python applications with Django, FastAPI, and async patterns. Scaffold projects using uv, enforce code quality with ruff/mypy, implement background jobs with Celery, add structured logging and metrics, and apply resilience patterns like retries and timeouts.

Build, iterate, and test Bayesian models using PyMC within marimo reactive notebooks, with fast test fixtures and CI/CD-friendly model validation.