OpenAPI plugins

Delegate specialized coding tasks to domain-expert subagents for building blockchain DApps and smart contracts, secure fintech payment systems with compliance, Unity-based games with multiplayer networking, scalable IoT edge solutions, native/cross-platform mobile apps, API documentation, quant trading models, and risk management frameworks.

Develop production-grade Go applications with AI-assisted skills covering project layout, concurrency, profiling, observability, testing, CI/CD, and idiomatic coding patterns across the full development lifecycle.

Generate 35 structured engineering documents — including incident postmortems, architecture decision records, code review checklists, PR descriptions, changelogs, runbooks, test strategies, threat models, SLO definitions, and migration plans — directly from rough notes, logs, or git history within Claude Code.

Design scalable backend architectures including REST/GraphQL/OpenAPI APIs, server-side logic, database schemas with indexing and Redis caching, OAuth authentication/security, and microservices.

Design REST API architectures with endpoint planning, Express.js routing, and validation; implement GraphQL servers using Apollo with schemas and playground; generate OpenAPI specs, request/response examples, and interactive docs from code analysis; set up hosting and CI/CD for API documentation.

Build, analyze, and ship .NET 10 applications with architecture guidance, code generation, automated cleanup, testing, security scanning, and deployment pipelines — all within Claude Code.

Architect scalable backend systems by designing REST/GraphQL APIs with OpenAPI specs, implementing server-side logic, creating database schemas with indexing and Redis caching, setting up secure OAuth authentication, and planning microservices.

Follow Spec Driven Development workflows to build features systematically: generate testable specs from descriptions, create dependency-ordered task plans, analyze artifacts for quality and consistency, execute phased TDD implementations with progress tracking, and convert tasks to GitHub issues.

Generate TypeScript types, Zod schemas, API clients (Axios/fetch), React/Vue Query hooks, and Faker mocks from any OpenAPI spec using the Kubb CLI or a conversational MCP server.

Architect scalable backend systems using a specialized AI agent: design REST/GraphQL/OpenAPI APIs with authentication and rate limiting, optimize database schemas via indexing and Redis caching, implement secure OAuth flows, build server-side logic, and structure microservices for robustness and performance.

Build, deploy, and operate AI agents on AWS with Amazon Bedrock AgentCore — scaffold projects, connect tools via Gateway, debug failures, deploy with rollbacks, enforce security, and evaluate agent quality.

Conduct comprehensive, multi-domain code reviews with automated blast radius analysis, architecture assessment, API surface evaluation, bug detection, test suite quality checks, and language-specific audits for Rust, shell, and math-heavy code. Orchestrate specialized reviews and enforce commit policies.

Architect scalable backend systems with an AI agent: design REST/GraphQL/OpenAPI APIs, database schemas with indexing and Redis caching, secure OAuth authentication, server-side logic, and microservices.

Enforces development standards across the entire lifecycle: structured commits, specification-driven development, BDD/TDD/ATDD workflows, code reviews, security audits, CI/CD setup, documentation generation, and project health assessments.

Automate and guide the full R&D workflow: interview vague ideas into BRDs/PRDs/use cases, generate/review prototypes/UI/API contracts/guardrails/HLDs/LLDs/test strategies/specs/runbooks, ensuring consistency via repo scans and iterative quality gates.

Build type-safe RPC APIs with Vovk.ts in Next.js by defining typed procedures, decorators, and segments; then generate typed clients for TypeScript, Python, and Rust, produce OpenAPI specs, and expose endpoints as LLM tool definitions.

Build, test, and maintain custom language SDKs generated from OpenAPI specs using the oagen framework — scafffold emitters and extractors, run compatibility checks, automate smoke tests, and fix regressions in a generate-verify loop.

Scaffolds .NET projects with Shiny Mediator patterns, generating handlers, contracts, middleware, CQRS, SSE, OpenAPI clients, and AOT-trimming code, plus migrating from MediatR.

Run comprehensive SEO workflows directly from Claude: keyword research, content briefs, technical audits, backlink analysis, competitive gap analysis, AI-search optimization, structured data generation, and SE Ranking API integration — all producing finished deliverables.

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

Manage the full API lifecycle from Claude Code: discover and explore Postman collections, send requests, run and debug test suites, sync specs with code, generate OpenAPI documentation, create mock servers, and audit security against OWASP Top 10.

Delivers a structured DDD-driven development workflow for Rust+React projects, automating backend finalization, test execution and repair, documentation generation (PRDs, design docs, tutorials), HTML previews, UI mockups, task planning, and acceptance validation through specialized sub-agents and commands.

Design contract-first APIs via OpenAPI 3.1, AsyncAPI 3.0, and Protocol Buffers from natural language requirements. Author formal specifications for systems, algorithms, and behaviors using TLA+, SysML, UML diagrams, state machines in Mermaid/PlantUML, and Use Case 2.0 templates for verification and modeling workflows.

Implement privacy engineering workflows to detect and redact PII in documents, apply NIST Privacy Framework functions for governance and risk management, deploy differential privacy mechanisms, conduct threat modeling, design privacy-preserving APIs and data sharing, manage consents, and track privacy metrics via dashboards.

Generate standardized technical documentation for architecture (arc42/C4 with Mermaid), decisions (ADRs/RFCs), operations (runbooks), onboarding, and API portals. Automate docs-as-code pipelines integrating Git workflows, CI/CD, linting, and deployment best practices.

Author, convert between, validate, refine, and audit specifications using EARS, Gherkin, Kiro, and user story formats. Generate ADRs, implementation plans, and run GitHub SpecKit's 5-phase workflow from constitution to implementation for spec-driven development.

Set up a structured, multi-agent development workflow with quality gates, board management, and session continuity across AI coding tools. Automate issue tracking, code review, testing, accessibility, security, and release processes through specialized agents and commands.

Architect comprehensive documentation systems and docs-as-code pipelines with OpenAPI/AsyncAPI support, while generating technical writing for API references, tutorials, CLI help, error messages, and UX microcopy using plain language and accessibility principles.

Generate enterprise-grade API documentation from OpenAPI/Swagger specs, user guides, architecture docs, and docs-as-code artifacts to streamline developer experience and documentation workflows.

Orchestrate multi-platform marketing campaigns from Claude using the Hyper MCP — manage paid ads on Google, Meta, TikTok, Pinterest, Amazon, LinkedIn, plus organic social, SEO research, email outreach, competitor analysis, ad creative generation, and analytics integrations.

Design, secure, and test REST/GraphQL APIs with API Platform, covering DTOs, filters, pagination, validation, serialization, error handling, OpenAPI customization, real-time Mercure updates, and MCP AI agent integration.

Plan, implement, review, and document the full software development lifecycle — from requirements and architecture to code changes, testing, and release — using a structured skill-based workflow that adapts to the task at hand.

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.

SDD implements a complete spec-driven development pipeline for Claude Code: survey a codebase or bootstrap greenfield, walk gated stages from idea capture → spec → architecture → data model → OpenAPI contract → task breakdown → TDD implementation → review → ship, while maintaining a living roadmap (Now/Next/Later). Every stage hard-refuses to proceed if the previous artifact is missing, and the depth of Q&A and ideation is tunable.

Automate the full product lifecycle from research through release-readiness with human-in-the-loop gates, cross-artifact traceability, contract-first OpenAPI/AsyncAPI specs, design system harvest, and automated Playwright E2E testing.

Automate Rootly incident management in Claude: create/triage/resolve incidents, manage alerts/workflows/services/on-call schedules, generate blameless postmortems with AI analysis, track action items, and check service health/status.

Scaffold production-ready projects from configurable templates (Cookiecutter, Copier, Maven Archetype, Harness) with automatic project detection and CI/CD integration. Also generate API clients from OpenAPI specs, database migrations from models, and test suites from code through a unified template interface.

Orchestrate multi-agent workflows with guardrails for systematic software engineering: design architectures, enforce quality via adversarial reviews, audit security/compliance, generate docs/diagrams/tests, track work across sessions, and accrue persistent knowledge in markdown artifacts.

Architect OpenAPI specifications with strategic analysis, documentation excellence, and integration optimization frameworks, then generate improvement roadmaps to align APIs with business goals.

Generate production-ready TypeScript manifests, Lit elements, C# controllers, and project setups to fully customize Umbraco CMS backoffice with sections, dashboards, property editors, actions, authentication, themes, validations, trees, collections, and health checks using official docs, plus QA code review and automated builds.

Generate Mermaid/ASCII diagrams from descriptions, explain code with narratives and breakdowns, coauthor READMEs/API/architecture docs/proposals/decision records, manage ADRs/RFCs with auto-numbering/indexing, audit doc freshness/staleness/inconsistencies, ensure Diataxis structure, and review quality.

Automate ABC development workflow: query Apifox OpenAPI docs for 5000+ medical APIs, execute custom git flows on Codeup repos, manage TAPD agile tickets/stories/bugs with SLS log tracing to localize Java issues, import Modao prototypes as Markdown docs, trigger and monitor Jenkins builds, and get Spring Boot backend guidance.

Implement the Machine Payments Protocol (MPP) for HTTP 402-based autonomous machine-to-machine payments, enabling AI agents to pay for API calls, data, and services. Includes middleware for Hono/Express/Next.js, Stripe/Tempo integrations, OpenAPI service discovery, and security patterns.

Register OpenAPI specs with the oapi CLI, execute requests against REST APIs, manage authentication profiles, explore endpoints, and interact with APIs directly from your terminal.

Implements Amazon's Working Backwards methodology and operational excellence culture for AI coding agents, enabling structured product discovery via PR/FAQs, production-grade code reviews, safe staged deployments with feature flags, blameless post-incident analysis, and automated quality gates across the full development lifecycle.

Orchestrate agent-driven software development workflows: convert PRDs to TRDs with task breakdowns, delegate implementation to specialist agents for frontend UIs, backend APIs, mobile apps, databases, and docs, enforce TDD, git branches, quality gates, and OpenAPI generation across diverse stacks.

Run 50+ OWASP security checks against codebases during development — detecting injection flaws, broken authentication, cryptographic misuse, prompt injection, SSRF, and supply-chain risks across web, API, and LLM applications — with automated fix generation and attack chain analysis

Reference Dutch government software development standards and guidelines: API design rules, data exchange formats (DCAT-AP, linked data), NL Design System frontend patterns, accessibility (WCAG), Kubernetes infrastructure practices, software architecture (NeRDS), open source licensing, authentication (DigiD, OAuth), and security compliance

Enforces API contract compliance across producer and consumer services by detecting breaking changes, validating calls against a registry, generating mock servers and contract tests, and versioning public API surfaces before shipping

Generate SDKs in TypeScript, Python, Go, Java, C#, PHP, Ruby, Kotlin from OpenAPI specs using Speakeasy CLI. Customize specs via overlays and AI suggestions, extract from frameworks like FastAPI or Rails, set up contract testing and mock servers, automate multi-repo GitHub sync, create Terraform providers, implement lifecycle hooks, and diagnose generation failures.

Transforms ARCHITECTURE.md into a full enterprise architecture documentation suite: generates compliance contracts (SRE, cloud, security, etc.), ADRs, development handoffs with OpenAPI/DDL/K8s artifacts, Word exports, IcePanel C4 sync, and traceability reports. Validates architecture against 10 risk lenses, enterprise alignment (BIAN v14), and 10 compliance standards with interactive HTML review playgrounds.

Manage a DataSpoke deployment via its public API: configure and verify API access, inspect ingestion sources and trigger extractor runs, manage validation slots and author validation routines for data pipelines, and explore OpenAPI governance and ontology endpoints.

Coordinate a team of AI agents that enforce structured workflows with mandatory gates—API contracts before coding, root-cause analysis before fixes, TDD, and pre-merge checks—to ensure quality and consistency.

Score and lint OpenAPI documents against the Jentic API AI Readiness Framework (JAIRF) using the @jentic/api-scorecard-cli. Supports local files or URLs, generates JSON/HTML scorecards, and integrates with CI for automated API quality assessment.

Review software specifications from Google Docs, GitHub issues, pasted text, or files to detect gaps, inconsistencies, contradictions, risks, and scope feasibility. Specialized subagents audit API contracts, data models, UX flows, infrastructure, testability, business logic, and AI readiness, delivering structured JSON checklists, issue tickets, test plans, risk matrices, and task breakdowns.

Enforces disciplined TDD (Red-Green-Refactor) cycles with language-agnostic code quality reviews, architecture guidance, and automated agent teams that decompose features, write tests, and refactor code.

Load TAK Server's complete API reference—including OpenAPI 3.1 REST endpoints, WebCOP WebSocket/STOMP, missions and data sync CRUD, federation, certificates, CoT schemas—into conversation context. Reference these APIs via skills to build TAK/ATAK server integrations for situational awareness.

Audit code, APIs, and tests for quality issues across dimensions — type safety, error handling, test robustness, API compliance, and accessibility — using specialized agents that review diffs, verify OpenAPI specs, mutate tests, and enforce coding standards.

Implement the Agentic Commerce Protocol (ACP) for AI-agent-mediated commerce, including checkout sessions, delegated payments with Stripe SharedPaymentTokens, product feeds, order lifecycle management, fulfillment options, discount extensions, affiliate attribution, and merchant server scaffolding in Python, TypeScript, or Go.

Generate, analyze, and debug Robot Framework tests with AI assistance for web (Selenium, Playwright), API (Requests, RESTinstance), and mobile (Appium) automation. Provides keyword explanations, test architecture design, migration support, and result analysis from output.xml.

Run a multi-agent software delivery pipeline: plan, implement, review, and verify code changes with specialized agents for code review, testing, security, performance, and acceptance, all coordinated through phased gates and evidence-based decisions.

Extend REDAXO addons by adding custom REST routes via FriendsOfRedaxo/api with Bearer-token auth and scope management to expose your data over the shared API, while calling its endpoints for articles, categories, slices, modules, templates, languages, media, and users using OpenAPI specs and handling auth, errors, and quirks like trailing slashes and cache invalidation.

Orchestrate multi-agent development workflows with constructor-pattern primitives: scaffold APIs, docs, CI/CD, and auth; run parallel code audits, debugging, and quality gates; generate animations, images, and social content; manage cross-session messaging and cloud consolidation.

Generate TypeScript types, client code, and CLI commands from any OpenAPI spec, then chain those commands into reusable YAML routines with variables, loops, conditions, and assertions for multi-step API automation.

Orchestrate a spec-to-ship pipeline across 58 skills — scaffold projects, generate backend/frontend code with OpenAPI contracts, run TDD cycles, audit quality/security, and deploy via CI/CD. Includes multi-agent collaboration for PM, dev, QA, and DevOps roles with human approval gates and continuous learning via LEARN.md.

Orchestrate 10 agents to transform OpenAPI/GraphQL specs into production-ready TypeScript API clients with type-safe methods, Zod schemas, OAuth/JWT auth flows, rate limiting strategies, retry/error handling, mock servers, interactive explorers, and complete test suites using Vitest/Jest/Playwright.

Generate k6 load test scripts from OpenAPI specs, API codebases like Express/NestJS/FastAPI/Django, HTTP/gRPC/WebSocket endpoints; design smoke/stress/spike scenarios with executors/thresholds; analyze metrics like p95/p99 response times/errors; configure CI/CD pipelines, Kubernetes distributed execution, and fault injection for resilient performance validation.

Automate documentation creation and updates with AI agents: generate OpenAPI specs and Markdown API docs from code endpoints, changelogs from git history and PRs, READMEs with badges and examples, plus integration guides and tutorials.