OpenAPI plugins

Generate comprehensive documentation, code explanations, and tutorials from existing codebases, with automated doc generation via CI/CD and integrated AI-powered code review for quality and security.

Generate C4 architecture documentation (Context, Container, Component, Code) from a codebase using bottom-up analysis, producing Mermaid diagrams and structured docs in a dedicated directory.

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

Generate and maintain comprehensive documentation from any codebase: OpenAPI 3.1 specs, Mermaid diagrams, step-by-step tutorials, Architecture Decision Records, and automated changelogs. Supports CI/CD integration and includes agents for creating developer portals and technical references.

Design and implement secure backend APIs with authentication, authorization, rate limiting, input validation, and protection against common vulnerabilities using architectural guidance and hands-on coding assistance.

Orchestrate AI agents across the full software development lifecycle—from market research and product analysis through architecture, implementation, sprint management, code review, testing, and retrospectives.

Generate mock REST APIs with configurable latency and scenarios for development and testing, then produce OpenAPI 3.1 documentation and interactive developer portals from those APIs

Design, build, document, and secure production-ready REST, GraphQL, and WebSocket APIs with patterns for versioning, pagination, auth, error handling, load testing, and monitoring

Design, build, and document production-ready Python APIs with FastAPI and Django, including async patterns, OpenAPI spec generation, Pydantic models, and testing strategies.

Generate and maintain OpenAPI 3.1 specifications from code or design-first specs, enabling API documentation, SDK generation, and contract compliance validation.

Write, run, and refine promptfoo eval suites for LLM testing, including adversarial red team scans with configurable providers, plugins, and strategies. Automate CI gates and export reports.

Automate 90+ Korean daily-life and business tasks: book KTX/SRT trains, search Coupang/Daangn, check real estate prices, look up laws, track parcels, and more via public APIs and browser automation.

Scaffold, build, and deploy MCP servers using the mcp-use framework, including OpenAPI-to-MCP conversion with Zod schemas and cloud deployment.

Generate a complete, production-ready application from an OpenAPI specification, including models, controllers, services, tests, and configuration.

Automate browser interactions, extract data, and navigate websites using natural language commands via Stagehand. Build and debug automation skills, capture DevTools traces, scrape static pages, deploy serverless browser functions, and run adversarial UI tests.

Orchestrate authorized penetration tests and red team engagements with 50 specialist subagents covering recon, web/API, Active Directory, cloud, mobile, wireless, exploitation, post-exploitation, detection, forensics, and reporting.

Automate API endpoint testing for REST and GraphQL APIs with request generation, response validation, schema compliance, and coverage reporting for regression or new test suites.

Validate API contracts using consumer-driven contract testing with Pact, OpenAPI validation, and breaking change detection for microservice integrations

Ensure API contract compliance by validating responses against OpenAPI and JSON schemas, detecting schema drift, and verifying data integrity in middleware or tests.

Migrate APIs between versions or frameworks with automated compatibility layers, breaking change detection, and zero-downtime deployment using strangler fig, traffic shadowing, and phased cutovers.

Generate production-ready REST APIs from OpenAPI specs or schemas, with CRUD endpoints, pagination, filtering, authentication, validation, and test scaffolding for Express, FastAPI, Spring Boot, Gin, and NestJS.

Generate mock API servers from OpenAPI specs with realistic fake data, stateful CRUD, and configurable latency/errors for testing frontend applications.

Generate type-safe client SDKs from OpenAPI specs for TypeScript, Python, Go, and Java with built-in auth, retries, pagination, tests, and documentation.

Run fuzz tests against REST and GraphQL APIs using malformed inputs and edge cases to discover crashes, vulnerabilities, and input-validation gaps, then review a categorized security report.

Automate documentation workflows: generate OpenAPI specs and SDK developer docs, configure and deploy Docusaurus sites, and fix Markdown formatting errors for consistent technical writing.

Build, deploy, and operate AI agents on AWS using Amazon Bedrock AgentCore — scaffold projects, connect tools via Gateway and MCP, orchestrate multi-agent workflows, enforce Cedar policies, debug traces and logs, and harden for production with IAM, auth, rate limiting, and cold-start tuning.

Debug REST API failures by analyzing OpenAPI specs and HTTP request/response logs, identifying root causes by status code category, and generating reproducible cURL commands to reproduce and fix issues. Includes an MCP server for inspecting, testing, and analyzing API requests and responses.

Manage Windsurf IDE and Cascade AI agent configurations across the full development lifecycle — automate CI/CD pipelines, enforce code quality, generate tests, debug errors, secure dependencies, set team policies, and orchestrate multi-file refactoring.

Provides a comprehensive .NET development assistant with 47 skills, 10 agents, and MCP tools for building, testing, deploying, and securing .NET 10/C# 14 applications. Covers architecture guidance (Clean Architecture, DDD, Vertical Slices), API development, EF Core, caching, messaging, CI/CD pipelines, Docker containerization, code quality analysis, security scanning, and automated build fixing.

Design and document REST and GraphQL APIs: plan endpoints, generate OpenAPI specs, auto-create interactive docs from code annotations, and scaffold full GraphQL schemas with resolvers.

Access a complete financial data pipeline covering China A-share and US equity markets: pull structured financials and sentiment from RavenPack, collect US fundamentals via yfinance, install and orchestrate the Gangtise OpenAPI research suite, aggregate A-share news and policy, and generate daily pharma sector reports sent to Feishu.

Design and document RESTful and GraphQL APIs by generating OpenAPI 3.1 specifications from codebase analysis or domain models, with structured endpoint tables, request/response schemas, auth, and versioning.

Generate OpenAPI 3.1 specifications by scanning project API routes, then validate specs for structural correctness, reference integrity, completeness, and best practices with severity-based feedback and fix suggestions.

Generate TypeScript types, Zod schemas, Axios/fetch clients, React Query and Vue Query hooks, and Faker mocks from OpenAPI/Swagger specs using the Kubb CLI and a bundled MCP server for conversational code generation.

Test APIs with performance, load, contract, and security testing. Simulate traffic spikes, validate OpenAPI specs, and identify bottlenecks before deployment.

Run structured, multi-domain code reviews with blast radius analysis, architecture evaluation, security audits, and test coverage checks across Rust, Python, shell, and Makefiles.

Synchronize your OpenAPI specification (openapi.yml) with your REST API implementation by scanning code for endpoints, schemas, and middleware, then updating the spec to match. Ensures API documentation stays accurate as code evolves.

Design and implement internal API architecture for B2B applications, including REST and GraphQL API design, SDK development, developer portals, and API documentation with performance optimization and versioning strategies.

Test APIs for performance, load, contract, and security by simulating traffic spikes and validating OpenAPI specifications to identify bottlenecks before deployment.

Design and implement internal API architecture for B2B applications, including REST and GraphQL API design, SDK development, developer portals, documentation, performance optimization, and versioning strategies.

Run comprehensive API tests covering performance, load, contract, and security scenarios. Simulate traffic spikes, validate OpenAPI specifications, and identify bottlenecks before deployment.

Keep your OpenAPI specification in sync with your REST API implementation by automatically scanning endpoints, schemas, and middleware to update, validate, and fix discrepancies in openapi.yml.

Reverse engineer clean behavioral specifications from any codebase using multi-source intelligence analysis, including source code, binaries, documentation, community content, git history, SDKs, API contracts, and runtime observation. Produces structured specs with provenance tracking, citation enforcement, and contamination removal for implementation handoff.

Design and implement internal API architecture for B2B applications, covering REST and GraphQL API design, SDK development, developer portals, and documentation, with performance optimization and versioning strategies.

Orchestrate multi-agent development workflows with 39 specialists across code review, debugging, security audits, performance profiling, SEO checks, accessibility compliance, and documentation. Supports 4-phase orchestration, parallel subagents, persistent sessions, and standalone commands for specialized tasks.

Automatically synchronize your OpenAPI specification with your REST API implementation by scanning code for endpoints, schemas, and middleware, ensuring the spec always matches the actual API.

Manage the full lifecycle of UiPath automation projects from within Claude Code — build, deploy, and debug RPA workflows, agents, coded apps, integration connectors, and governance policies using CLI commands directly in the chat interface.

Orchestrates the full software development lifecycle with 58 specialized agents across inception, elaboration, construction, and transition phases. Manages architecture evolution, security reviews, regression testing, deployment automation, risk tracking, and multi-agent artifact generation with provenance tracking and citation validation.

Run deterministic merge gates that statically analyze AI agent tool definitions (MCP, OpenAPI, SDK decorators) to enforce tool-use readiness policies and audit host-grant permissions before merging agent capability changes.

Enforces a complete development standards workflow including conventional commits, code review checklists, TDD/BDD/ATDD test generation, specification-driven development, changelog and release management, CI/CD design, security scanning, and project health metrics — all language-agnostic.

Write, review, and debug Go services with patterns for API design, testing, concurrency, observability, and project structure. Covers gRPC, REST, CLI tools, dependency injection, database access, CI/CD, security audits, and performance optimization.

Build and maintain OpenAPI SDK generators for oagen: audit emitter IR coverage, scaffold new language emitters and extractors, generate smoke tests, verify backward compatibility, and iteratively fix emitters until tests pass.

Generate typed, packaged API client SDKs from OpenAPI specs and write declarative, type-safe API clients with unihttp, including DTOs, method definitions, and contract tests.

Manage the full API lifecycle from Claude Code: sync Postman collections, generate OpenAPI specs from codebases, run test suites, create mock servers, audit security against OWASP Top 10, and evaluate AI agent compatibility.

Design, validate, and evolve APIs with expertise in OpenAPI, GraphQL, and REST architecture, including contract testing, code generation, breaking change detection, and API gateway configuration for rate limiting, authentication, and routing.

Build and maintain Vovk.ts TypeScript RPC backends for Next.js — scaffold projects, define typed procedures with Zod/Valibot validation, configure decorator-based routing, generate OpenAPI specs, and auto-create type-safe clients for JavaScript, Python, and Rust. Includes CLI scaffolding, multi-tenant setup, streaming endpoints, LLM tool definitions, and npm/crates.io/PyPI publishing workflows.

Generate and maintain architecture documentation, ADRs, changelogs, system diagrams, onboarding guides, and stakeholder presentations from your codebase and conversations.

Build API test suites covering endpoint integration, contract verification, and load testing for REST, GraphQL, and gRPC APIs using Supertest, Pact, and k6.

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.

Carry a feature from idea to shipped via a gated pipeline: survey codebase, specify specs, design architecture, model data, derive API contracts, break into tasks, implement with TDD, review, and ship. Maintain a living roadmap and catch drift across artifacts.

Provides a disciplined workflow for Python application development: from requirements discovery and domain modeling through implementation, TDD, code review, and PR management. Comes with specialized skills for FastAPI, SQLAlchemy, Temporal, Python 3.10+ patterns, and monorepo configuration.

Manage and develop Salesforce B2C Commerce instances via CLI — deploy cartridge code, debug server-side scripts, manage users and roles, query analytics, handle sandboxes, configure eCDN, and automate site operations.

Develop and extend Salesforce B2C Commerce Cloud with custom cartridges, SCAPI/OCAPI endpoints, storefront controllers, ISML templates, hooks, jobs, and SLAS authentication for headless or SFRA-based storefronts.

Audit and generate API reference documentation by scanning implementations against OpenAPI specs, detecting missing parameters, undocumented errors, stale examples, and coverage gaps, then writing parameter tables, code examples, and structured docs.

Design and audit multi-language SDKs from OpenAPI and GraphQL specs, ensuring idiomatic quality and cross-language consistency across your API ecosystem.

Set up API quality gates in CI pipelines: generate linting, style enforcement, and breaking change detection configurations for REST, GraphQL, or gRPC APIs, then audit and enforce them before PRs merge.

Audit API changes for breaking changes, classify impact, recommend semver levels, and enforce deprecation policies with CI gates using OpenAPI specs

Design and review API schemas (OpenAPI, GraphQL, gRPC) for consistency, completeness, and developer ergonomics. Enforce naming conventions, versioning, and self-documenting contracts across your codebase.

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.

Guides a structured product development lifecycle: clarifies business ideas into BRDs, maps user journeys, writes and reviews PRDs, generates API contracts (OpenAPI, GraphQL, gRPC, WebSocket), designs HLD/LLD, creates interactive UI prototypes, develops test strategies and cases, and produces ops runbooks — with automated quality gates and reviews at each stage.

Generate Shiny Mediator handlers, contracts, and middleware for .NET applications with AOT/trimming support, source generators, and CQRS/event-driven patterns. Scaffold .NET projects, create OpenAPI clients, and migrate from MediatR.

Surveys API or SDK documentation coverage by analyzing OpenAPI specs to identify undocumented endpoints and quality gaps, helping prioritize documentation efforts.

Design API compatibility and deprecation policies with stability tiers, sunset timelines, and CI gate enforcement using openapi-diff to detect breaking changes and ensure policy compliance in CI/CD pipelines.

Generate CI quality gate configurations for APIs that enforce linting, breaking change detection, and schema coverage checks

Review OpenAPI, GraphQL, and Protobuf schemas for naming consistency, completeness, and developer ergonomics, with actionable fixes.

Audit API schema files (OpenAPI, GraphQL, Protobuf) across a codebase to detect coverage gaps, naming inconsistencies, and missing descriptions.

Generates API reference documentation from OpenAPI specs, function signatures, and response schemas, producing parameter tables, code examples, and structured docs for endpoints or SDK methods.

Audit an existing REST API for breaking change risks, missing compatibility controls, and undocumented stability tiers, then report deprecated fields past sunset and recommend CI gates

Design API schemas for new features — OpenAPI specs, GraphQL schemas, or gRPC protos — with clear, consistent contracts, examples, and rationale.

Generate an SDK architecture from OpenAPI or GraphQL specs, selecting language targets, idiomatic patterns, and code generation strategy.

Build privacy engineering workflows: PII detection/redaction, differential privacy, NIST Privacy Framework compliance, consent management, privacy-preserving data sharing, threat modeling, and privacy KPI dashboards

Automate comprehensive API quality assurance — run functional, performance, load, and contract tests on REST, GraphQL, and microservice endpoints, with integrated security checks and automated test framework generation.

Design and document REST APIs with expert guidance on resource modeling, HTTP methods, versioning strategies, pagination (cursor/offset), rate limiting, and OpenAPI/Swagger spec generation.

Generate API documentation, user guides, and architecture docs via docs-as-code workflows using OpenAPI, Markdown, and YAML. Delegate to @technical-writer for any documentation task.

Score OpenAPI specifications against the Jentic API AI Readiness Framework (JAIRF) and automatically improve them to raise the score, producing an enhanced spec and reusable OpenAPI Overlay. Supports non-breaking defaults, summary-description and full breaking-allowed modes, with oasdiff breaking-change detection.

Build, secure, and document API Platform resources with DTOs, filters, pagination, validation, serialization, GraphQL, real-time Mercure updates, OpenAPI docs, functional tests, and MCP-based AI agent access for Symfony and Laravel integrations.

Integrate multiple LLMs (OpenAI, Gemini, Ollama) into your development workflow for second opinions, code review delegation, image generation, side-by-side model comparisons, and data format conversion — all from the terminal.

Delegate development tasks—code review, API documentation, testing, performance optimization, LLM system design, and more—to specialized AI agents, coordinated by a Drucker-inspired team management skill.

Design RESTful APIs, GraphQL schemas, and microservice architectures with auto-generated documentation, validation, security, and testing

Generate API documentation from source code, producing OpenAPI 3.0 specs, interactive Swagger UI and ReDoc views, TypeScript type definitions, and Postman collections with authentication and example support

Enforces a specification-driven SDLC workflow: analyze codebases, author constitutions, generate requirements and user stories, design APIs and data models, plan tasks via vertical slicing, implement with strict TDD, and verify with human-in-the-loop checkpoints.

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.

Generate, manage, and QA Umbraco CMS backoffice extensions — from property editors and dashboards to workspaces, trees, and Tiptap rich-text customizations — with code scaffolding, OpenAPI client setup, and automated review.

Accelerates ABC development flow by managing Git branch workflows, triggering Jenkins deployments, querying Apifox API docs, analyzing SLS logs for Java backend issues, automating TAPD agile tasks, and capturing Modao prototypes as Markdown.

Apply Amazon's Working Backwards methodology and operational excellence practices to the full software lifecycle: product discovery, design, implementation, code review, deployment, incident response, and production operations.

Develop, test, and deploy cybersecurity applications on the CrowdStrike Falcon Foundry platform using OpenAPI specs, React/Vue UI, Go/Python serverless functions, OAuth security, and Playwright end-to-end testing, with support for SOAR workflows and CLI debugging.