Pytest plugins

Enforce a structured TDD workflow with parallel task execution, isolated git worktrees, and systematic code review. Guides root cause investigation before fixes, verifies tests and linters pass before claiming completion, and dispatches subagents for independent tasks like fixing multiple test failures simultaneously.

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.

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.

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.

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 literature review, paper writing, and project knowledge management. Integrates with Zotero and Obsidian to search papers, extract writing patterns, generate structured manuscripts, manage citations, and produce conference materials. Also includes general-purpose development tools for code quality, debugging, Git workflows, and project scaffolding.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

Enforces Test-Driven Development by detecting your test framework (Vitest, Jest, Storybook, pytest, Go), installing the matching reporter, and blocking direct file edits to redirect reads through a custom pipeline that runs on session start and each user prompt.

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.

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.

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.

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.

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.

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.

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.

Automate end-to-end QA workflows across UI, API, and accessibility testing using Playwright, Selenium, and REST Assured—plan tests, generate ISTQB-aligned artifacts, debug failures, and heal flaky tests through coordinated agent delegation.

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.

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.

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.

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.

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 shared infrastructure and pipeline building blocks for Claude Code plugins, including authentication patterns, content sanitization, error recovery, service registration, quota tracking, supply chain security auditing, and cross-plugin testing standards.

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.

Run multi-dimensional code reviews with specialized analysis for architecture, API surfaces, blast radius, bugs, Rust safety, math correctness, test quality, Makefiles, shell scripts, and code quality — all coordinated by orchestration skills for comprehensive pre-release or pre-PR audits

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.

Run an AI engineering agent team for Python/TypeScript/Go monorepos that plans, implements, tests, reviews, and deploys features through a progressive-disclosure pipeline — from spec grooming and architectural analysis to CI-validated PRs and on-call failure remediation.

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.

Manage unbounded context in Claude Code by routing queries across multiple LLM providers with recursive analysis, hallucination detection, and performance benchmarking.

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.

Package, release, and distribute Python libraries with modern tooling: pyproject.toml, build backends, PyPI publishing, and GitHub Actions automation. Includes workflows for testing, documentation, security auditing, API design, CLI building, and release management.

Accelerate ML experimentation by automating the full iteration loop: from experiment proposals and project scaffolding to pipeline declarations, model evaluation, audit digest generation, and test-driven validation. Includes environment bootstrapping and code quality enforcement.

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

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.

Write and run Pytest test suites with fixtures, parameterization, hooks, coverage, and plugins, including custom plugin development for Python projects

Automate Unity Editor workflows from Claude Code: build, debug, profile, manage assets, manipulate scenes, test UI, and execute arbitrary API methods via the unity-cli CLI tool.

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.

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.

Build, test, and compare Bayesian models with PyMC 6+ and ArviZ, including prior selection, spline regression, model comparison via LOO-CV and Bayes factors, and unit testing with pytest. Also create and convert marimo reactive notebooks for exploratory data analysis.

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.

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.

Manages a long-term cognitive substrate for agent-first knowledge work across sessions, using 20 fungal-verb operations for ingestion, digestion, circulation, and homeostasis. Includes automated drift detection, migration drafting, release pipeline orchestration, and a local MCP server with stdio and OAuth 2.1 transports.

Generates unit, integration, and e2e tests using Jest, Vitest, Pytest, Cypress, or Playwright; researches documentation and best practices via web search; creates formatted reports (PDF, DOCX, HTML); and manages CLAUDE.md files by scanning workspaces and analyzing staged git changes. Also optimizes 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 AI-First SDLC policies with zero technical debt by automating pre-commit validation, compliance checks, and CI/CD workflow generation for Python, JavaScript, Go, and Rust projects. Manage agent teams and gatekeep PRs with automated testing and security scans.

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.

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.

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.

Auto-detects JS/TS/Python/Go/Rust/PHP/Java projects, installs linting/typechecking/testing tools, and generates custom /fix, /test, /commit, /update slash commands using parallel Claude agents to audit dead code, security risks, deprecations, generate tests, commit safely, and update dependencies.

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.

Automate review-driven development workflows: requirement interviews, git worktree branching, test-first implementation, automated verification (Playwright, vitest, pytest, Maestro), evidence collection, and structured report generation for PR sign-off.

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.