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 artifacts — postmortems, runbooks, ADRs, PR descriptions, changelogs, SLO docs, threat models, test strategies, database plans, and onboarding guides — from rough notes, logs, or specs, following established SRE and software engineering conventions.

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.

Guides full .NET 10/C# 14 development lifecycle in Claude Code — architecture selection, code quality enforcement, testing with xUnit/Testcontainers, Docker deployment, API design, security scanning, and automated cleanup. Includes agents for PR review, build fixing, and optimization.

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.

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.

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.

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.

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.

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.

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.

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

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.

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

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.

Manage full API lifecycle within Claude Code using Postman: discover APIs, sync collections, generate OpenAPI specs, run tests, create mocks, audit security, and publish docs.

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.

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.

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.

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

Drive a feature from idea to shipped code through a gated backbone of spec, design, data model, API, tasks, tests, implementation, review, and release, with each stage reading previous artifacts and enforcing completeness. Includes a TDD engine, living roadmap, Q&A with depth control, and surface-aware design for multi-platform apps.

Run end-to-end marketing campaigns across Google, Meta, TikTok, Pinterest, Amazon, and LinkedIn — from ad creation and SEO research to competitor intel, email outreach, and analytics — all through chat with the Hyper MCP.

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.

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.

Generate complete project scaffolds and Harness CI/CD pipelines from templates using Handlebars, Cookiecutter, Copier, or Maven archetypes. Convert existing projects into reusable archetypes, create type-safe API clients and data models, design database schemas with migrations, and manage the full deployment lifecycle—all through Claude Code.

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.

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.

Add HTTP 402 machine-to-machine payments to your APIs with per-request, streaming, and micropayment support. Integrates with Stripe, Tempo, and popular frameworks (Hono, Express, Next.js, Elysia) and provides OpenAPI service discovery for autonomous agents.

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.

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

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.

Automate end-to-end SEO workflows by using data from SE Ranking and Google APIs to generate keyword research reports, content briefs, technical audits, competitive analysis, and strategic roadmaps — all ready for execution in Claude Code.

Generate, analyze, and migrate Robot Framework tests for Playwright, Selenium, Appium, and REST API libraries, with keyword search, results analysis, and code quality hooks.

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.

Enforce structured development workflows with specialist agents that gate coding behind written contracts, specs, tests, and reviews, automate incident response, performance audits, and coordinate parallel tasks across domains.

Orchestrates the full AI-assisted SDLC workflow: from raw requirement clarification, spec generation, and design decisions through implementation planning, parallel task execution, verification testing, and code review — all within structured Git branches and Markdown SSOT documents.

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.

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 APIs against OpenAPI specs, review code quality across diffs and types, enforce frontend SDK boundaries, generate diagrams and documentation, manage Jira tickets, and test keyboard accessibility and layout stability.

Implement the Agentic Commerce Protocol (ACP) — the open standard by OpenAI and Stripe — enabling AI agents to mediate commerce workflows including checkout sessions, delegated payments, product feeds, order lifecycle management, fulfillment, discounts, affiliate attribution, and merchant server scaffolding across Python, TypeScript, and Go backends.

Run a multi-agent software delivery pipeline: plan, implement, review, test, and verify code changes with specialized agents for architecture, security, performance, reliability, and acceptance review.

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 workflow: generate PRDs, API contracts, backend/frontend code, tests, and CI/CD from requirements, then audit quality, security, and design consistency — all within a multi-role AI pipeline with human approval gates.

Develop .NET applications across the full stack — from C# backend APIs and UI frameworks (Blazor, MAUI) to AI/ML integration, cloud deployment, testing, debugging, security review, and DevOps automation

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.