Go plugins

Turn Claude Code into a multi-agent engineering platform with 542 skills, 184 commands, and 134 agents for end-to-end feature development, code review, build fixing, testing, security auditing, and deployment across 40+ languages and frameworks.

Automatically generate C4 architecture diagrams (Context, Container, Component, Code) from your codebase via bottom-up analysis, producing Mermaid diagrams and documentation for system design, API interfaces, and deployment units.

Accelerate full-stack development with 66 specialized skills covering 12 languages, frontend/backend frameworks, infrastructure, DevOps, security, and testing, plus Jira/Confluence project management commands for epic planning, discovery, and retrospectives.

Automate technical debt reduction, dependency updates, and code refactoring by scanning for vulnerabilities and code smells, generating prioritized remediation plans, and leveraging AI-powered test automation and code review.

Scaffold, write, and optimize systems-level code in Rust, Go, C, and C++ with agents and skills for memory safety, concurrency (goroutines, Tokio async), and production project setup

Enforce strict red-green-refactor TDD cycles: generate failing tests, implement minimal passing code, then refactor while keeping tests green. Includes AI-powered code review for security and quality.

Delegate architecture, implementation, optimization, and debugging of complex applications to specialized AI agents expert in Python/Django/FastAPI, TypeScript/React/Next.js/Angular/Vue, Go, Rust, Java/Spring Boot, PHP/Laravel/Symfony, C#/.NET, mobile (Flutter/React Native/Swift/Kotlin), Elixir/Rails, SQL, and DevOps tools.

Write systems-level code in C++, Go, and Rust with idiomatic patterns, concurrency, memory safety, and performance profiling for production-ready services, CLIs, and libraries.

Run CodeQL and Semgrep to scan multi-language codebases (Python, JavaScript/TS, Go, Java, C#, Ruby, Rust) for security vulnerabilities via taint tracking and pattern matching. Parse, deduplicate, and aggregate SARIF outputs from scans, then integrate findings into CI/CD pipelines using GitHub Actions or bash scripts.

Enables Claude to write, review, and debug production-ready Go code across the full stack: from project scaffolding and idiomatic design through concurrency, testing, benchmarking, database access, GraphQL/gRPC APIs, observability, CI/CD, security auditing, and dependency management.

Audit smart contracts for vulnerabilities across Cosmos, Solana, Polkadot, TON, Algorand, and StarkNet blockchains using specialized scanners. Assess codebase maturity with scorecards, prepare for professional audits via static analysis and test improvements, analyze token integrations for ERC standards and risks, and apply Trail of Bits guidelines for architecture reviews and secure workflows.

Develop and troubleshoot Ginkgo/Gomega test suites in Go, enabling spec authoring, table-driven tests, filtering, parallel execution, flake handling, async timeouts, CI setup, and JSON-based failure diagnosis.

Run a complete AI-assisted coding workflow with self-correcting memory, persistent FTS5-indexed research wikis, auto-research loops, multi-LLM council deliberation, and 8 specialized agents that coordinate parallel sessions, enforce quality gates, audit context costs, and capture learnings across every session.

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.

Build multi-language code graphs to map call graphs, attack surfaces, blast radius, taint propagation, privilege boundaries, and complexity hotspots for security audits. Visualize architecture with Mermaid diagrams, compare snapshots across git commits for evolution analysis, triage mutation testing survivors, generate crypto test vectors, diagram protocols, and project SARIF findings onto graphs.

Generate production-grade Go CLIs from OpenAPI specs or API descriptions, then publish them to a shared library using an AI-assisted pipeline that reviews output for bugs, regenerates after upgrades, and proposes systemic improvements.

Generate interactive, deployment-ready API documentation from OpenAPI specs, existing codebases, or live endpoints. Produce runnable examples in curl/JS/Python/Go, authentication guides, error references, and versioning support for quick sharing on Vercel or Netlify.

Configure and optimize mewt/muton mutation testing campaigns by scoping targets, tuning timeouts, and streamlining long-running tests for Rust, Go, TypeScript, and JavaScript codebases.

Annotate codebases with dimensional analysis comments documenting units, dimensions, and decimal scaling. Automatically scan for arithmetic patterns, discover project-specific units, propagate annotations through expressions and functions, and validate consistency to detect mismatches and bugs in DeFi protocols or numerical code.

Generate production-ready Google Cloud code examples, starter kits, and templates for AI agents and apps from official ADK, Genkit, and Vertex AI sources. Adapt to Python, TypeScript, or Go with security, monitoring, Firebase, and Terraform IaC integration.

Audit dependencies across Node.js, Python, PHP, Ruby, Go, and Rust projects for vulnerabilities, outdated versions, transitive issues, and license compliance. Generate detailed reports with CVE information, upgrade recommendations, and fix commands using tools like npm audit and pip-audit.

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.

Generate production-ready gRPC services from Protocol Buffers, creating proto definitions, server and client code in Go, Python, or Node.js, plus streaming RPCs, interceptors, TLS configs, health checks, tests, and REST gateways.

Scan cryptographic code for timing side-channel vulnerabilities like secret-dependent branches and divisions across Go, Rust, Java, Kotlin, C#, PHP, JS/TS, Python, and Ruby. Run constant-time analysis via skills or commands to get violation reports in JSON, with filters for warnings, architecture, and functions.

Automate the entire PRP workflow — plan, implement, debug, review, commit, and create PRs — using specialized agents that investigate issues, generate implementation plans, run validation loops, and execute multi-aspect code reviews.

Engineer production-ready ADK agents and multi-agent systems in Python, Java, or Go, generating clean code structures, unit tests, safe tools, and deployment automation for Vertex AI.

Build, initialize, architect, implement, debug, and deploy production-ready Firebase Genkit AI workflows with RAG, multi-step flows, tool calling, Gemini/Vertex AI integration, and OpenTelemetry monitoring in Node.js/TypeScript, Python, or Go to Firebase Functions or Cloud Run.

Scan codebases for SQL injection vulnerabilities by tracing user inputs through code to database queries, identifying unsafe patterns like string concatenation and unparameterized ORM usage in Django, Rails, Express, and Go apps. Get risk reports and mitigation recommendations via skills or direct commands.

Build production-ready API gateways for microservices, implementing intelligent routing, authentication, rate limiting, load balancing, circuit breakers, health checks, and response transformations. Deploy to Kong, Express Gateway, AWS API Gateway, or custom Node.js/Go/Express servers to proxy and manage backend traffic securely.

Generate and implement standardized API error handling with RFC 7807 responses, typed error classes, middleware, logging, monitoring, and recovery strategies for consistent HTTP status codes across Express, FastAPI, Flask, Node.js, Python, Java, and Go backends.

Delegate coding tasks to expert AI agents specialized in Python, Go, Rust, Java, JavaScript, PHP, Ruby/Rails, C/C++, SQL, and TypeScript. They proactively write idiomatic code, refactor for performance, implement advanced features like concurrency and generics, add tests with pytest or RSpec, optimize queries/schemas, and handle builds like Cargo.toml or CMake.

Generate .devcontainer configurations for Python, Node, Rust, and Go projects with integrated Claude Code plugins, language tooling like uv/fnm, and persistent volumes to create isolated, reproducible development environments.

Generate production-ready WebSocket servers for real-time bidirectional communication using Node.js with Socket.IO or native ws, Python/FastAPI, or Go. Scaffold includes authentication middleware, event handlers, rooms, broadcasting, heartbeats, presence tracking, client SDKs, configuration, tests, and Redis scaling for high-traffic apps.

Generate production-ready, type-safe client SDKs in TypeScript, JavaScript, Python, Go, and Java from OpenAPI specs, automatically including authentication, retries, pagination, tests, usage docs, and examples for rapid API client development.

Run mutation testing on JavaScript, Python, Java, Go, C#, or Ruby codebases to evaluate test suite quality. Introduce code mutants with tools like Stryker, mutmut, PITest, or go-mutesting, check detection rates, identify coverage gaps, and generate reports with survival scores and improvement suggestions.

Orchestrate multi-agent AI workflows in Claude Code: track work via convoys and beads, deploy polecat/crew agents, merge via refinery, install/monitor with gt/bd CLI for AI-powered software factories.

Generate production-ready REST APIs from OpenAPI specs or schemas, creating full CRUD endpoints with pagination, filtering, auth, routes, controllers, models, middleware, services, tests, and docs for Express, FastAPI, Spring Boot, and Gin.

Run integration test suites for APIs, databases, services, queues, and files using real Dockerized dependencies without mocks. Automates full workflow: environment setup, database seeding, service orchestration, test execution with coverage reporting, and teardown cleanup. Select suites and configure environments via CLI flags.

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.

Enforces Test-Driven Development by detecting your test framework (Vitest, Jest, Storybook, pytest, Go), installing the matching reporter, and blocking direct file edits to redirect reads through a custom pipeline that runs on session start and each user prompt.

Write expressive, correct Gomega assertions in Go tests using Expect/Ω notation, synchronous and asynchronous (Eventually/Consistently) patterns, the full built-in matcher catalog, composite matchers for nested structs, custom matcher authoring, and sub-libraries for HTTP, streaming I/O, goroutine leak detection, and performance measurement.

Parse, sign, and validate JWTs using the lestrrat-go/jwx v4 library in Go, with support for JWS, JWE, and JWK, algorithm selection, and common security pitfalls avoided.

Manage and monitor Datadog resources (monitors, logs, APM traces, dashboards, security signals, SLOs) via CLI commands and specialized agents, enabling observability workflows for infrastructure, applications, and CI/CD pipelines.

Automates the full software development lifecycle within Claude Code: orchestrating multi-agent code reviews, debugging, refactoring, security auditing, testing, and documentation generation with tool-assisted workflows for git, linting, builds, and architecture design.

Enforce cross-language coding standards and automate development workflows—code review, commit message generation, project scaffolding, optimization scans, and documentation—by configuring Claude Code and other AI assistants with contextual rules, skills, and commands for Java, Go, Python, TypeScript, Vue, React, Docker, and Redis.

Delegate specialized AI agents to build secure Solidity smart contracts, DeFi protocols, and full Web3 apps including tests, gas optimization, audits, and frontend integration. Develop production Hyperledger Fabric v2.5/v3 enterprise blockchains with Go/Java/TypeScript chaincode, network architecture, Kubernetes deployments, Raft/SmartBFT consensus, channels, MSPs, and privacy features.

Transform requirements documents, CSV/JSON schemas, SQL DDL, protobuf, or OpenAPI specs into production-ready codebases with types, CRUD APIs, and parsers for TypeScript/Express, Python/FastAPI, or Go.

Develop Terraform providers in Go with Plugin Framework: scaffold projects, implement resources/data sources/actions with CRUD and lifecycle hooks, run acceptance tests via patterns and TF_ACC, generate/validate Registry docs using tfplugindocs.

Equips Claude Code with 61 marketing and GTM skills for founders: research competitors, generate launch assets, audit pricing/pages, draft outreach sequences, analyze app store reviews, and automate content creation across blogs, social, email, and video.

Automatically generate a README.md by analyzing your project's files: detect languages/frameworks like JavaScript/Python/Rust/Go, extract metadata/installation/usage info, and add badges plus table of contents.

Audit local repositories for code health by analyzing complexity metrics, git churn, and test coverage gaps. Generate detailed reports with overviews, critical issues, warnings, prioritized refactor recommendations, and actionable steps to address technical debt hotspots.

Automate code analysis, test setup, and quality enhancement across JavaScript, TypeScript, Python, Java, Go, Rust, and Ruby by running slash commands that generate unit/integration/E2E/mutation/property/load/visual tests, fix linting/formatting issues, analyze coverage/performance/security, reproduce bugs with failing tests, optimize code, and integrate CI/CD workflows.

Extends Claude Code with a modular framework of agents, commands, and skills to automate test-driven development, code review, security scanning, dependency management, documentation sync, git workflows, and build fixing across multiple languages.

Design MongoDB schemas with best patterns and anti-patterns, generate and optimize queries from natural language using schema and indexes, tune client connections across Node.js Python Java Go drivers, implement Atlas full-text vector hybrid search for RAG, provision stream processing pipelines with Kafka S3 Lambda, and configure MCP servers via Docker or Atlas API.

Bootstrap Stripe projects with CLI, implement official best practices for payments via Checkout Sessions or PaymentIntents, Billing subscriptions, Connect Accounts, Treasury, Payment Element, and upgrade APIs/SDKs across Python, Ruby, Node.js, Java, Go, .NET.

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.

Profile codebases in JavaScript, Python, and Go to uncover performance bottlenecks, resource leaks, scalability issues, and anti-patterns in databases, memory, async code, frontend, and networks with quantified impact reports. Then automatically optimize hotspots by applying caching, batching, algorithmic improvements, and async patterns to files, functions, or modules.

Design RESTful or GraphQL APIs from domain models and requirements, generate OpenAPI 3.1 specs by scanning codebases in Express, FastAPI, Flask, Go, or Java, and consult an expert for endpoint reviews, schemas, auth, versioning, pagination, and optimizations.

Orchestrate AI coding agents through a structured RPI (Research-Plan-Implement-Validate) lifecycle with persistent knowledge flywheel, git-backed task graphs, multi-agent coordination, and automated validation gates for quality, security, and drift detection.

Automatically refactor individual files, directories, semantic queries, recent git changes, or entire project codebases using AI agents that simplify logic, remove dead code, apply language/framework best practices for TypeScript/React/Next.js/Python/Go/Swift, standardize styles, reduce duplication, and output structured summaries with git rollback instructions.

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.

Use gcx CLI to debug Grafana observability stacks: investigate alerts, SLO breaches, synthetic check failures via Prometheus metrics and Loki logs; manage dashboards, SLOs, resources with GitOps; scaffold Go projects; automate setups and code generation for resources-as-code.

Automatically modernize Go code by applying syntax guidelines and features like slices, maps, cmp.Compare, min/max based on the project's Go version from go.mod, replacing outdated patterns with idiomatic alternatives.

Build cross-platform desktop and mobile applications with Tauri, covering core, system, network, mobile, data, UI, and security skills across 52 capabilities.

Automatically add inline documentation—JSDoc, docstrings, comments—to under-documented functions, methods, complex logic, parameters, returns, and modules in TypeScript, JavaScript, Python, Go, and Rust. Generate structured explanations of code files, functions, or concepts, covering purpose, step-by-step logic, key concepts, gotchas, and dependencies.

Generate API reference docs by scanning source code for routes, types, params, schemas, responses, and auth; produce Markdown project docs with module overviews, function details, examples, and configs; automatically update README.md to reflect current project state including installation, usage, badges, and verified examples with diffs.

Scan direct and transitive dependencies across Node, Python, Java, Rust, Go package managers for license compliance, classify licenses, flag issues with counts and statuses in reports, and generate NOTICE files attributing third-party licenses with full texts, copyrights, and project notices.

Generate Markdown API reference docs from source code and routes, extracting endpoints, methods, parameters, schemas, auth, errors, and examples for Express, FastAPI, Django, Java, and Go backends.

Interactively configure secure AWS S3 buckets with encryption, versioning, lifecycle rules, and logging, then generate CloudFormation or CDK IaC plus documentation. Set up complete Lambda functions with handler code in Node/Python/Go, IAM roles, DynamoDB triggers, and IaC via CloudFormation/SAM/CDK.

Generate optimized, explained regex patterns from natural language descriptions supporting JavaScript, Python, Go, Java, and PCRE flavors. Test patterns against sample inputs, edge cases, adversarial strings, and non-matches with match reports, group captures, performance metrics, accuracy scores (TP/TN/FP/FN), and targeted improvement suggestions.

Scaffold production-ready API, web, CLI, library, or fullstack projects in TypeScript, Python, Go, or Rust, complete with source/tests, Docker, GitHub Actions CI/CD, git init, and deps. Add feature modules like CRUD resources, services, middleware, CLI commands, or UI components, generating files/tests, wiring routes/middleware, and updating docs.

Run one command to automatically sort, group, deduplicate, remove unused imports, and clean import statements across all files in your JavaScript, TypeScript, Python, or Go project, following linting rules and conventions for consistent code style.

Detect memory leaks and profile heap usage in Node.js, Python, Java, Go, and browser apps by capturing snapshots, measuring growth rates with GC, tracing references, identifying consumers, suggesting fixes, and verifying resolutions.

Trade Taiwan financial markets (TWSE/TPEX/TAIFEX) programmatically using Shioaji's Python binding, CLI tool, or HTTP API with SSE streaming. Supports orders, real-time quotes, account data, and multi-language HTTP clients in JS/TS, Go, C/C++, C#, Rust, Java/Kotlin.

Capture terminal sessions as VHS animated GIFs and browser interactions as Playwright videos, convert to optimized GIFs via FFmpeg, then compose into stacked, gridded, or picture-in-picture tutorial demos from manifests.

Automate Git-powered coding workflows: generate atomic conventional commits from changes, push to feature branches and create/update PRs, clean merged/stale branches, fetch organized PR comments, generate/update READMEs and changelogs, maintain CLAUDE.md docs, and set up GitHub Actions for Claude Code—all with AI agents for audits.

Interactively debug source code in Python, Go, Node.js, Rust, and JavaScript by setting breakpoints, stepping line-by-line through execution, inspecting live variables, evaluating expressions, navigating the call stack, and tracing root causes like crashes, exceptions, or incorrect outputs.

Enforces secure coding and prevents common vulnerabilities by guiding AI agents during development, plus migrates memory-unsafe code to Rust/Go/Java/C#/Swift with rewrite workflows, and performs full security code reviews with prioritized OWASP-based reports.

Query a searchable knowledge base of 152+ curated best practices across 30+ languages and frameworks to retrieve instant recommendations on code style, security, and performance from sources like Google, Airbnb, and OWASP. Run Python scripts for targeted advice tailored to your codebase.

Orchestrates structured development workflows from idea to PR merge: clarifies ideas, brainstorms and documents designs, creates git branches/worktrees, plans and executes tasks via subagents with TDD, systematic debugging, automated code reviews, verifications, and git integration.

Scan Go REST API code in internal/api to automatically synchronize openapi.yml: add new endpoints, update schemas from DTOs/struct tags, parameters, responses, and fix documentation discrepancies for complete spec coverage.

Build and manage Grafana app platform plugins end-to-end: scaffold CUE kind definitions with code generation, implement reconcilers and admission webhooks in Go, send OpenTelemetry telemetry to Grafana Cloud, and create dashboard UIs with @grafana/scenes. Includes cost optimization, SLO management, and AI-assisted observability workflows.

Build data processing pipelines, operator graphs, ABAP/S4HANA integrations, replication flows, and ML scenarios in SAP HANA Cloud Data Intelligence. Assemble workflows using Gen1/Gen2 operators and subengines in Python, Node.js, or C++, with JupyterLab for ML and Data Transformation Language functions.

Enforce Project CodeGuard security rules in AI coding workflows to detect and prevent vulnerabilities during code writing, review, and modification across languages like Go, C, and Docker.

Helps Qdrant users optimize and manage vector search deployments through tuning performance, diagnosing search quality, scaling clusters, deploying infrastructure, upgrading versions, and using client SDKs.

Perform AI-native security audits on repositories: scan source code for SAST vulnerabilities like SQLi and XSS, dependencies for CVEs via SCA, leaked secrets and API keys; validate findings by tracing data flows, testing exploits, and analyzing controls; proxy HTTP/HTTPS traffic for inspection; aggregate prioritized reports with remediation guidance.

Integrate Sentry error monitoring and debugging into your development workflow. Set up SDKs across multiple platforms, analyze and fix production issues using stack traces and breadcrumbs, review PRs for Sentry-detected bugs, configure alerts, and migrate between SDK versions—all from within Claude Code.

Create and run multi-agent orchestration workflows from natural language descriptions, with parallel execution, conditional flows, checkpoints, visual progress tracking, and error recovery — all managed through a Socratic designer and interactive CLI.

Connect to MongoDB databases, explore schemas, generate queries and aggregation pipelines from natural language, analyze query performance with index recommendations, implement Atlas Search and Vector Search, and manage stream processing workflows — all from within Claude.

Navigate Go codebases with AST-aware call graphs and blast radius analysis, replacing grep for symbol search, refactoring, and bug hunting

Apply idiomatic Go best practices across your codebase — from code review and style enforcement to concurrency patterns, testing, error handling, and performance — with progressive disclosure and automated validation.

Convert broad project goals into structured, validated PRDs and dependency-ordered task graphs with automated discovery, spec generation, planning, and CDD-verified execution. Supports interactive and autonomous modes, multi-agent fleet execution, and zero-config setup for Claude Code.

Enforce architectural rules, clean code, DDD, security, and test quality across the software delivery lifecycle using composable AI skills that guide design, code generation, review, and documentation workflows.

Scan Go REST API code in internal/api to automatically synchronize openapi.yml: add new endpoints, update schemas from DTOs and struct tags, parameters, responses, and docs. Fix discrepancies and validate spec against implementation.

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.

Prevent codebase knowledge atrophy with adaptive challenges, spaced repetition, and an auto-built knowledge graph from AST parsing. Onboard new developers through structured stages with progress tracking and mastery checks. Capture tribal knowledge via annotations tied to specific code paths.