Go plugins

Transforms Claude Code into an autonomous engineering platform with 64 specialized agents, 262 skills, and 84 commands for multi-agent orchestration, TDD, code review, security auditing, deployment pipelines, and cross-stack development across 30+ 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.

Transforms Claude Code into a full-stack development assistant with curated expertise across 12 programming languages, major backend and frontend frameworks, DevOps tools, and software engineering practices—enabling code generation, debugging, architecture design, testing, and project management all from a single skill pack.

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 production-ready Rust projects and write efficient systems code in Rust, Go, C, and C++ with memory-safe patterns, async concurrency, and performance-optimized architecture.

Automate the full TDD red-green-refactor cycle: generate failing tests, implement minimal passing code, safely refactor, and get AI-driven code review with security and performance analysis.

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.

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.

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.

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-ready Go CLIs from API specs or OpenAPI documents. Publish, regenerate, and improve CLI tools using a structured review pipeline that detects semantic bugs, scores output quality, and submits pull requests with fixes.

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

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 from planning to pull request: generate implementation plans, execute changes with validation loops, investigate issues, create PRs, and run multi-agent 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.

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.

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

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

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

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.

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.

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.

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.

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.

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.

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.

Battle-tested Claude Code configuration collection delivering 108 components (skills, commands, agents, hooks) for automated code review, test-driven development, security scanning, multi-agent orchestration, and project documentation — evolved over 10+ months of daily use

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.

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.

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.

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.

Orchestrates AI coding agent workflows with persistent issue tracking, knowledge compounding across sessions, multi-model validation gates, and autonomous task execution loops.

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.

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.

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

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.

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.

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.

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.

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

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.

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.

Provides 110 production-grade skills for Claude Code covering code review, security auditing, architecture analysis, testing, research, content creation, and agent automation. Includes git workflows, dependency auditing, manuscript validation, UX design review, and CI/CD pipeline management.

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.

Executes spec-driven development by decomposing large features into dependency-aware specs, then implements them autonomously task-by-task with verification, progress tracking, and interactive interviews for research, requirements, and design phases.

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.

Enforce secure-by-default coding practices and prevent common vulnerabilities when writing or reviewing code. Perform full security code reviews with OWASP-aligned rules and generate prioritized remediation reports. Guide migration of legacy C/C++/Assembly code to memory-safe languages like Rust, Go, Java, C#, and Swift.

Apply idiomatic Go best practices for code review, writing, testing, concurrency, error handling, and performance optimization using 20 modular skills that activate contextually with progressive disclosure, checklists, reference files, and bash automation scripts for linting, naming, docs, and benchmarks.

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.

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.

Auto-detect your project's tech stack from files like package.json and tsconfig.json, then generate CLAUDE.md with assembled coding standards tailored for TypeScript, React, Python, Go, or Rust. Trigger with 'init rules' or 'generate CLAUDE.md' to set up project coding guidelines instantly.

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 a live code knowledge graph via AST extraction and AI enrichment, then run adaptive challenges and spaced-repetition quizzes to prevent knowledge atrophy and accelerate onboarding.

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.

Build and manage apps on the Grafana App Platform using the grafana-app-sdk — define CUE kind schemas, implement reconciliation logic, and configure admission webhooks for custom resources. Also covers Grafana Cloud configuration, monitoring, cost optimization, dashboards, alerting, observability pipelines, and performance testing.

Request explicit security best-practice reviews for Python, JavaScript/TypeScript, or Go code to receive framework-specific guides, improvement suggestions, and vulnerability detections.

Conduct authorized penetration testing via ffuf web fuzzing to discover directories and subdomains, fuzz parameters, execute authenticated raw requests, auto-calibrate scans, apply rate limiting, and analyze JSON outputs for strategy building and result review.