Pytest plugins

Enforces a structured TDD workflow with parallel task execution, code review, and root-cause debugging. Guides brainstorming into validated specs, creates isolated git worktrees for feature branches, and runs verification checkpoints before merging or committing.

Build production-ready Python applications with modern async patterns, type safety, and testing. Scaffold projects using FastAPI or Django, manage dependencies with uv, enforce code quality with ruff, and implement structured observability, retries, and background jobs.

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.

Automate the full TDD red-green-refactor cycle: generate failing tests, implement minimal passing code, safely refactor, and get AI-driven code review with security and performance analysis.

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.

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.

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.

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.

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.

Automate the full lifecycle of academic research projects from literature discovery and review to experiment analysis, manuscript drafting, and reviewer rebuttals, while also offering code quality checks, git workflow enforcement, and project scaffolding for software development.

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.

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.

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.

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.

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

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.

Build plugin infrastructure with authentication patterns, supply-chain security auditing, quota tracking, service registry management, agent state recovery, structured logging, and quality scoring gates — then deploy with one-command reinstall and SLSA-backed 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.

Run structured multi-domain code reviews combining architecture analysis, API surface inspection, blast radius risk scoring, bug detection, test quality evaluation, and language-specific audits (Rust, shell, math) into unified reports with actionable recommendations for pre-release and pre-PR quality gates.

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.

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.

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.

Extends Claude Code with recursive language model orchestration for unbounded context handling across large codebases, including multi-provider routing, hallucination detection via epistemic verification, trajectory analysis, and performance benchmarking.

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.

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.

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.

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.

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.

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.

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.

Automate Unity game development workflows using unity-cli: build and verify projects, debug runtime errors, profile performance, manage assets and scenes, test UI layouts, and invoke arbitrary API methods directly from the CLI. Includes agents for documentation and version management, plus hooks for custom automation.

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.

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 cognitive substrate for agent-first, long-term knowledge across Claude Code sessions using 20 fungal-named verbs for ingestion, digestion, circulation, and homeostasis, with automated health checks, drift detection, schema migration, release pipeline orchestration, and git-backed memory persistence.

Drive an ML experimentation workflow in Python — propose experiments, structure projects, build sklearn-compatible pipelines, evaluate learners, audit results, and enforce code quality with ruff and pytest.

Generates tests, optimizes prompts, researches documentation, and creates formatted documents (PDF, DOCX, HTML) from markdown. Manages CLAUDE.md files by scanning workspace structure and updating from git changes.

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 automating Python validation (ruff, pytest, mypy, bandit), enforcing conventional git commits and branch workflows, generating CI/CD pipelines, and gating pull requests with compliance checks.

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.

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.

Manage full development lifecycle from requirements gathering to PR submission with built-in review agents for code quality, security, E2E tests, and UI/UX. Automates commit workflows, generates structured reports with evidence, and enforces verification for web, backend, and mobile projects.

Guides AI-assisted development through a spec-driven TDD workflow: triage, spec writing, architecture evaluation, TDD planning, ping-pong test-code cycles, browser verification, and code review. Includes codebase analysis, dependency analysis, git hotspot detection, and design discovery.