Go plugins

Transforms Claude Code into a full-featured development platform with 270+ language-specific skills, 90+ CLI commands, and 67 specialized agents covering code generation, review, testing, debugging, deployment, security, and automation across 40+ technology stacks.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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 an entire PRP workflow loop — plan, implement, debug, review, commit, and PR — using specialized agents that execute plans, investigate issues, run multi-aspect code reviews, and enforce a review gate on session stop.

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.

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, 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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Enforces Test-Driven Development by detecting the test framework, installing a reporter, and outputting test results. Blocks file writes with forbidden terms and enforces semantic rules via bash guards and LLM prompt checks.

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.

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.

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.

Debug production issues by instrumenting projects with Traceway and using the CLI to query logs, exceptions, metrics, and traces to root cause. Supports backends via OpenTelemetry and frontends/mobile via Traceway SDKs.

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.

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.

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.

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.

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.

Orchestrate Claude Code workflows with agent teams, custom skills, and event-driven hooks — automate build/test cycles, security reviews, code generation, git operations, and project planning from within Claude Code.

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.

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.

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.

Run structured AI coding sessions with permanent progress gates, knowledge extraction, multi-agent orchestration, and automated validation loops that compound learnings across sessions.

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.

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.

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.

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.

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.

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.

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.

Generate customized CLAUDE.md configs for Claude AI assistants by auto-detecting Node, Python, Rust, Go, Java, Docker environments and package managers, incorporating git user info, TDD methodologies, memory rules, and local best-practices references with multi-file sync.

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.

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.

Drive spec-driven development from research through autonomous task-by-task implementation, with multi-spec epic decomposition, progress tracking, and failure reproduction/verification loops.

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.

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 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.

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.

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.

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.

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

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.

Turn project goals into validated PRDs and dependency-ordered task graphs, then execute tasks with CDD verification—automating the full pipeline from discovery through implementation.

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.

Build custom apps on the Grafana App Platform using the grafana-app-sdk: define CUE kind schemas, implement reconcilers and admission webhooks in Go, scaffold project structure, and deploy standalone operators or frontend-only apps.

Learn and retain codebase knowledge through adaptive challenges, spaced repetition, and structured onboarding. Extracts AST-based knowledge graphs, captures tribal knowledge as annotations, and runs multi-question gauntlet sessions to test understanding.

Set up oscal-cli and manage OSCAL compliance documents: validate JSON/XML/YAML files against NIST schemas, convert formats with round-trip fidelity, author SSPs/profiles/ARs/POA&Ms, fix validation errors, and integrate with FedRAMP/eMASS workflows.