Pytest plugins

Design and implement backend systems with REST/GraphQL APIs, microservices, event sourcing, CQRS, and Temporal workflows, including testing, security auditing, and performance optimization.

Generate unit and integration tests for Python and JavaScript with mocking, edge cases, and framework-specific patterns. Includes debugging and test automation with self-healing tests and CI/CD integration.

Orchestrates end-to-end full-stack feature development with specialized agents for architecture, implementation, testing, security, performance, and deployment, using an API-first approach and interactive checkpoints.

Generate stateful CLI interfaces for any GUI application using the cli-anything harness methodology. Includes commands to build, list, refine, test, and validate CLI harnesses, enabling interactive REPL sessions and JSON output.

Develop production-ready Python backends with async patterns, modern frameworks (FastAPI, Django), and best practices for architecture, testing, and performance.

Add DeepEval evaluation loops, tracing, and dataset generation to AI applications, enabling span-by-span observability in Confident AI and iterative improvement on failures.

Conduct end-to-end academic research with AI/ML: literature discovery from arXiv/Zotero, paper ingestion into an Obsidian knowledge base, experimental analysis with statistical rigor, publication-ready figure/writing/rebuttal generation, and knowledge management across sessions.

Test Temporal workflows using pytest with time-skipping, mocking strategies, and unit, integration, replay testing

Run pytest tests with coverage, identify uncovered lines via annotated source files, and iteratively add tests to reach 100% line coverage.

Generate comprehensive unit tests from source code with automatic framework detection, covering happy paths, edge cases, error handling, and mocking for multiple languages.

De-identify PHI, extract clinical named entities, map to FHIR R4 and OMOP CDM, run compliance audits, and evaluate model fairness—all on-device.

Configure Python projects using modern tooling (uv, ruff, pytest) and prevent accidental production deployments by requiring confirmation for deploy commands.

Manage and run regression test suites across releases, mapping tests to bug tickets, detecting flaky tests, and analyzing change impact to prevent breaking existing functionality.

Generate structured test reports from JUnit XML, Jest JSON, and pytest results, producing Markdown summaries, HTML dashboards, and CI annotations with coverage metrics, pass/fail analysis, and trend comparisons.

Set up and manage comprehensive testing infrastructure across unit, integration, E2E, visual, load, mutation, and property-based testing. Analyze code quality, generate tests, enforce quality gates, and automate TDD workflows with CI/CD integration.

Orchestrate complex test workflows with parallel execution across multiple frameworks, intelligent sharding, retry logic, and CI pipeline generation. Manage test dependencies and run only affected tests based on file changes.

Manage and update snapshot tests across Jest, Vitest, Playwright, and Storybook with intelligent diff analysis for selective updates and regression testing.

Generate realistic test data with locale awareness, producing factory functions, database seed scripts, and fixture files ready for immediate use in tests.

Run integration tests with automated Docker environment setup, database seeding, and cleanup, validating API calls, database queries, and message queue interactions across services.

Guides test-first (TDD/SDD) development from planning through implementation, verification, and debugging. Analyzes codebases to reverse-engineer specs, generates requirements and test cases, runs Playwright E2E tests, detects security vulnerabilities, and produces architecture diagrams and design documents.

Write, test, profile, and publish Python code with async patterns, pytest, ruff, and performance tools. Agents handle code review, bottleneck analysis, and packaging to PyPI.

Orchestrates multi-agent AI swarms across Claude Code, Gemini CLI, and Codex CLI to autonomously manage GitHub issues from creation through merged PR, with TDD enforcement, design review gates, adversarial code review, and PR shepherding.

Orchestrate an opinionated agent team for Python/TypeScript/Go monorepos: plans via product-architect grills, implements via SWE↔Tester loops, reviews PRs, and drives CI green — all through progressive-disclosure specs that agents load on demand.

Deploy a fleet of specialized AI agents for quality engineering: automated test generation, sublinear coverage analysis, chaos/resilience testing, mutation testing, flaky test remediation, and quality gate enforcement across CI/CD pipelines.

Test HTTP APIs (REST and GraphQL) with request/response validation, authentication, and error handling using Supertest for TypeScript/JavaScript and httpx/pytest for Python.

Drop-in agentic loops for autonomous ML research, data analysis, scientific writing, code/SQL/prompt optimization, red-teaming, and power analysis — each binds to your own task at invocation time.

Generate, maintain, and debug Playwright Page Object Model tests with live DOM extraction, locator healing, and failure analysis, keeping test suites aligned with evolving frontends.

Turn Claude Code into a QA engineer capable of writing and executing end-to-end tests with Playwright and Cypress, API tests, unit tests with Jest and pytest, performance tests with k6, and running an autonomous QA agent that explores apps, generates tests, and self-heals.

Adds recursive language model orchestration with multi-provider routing, unbounded context handling, and epistemic verification for hallucination detection. Externalizes conversation and files as Python REPL variables for efficient large-context analysis.

Generate agent-native CLI tools for any web app by recording and analyzing its network traffic, then automatically implementing, testing, and validating the resulting Python CLI package.

Enforce AI-first code conventions, audit staged diffs for OWASP security issues, generate architecture docs and session summaries, and check tool-stack freshness — all via skills, hooks, and agents that complement other plugins.

Adds Pytest expertise for writing and running Python tests with fixtures, parameterization, markers, coverage reporting, and plugin integration such as pytest-cov and pytest-mock.

Orchestrate end-to-end machine learning experimentation workflows using the Python data science stack, from project scaffolding and exploratory analysis through pipeline design, evaluation, testing, and iteration tracking.

Provides a dedicated QA engineer that creates test strategies, builds E2E suites with Playwright or Cypress, performs API testing (REST, GraphQL, gRPC), audits test health for flaky tests and coverage gaps, and runs visual design reviews.

Perform a comprehensive test reconnaissance: inventory test frameworks, test files, code coverage, and CI integration, and assess testing maturity for project takeover or audit.

Generate a test strategy for a project or feature including risk map, test type decisions (unit/integration/E2E), coverage targets, and CI configuration. Handles queries like 'create test strategy', 'testing plan', or 'improve test coverage'.

Query Python import and call graphs to measure blast radius and coupling before editing code, rename symbols with safe refactoring, and auto-select affected tests

Enables safe, reviewable, incremental agent-driven development with a structured RPEQ workflow (Research, Plan, Execute, QA). Provides tools for codebase analysis, implementation planning, gated execution, QA, debugging, and documentation, all integrated with git and CI.

Audit, validate, and evolve Claude Code agent/skill/hook configurations with adversarial review, performance profiling, and automated governance — turning ad-hoc AI-assisted coding into a disciplined, self-improving development workflow.

Enforce test-first Python development with structured workflows for planning, debugging, feature implementation, bug fixing, refactoring, and code review. Integrates CI support and quality checks throughout the process.

Orchestrate plan-first AI development using batched parallel agents: decompose features into sub-tasks, enforce TDD and verification before commits, dispatch independent work in isolated git worktrees, and review with falsification-first checks.

Generate and run tests across pytest, Playwright, Jest, Cypress, and more; debug failures; and scan APIs for OWASP Top 10 vulnerabilities — all from Claude Code.

Manage the full Testany test lifecycle: generate test cases from requirements, orchestrate pipelines with dependencies and variable relays, execute tests with monitoring, diagnose failures with root cause analysis, and configure CI/CD triggers via webhooks or scheduled plans.

Review Python/FastAPI backend code with automated checks for SQLAlchemy ORM patterns, PostgreSQL query optimization, pytest test quality, and type safety, using a multi-step verification protocol to eliminate false positives

Establishes opinionated Python 3.11+ engineering standards with SOLID principles, strict typing, ruff linting, pytest testing, and uv tooling. Routes tasks to specialist skills for TDD, CLI apps (Typer/Rich), web APIs (FastAPI/Django/Flask), data/science workflows, CI/CD publishing, and constrained environments.

Develop Bayesian probabilistic models with PyMC, analyze posteriors with ArviZ, and build interactive data notebooks with marimo, including prior selection, model comparison, spline regression, and pytest-based testing for MCMC workflows.

Build, validate, and migrate data pipelines with ETL reliability patterns, data profiling, quality checks, schema inference, and synthetic test data generation for CSV, Parquet, JSON, and SQL databases.

Streamlines Python development with automated workflows for building Django and FastAPI apps, managing SQLAlchemy databases with Alembic, writing pytest tests, debugging errors, and enforcing code quality.

Accelerates Python 3.11+ development with CLI app creation (Typer/Rich), pytest-based TDD, code quality tooling (ruff/mypy), and modern packaging workflows. Includes structured feature planning, debugging, code review, and documentation generation.

Build, test, and deploy FastMCP v3 Python MCP servers using provider/transform architecture, multi-auth, and async patterns. List tools, invoke calls, and validate with pytest and in-memory transports.

Set up and maintain scientific Python projects with best practices for code quality, environment management, packaging, testing, and documentation. Automates configuration of ruff, mypy, pre-commit, pixi environments, pyproject.toml packaging, pytest testing, and Sphinx/MkDocs documentation following Scientific Python community standards.

Enforce an AI-first SDLC with zero technical debt through automated validation, compliance checks, and workflow gates across the development lifecycle, from project commissioning to pull requests and releases.

Standardize Python project setup, modern coding conventions, SQLAlchemy 2.0 ORM patterns, and pytest testing practices. Use shared skills for dependency management, linting/typing with ruff and mypy, writing type-hinted Python with dataclasses and match statements, plus fixture-based test suites with coverage.

Autonomous spec-driven development loop: turn rough ideas into structured requirements, decompose them into dependency-ordered task plans, then implement, test, review, and commit each task with behavioral guardrails and knowledge-graph context.

Manage Python projects with uv for dependency management, testing with pytest, code quality with ruff (linting/formatting), static type checking with ty/pyright, and packaging for PyPI deployment, with integration for VS Code and GitHub Actions.

Test HTTP APIs (REST/GraphQL) with request/response validation, authentication, and error handling using Supertest for TypeScript/JavaScript and httpx/pytest for Python. Set up contract testing with Pact and OpenAPI spec validation for CI breaking change detection and compliance checks.

Automated test execution, analysis, and quality improvement across Python, JavaScript/TypeScript, Go, and Rust projects. Provides property-based testing, mutation testing, test smell detection, multi-tier test runner (unit/integration/E2E) with fail-fast execution, and CI setup. Supports pytest, Vitest, Jest, Playwright, Cypress.

Build modern Python applications with expert patterns for async/await, type hints, FastAPI, testing, uv packaging, and deployment to Cloudflare and Modal. Also includes OpenCV computer vision and FFmpeg video/audio processing with GPU acceleration.

Guides AI-assisted development through a spec-driven TDD workflow: triage, discovery, spec writing, architecture evaluation, TDD planning for various patterns (outside-in, ping-pong, CQRS, MVC), code generation, test writing, browser verification, code quality and hotspot analysis, and structured review loops with ship recommendations.

Enforces PROJECT.md-first autonomous development with an 8-agent pipeline that auto-orchestrates research, planning, testing, implementation, review, security audit, and documentation sync. Validates every feature against project goals, detects code-doc drift, generates tests, and auto-updates docs on commit.

Hunt bugs in Python codebases by automatically analyzing code, proposing Hypothesis properties, generating and running pytest tests, and triaging failures.

Setup, optimize, and debug Python 3.12+ projects with expert validation and patterns, including type safety, async, web frameworks, testing, and AI/ML.

Generates tests across Jest, Vitest, Pytest, Cypress, and Playwright; optimizes prompts for AI models; researches external documentation and best practices; creates and updates CLAUDE.md files from staged git changes; and produces formatted documents (PDF, DOCX, HTML) from markdown.

Clone untrusted Python dependencies into your project, generate test suites to validate them, and decompose into minimal sub-packages to reduce supply chain risk.

Develop, test, debug, and maintain Keboola Python components with automated schema testing, VCR functional tests, code quality reviews, cookiecutter initialization, and migration to uv/pyproject.toml.

Develop production-ready Python backends with Django, FastAPI, and async patterns, supported by modern tooling for testing, observability, and package management.

A multi-skill catalog that equips Claude Code with agentic workflows for code review, git operations, documentation, knowledge capture, and cross-tool compatibility across Claude, Codex, and Gemini CLI agents.

Provides Python backend specialists for Django, FastAPI, FastMCP, and Celery development with code quality enforcement, security auditing, and parallelization readiness analysis

Generate unit tests with mocking and edge cases, debug test failures with root cause analysis, and build automated testing ecosystems with self-healing tests and CI/CD integration

Auto-configure code quality tools, generate custom /fix and /commit commands, and run parallel agent-based code reviews, testing setup, and dependency updates across projects.

Orchestrate a multi-agent QA pipeline for code changes: analyze diffs, validate acceptance criteria, generate test scenarios, run browser validation, create bug reports, and produce automation code in Playwright, Cypress, or pytest.

Automates the full code review lifecycle: task planning, implementation, multi-platform testing (web/backend/mobile), evidence collection, PR automation, and structured reports covering code quality, security, accessibility, and E2E integrity.

Semi-automated research assistant for academic and policy research, integrating literature review, paper analysis, Obsidian knowledge management, structured policy analysis (Bardach framework), grant writing, and publication drafting with Takshashila Institution standards.

Generate unit tests from source code with automatic detection of Jest, pytest, or JUnit frameworks, covering happy paths, edge cases, error handling, and mock dependencies.

Run Claude autonomously for 6-8 hours overnight using Git hooks that enforce test-driven development — wake up to fully tested features, refactored code, or fixed bugs with pre-commit test validation and coverage enforcement.

Generate UML diagrams from real code with a multi-stage audit pipeline that verifies business correctness, diagram-code consistency, and notation readability, backed by an adversarial diagram auditor. Also strengthens mutation test suites by writing outcome-asserting tests.

Automate the full feature development lifecycle: brainstorm, plan, implement, review, and iterate on code until quality gates pass, with ad-hoc workflow generation from natural language descriptions.

Orchestrates multi-agent code workflows with exploration, planning, implementation, review, and validation phases, plus PR/issue triage, memory management, and structured code review for GitHub projects.

Accelerate development workflows with code reviews, API design (REST/GraphQL), test generation (Jest/Pytest/Go), Draw.io architecture diagrams, and cost-optimized ML training on AWS SageMaker.

Analyze test coverage from Jest, Vitest, pytest, and Go projects, generate test fixtures and mock data, execute tests with auto-detected frameworks, and get prioritized recommendations for improving coverage gaps.

Enforce spec-driven development with structured specs, automated proof auditing, drift detection, and test-coverage verification across features.

Autonomous session management with file access policies, safety guards, and parallel debugging. Run sequential improvement workflows, create/refine development plans, manage tmux sessions, and control AI behavior across sessions with block/allow patterns.

Orchestrates a team of specialized builder and validator agents to implement Django projects from engineering plans, with automated task delegation and parallel execution through a queue system

Analyze and improve test quality across your development lifecycle: detect inverted test pyramids, identify untested critical code, audit suite health, diagnose flaky tests, and set up CI/CD testing pipelines with progressive stages.

Develop, test, and troubleshoot Temporal.io workflows across Python, Go, TypeScript, Java, .NET, and PHP SDKs with expert guidance on determinism, patterns, and production incidents.

Build, design, and troubleshoot Python CLI applications using Typer with type-hint driven development, command structures, validation, and testing

Orchestrate full multi-layer test suites — unit, integration, and E2E — by delegating to specialist agents that scan projects, generate tests with coverage targets, and validate across APIs, databases, and UI workflows.

Run browser-automation tests (Playwright, headless) for E2E flows, screenshots, responsive layout, accessibility audits, and local webapp debugging. Also profile performance and write unit/contract tests with Vitest.

Manage the complete feature lifecycle from idea capture to shipped delivery: capture feature ideas as markdown files, create implementation plans, execute phased workflows with quality gates, auto-generate status dashboards, and integrate with git branching and PR review cycles. Includes specialized agents for system design, API contracts, TDD test generation, security auditing, QA, UX optimization, and legacy code analysis.

Provides opinionated Django development patterns covering API endpoints, admin panels, testing, and project scaffolding, along with an automated code review agent that enforces conventions like UUID primary keys and 1-file-per-model organization.

Run 35+ research-derived code review lenses on diffs or PRs to catch correctness, security, performance, accessibility, and architecture issues, then merge findings into a ranked verdict.

End-to-end AI-native ASIC/FPGA design flow from natural-language spec to GDS tapeout, with analog/mixed-signal support, formal verification, FPGA prototyping, and anti-fabrication gates enforced across every phase.

Enforces Clean Architecture in Python/FastAPI projects with layered scaffolding, design rule scanning, code smell detection, and automated refactoring plans. Scaffolds endpoints, reviews REST APIs, generates stub-based tests, and teaches Pythonic patterns.

Orchestrate spec-driven development with quality gates — plan features, review code, generate tests, audit security, and prep releases via /spec and /attune workflows.

Enforce Definition of Done and quality gates across the PR lifecycle with automated code review, security vulnerability scanning, test coverage validation, and TDD-based bug resolution orchestrated by specialized agents.

Automate Python project tasks with Angreal: create and run CLI tasks, manage arguments, scaffold templates, integrate with Git/Docker/VirtualEnv, and write ToolDescriptions for AI agents.