Go plugins

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.

Run comprehensive security analysis: SAST vulnerability detection across multiple languages, dependency scanning with automated remediation, threat modeling (STRIDE/attack trees), container and cloud security hardening, and compliance checks (OWASP Top 10, GDPR/HIPAA/SOC2) — all automated through CLI commands and agents.

Write safe, concurrent systems code across Rust, Go, C++, and C with production patterns for memory management, async/await, and concurrency, plus scaffolding and expert agents for each language.

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.

Audit dependencies across multiple languages for vulnerabilities, license issues, and outdated packages, with actionable remediation strategies. Also modernizes legacy codebases through safe, incremental framework migrations and dependency updates.

Write modern, memory-safe systems code in C++, Go, and Rust with idiomatic patterns for concurrency, RAII, smart pointers, and performance optimization.

Provides a team of specialized expert agents that each deep-dive into specific languages and frameworks—from Angular and React to Rust, Go, Java, Swift, and more—so you can delegate complex, language-specific tasks like architecture design, performance optimization, and enterprise patterns to the right expert on demand.

Write high-performance, memory-safe systems code in C++, Go, and Rust with idiomatic patterns for concurrency, resource management, and modern language features.

Run the official Go language server (gopls) inside Claude Code for real-time diagnostics, type checking, find references, and navigation in .go files.

Provides Go code intelligence via the gopls language server, including completions, diagnostics, formatting, and refactoring.

Configure and run SAST tools (Semgrep, SonarQube, CodeQL) for automated vulnerability detection in application code, with support for custom rules, CI/CD integration, quality gates, and false positive triage

Master Go concurrency patterns with goroutines, channels, sync primitives, and context to build concurrent applications, implement worker pools, and debug race conditions.

Idiomatic Go patterns and production tooling for the full development lifecycle: coding conventions, concurrency, performance optimization, testing, debugging, CI/CD, database access, GraphQL, gRPC, monitoring, and security auditing.

Scans codebases for security vulnerabilities using CodeQL and Semgrep static analysis. Automatically creates databases, runs query suites, processes SARIF output, and integrates findings into CI/CD pipelines.

Write, run, and debug Ginkgo/Gomega BDD test suites in Go: tree-construction model, spec authoring, table-driven tests, decorator reference, filtering, parallelization, flaky spec management, timeouts, async assertions, CI configuration, and JSON-based failure diagnosis via ginkgo CLI.

Fuzz C/C++, Rust, Python, and Ruby code with coverage-guided fuzzers (libFuzzer, AFL++, cargo-fuzz), detect memory errors via sanitizers, and set up continuous fuzzing with OSS-Fuzz. Includes static analysis with Semgrep and CodeQL, timing side-channel detection, and cryptographic test vectors.

Audit smart contracts across 6 blockchains (Ethereum/Solidity, Solana, Cosmos, Substrate, Algorand, TON, StarkNet) using Trail of Bits' Building Secure Contracts framework. Runs automated vulnerability scans, generates security documentation, assesses codebase maturity, and guides secure development workflows.

Generate interactive API documentation from OpenAPI/Swagger specs with runnable code samples in curl, JavaScript, Python, and Go, including auth guides, error references, versioning, and deployment-ready sites. Also reverse-engineer existing APIs to produce OpenAPI 3.0 specs, test collections, and client SDKs.

Run a complete penetration test workflow — authorize targets, scan for vulnerabilities across code and network, map findings to OWASP Top 10, and produce executive reports with chain-of-custody.

Audit project dependencies for known vulnerabilities, outdated packages, and license compliance across Node.js, Python, PHP, Ruby, Go, and Rust, generating detailed reports with CVEs, upgrade paths, and recommended fixes.

Generate production-ready GCP code examples from official ADK, Genkit, Vertex AI, and Gemini repositories, adapting to Python, TypeScript, or Go with built-in security, monitoring, and infrastructure-as-code for AI agents and cloud applications.

Analyze code coverage metrics (line, branch, function) across JavaScript, TypeScript, Python, Go, and Java projects. Identify untested code paths, dead code, and coverage gaps, then generate detailed reports with per-file breakdowns and actionable recommendations.

Generate production-ready gRPC services from Protocol Buffer definitions, including stubs, streaming RPCs, interceptors, health checks, TLS, tests, and REST gateways across multiple languages.

Build multi-language source code graphs for security analysis, including call graphs, attack surface mapping, blast radius, taint propagation, and complexity hotspots. Generate Mermaid diagrams, compare graph snapshots for structural diff, triage mutation testing results, and extract crypto protocol flows into ProVerif formal verification models.

Generate production-ready REST APIs from OpenAPI specs or schemas, with CRUD endpoints, pagination, filtering, authentication, validation, and test scaffolding for Express, FastAPI, Spring Boot, Gin, and NestJS.

Detect SQL injection vulnerabilities by scanning source code and database queries for unsafe patterns like concatenation and unparameterized ORMs. Traces user input through Django, Rails, Express, and Go frameworks to flag vulnerabilities and suggest parameterized queries.

Implement standardized API error handling with RFC 7807 responses, custom error classes, middleware, and logging across multiple backends (Node.js, Python, Java, Go).

Generate production-ready WebSocket servers with Socket.IO or native WebSocket, including room management, authentication, broadcasting, presence tracking, and Redis-backed scaling for real-time applications.

Generate ready-to-use test doubles (mocks, stubs, spies, fakes) by analyzing your code's dependencies, with support for Jest, Sinon, Python unittest.mock, Go interfaces, and testdouble.js.

Build and deploy production-ready Firebase Genkit AI workflows with RAG, multi-step flows, and tool calling, then deploy to Firebase Functions or Cloud Run with OpenTelemetry monitoring

Generate type-safe client SDKs from OpenAPI specs for TypeScript, Python, Go, and Java with built-in auth, retries, pagination, tests, and documentation.

Configure production-ready API gateways with routing, authentication, rate limiting, and health checks for microservices. Supports Kong, Express Gateway, AWS API Gateway, and custom implementations with load balancing and circuit breakers.

Generate pre-configured devcontainers with Claude Code integrated alongside Python, Node, Rust, or Go tooling, including persistent volumes for sandboxed development.

Configure mutation testing campaigns using mewt or muton, including scoping targets, tuning timeouts, and optimizing long-running runs to improve code quality.

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.

Integrate Zep agent memory into applications using temporal Context Graphs, with real-time documentation search for building and configuring Zep-powered apps.

Write expressive, correct Gomega assertions in Go tests, including synchronous Expect/Ω and asynchronous Eventually/Consistently patterns, a full matcher catalog, custom matchers, and sub-libraries for streaming output, subprocess management, HTTP client testing, goroutine leak detection, and benchmark measurements.

Guides Go developers using lestrrat-go/jwx v4 to parse and sign JWTs, work with JWS/JWE/JWK, select algorithms, and avoid common pitfalls.

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.

Installs a unified AI coding assistant configuration system with rules, skills, and commands to enforce coding standards, automate code reviews, commit messages, project setup, and generate documentation across multiple languages and frameworks (Go, Java, Python, TypeScript, Vue, etc.).

Orchestrates full-stack development workflows with specialized agents for code review, debugging, refactoring, testing, security auditing, and documentation across any software project.

Accelerate blockchain development with agents that help write and audit Solidity smart contracts, and build Hyperledger Fabric chaincode with enterprise network architecture.

Profile API endpoints and benchmark code implementations across multiple runtimes to identify performance bottlenecks, comparing metrics like latency, ops/sec, and memory usage.

Automates code refactoring and simplification across projects, removing dead/legacy code, reducing duplication, and enforcing framework-specific best practices for TypeScript, React/Next.js, Python, Go, and Swift while preserving functionality.

Manage multiple AI coding agent sessions with a unified CLI/TUI, enabling parallel task execution across sub-agents and seamless context handoff via session export/import.

Automates git workflows including conventional commits, stacked branches, PR preparation and review, changelog generation, and version management. Also handles documentation consolidation, dependency updates, test generation, and workflow self-improvement through retrospective analysis.

Apply modern Go syntax guidelines and features (slices, maps, cmp, min/max, etc.) based on project's detected Go version from go.mod, avoiding outdated patterns.

Develop Terraform providers using the Plugin Framework: scaffold projects, implement resources and data sources with CRUD operations, add imperative actions, generate Registry documentation, and run acceptance tests.

Scaffold production-ready projects with configurable stacks (TypeScript, Python, Go, Rust) and add feature modules (CRUD, services, CLI commands, UI components) with auto-generated tests and wiring.

Translate natural language into regex patterns across multiple flavors (JavaScript, Python, Go, Java, PCRE), then test them against sample inputs with captured groups and performance metrics

Automate AWS service configuration and deployment: create secure S3 buckets with encryption, versioning, and lifecycle rules, and deploy Lambda functions with IAM roles, triggers, VPC config, and IaC definitions.

Execute trades on Taiwan equity and derivatives markets (TWSE/TPEX/TAIFEX) through Shioaji's Python binding, CLI tool, or HTTP API server with server-sent events for real-time market data and order handling.

Integrate and manage Stripe payments: configure checkout sessions, billing flows, Connect accounts, and Treasury. Set up new Stripe projects with CLI, and safely upgrade API versions and SDKs across Python, Ruby, Node.js, Java, Go, and .NET.

Perform security code reviews across all languages using Project CodeGuard and OWASP rules, produce markdown reports with prioritized findings, and guide migration of C/C++/Assembly code to memory-safe languages like Rust, Go, Java, C#, or Swift.

Manage Qdrant vector search deployments end-to-end: scaling, performance tuning, search relevance optimization, multitenancy, zero-downtime upgrades, embedding model migration, monitoring with Prometheus/Grafana, and Edge deployment for local vector search

Automates development workflows across project management, code review, documentation, and system administration with agents for Jira, GitHub, Confluence, code analysis, mobile testing, browser control, and task management.

Debug application issues, manage dashboards, SLOs, alerts, and synthetic monitoring checks in Grafana Cloud using the gcx CLI, with support for GitOps workflows, Go code generation, and observability-driven root cause analysis.

Fast structural code search across polyglot projects using ast-index CLI — find symbols, classes, usages, implementations, hierarchies, and dependencies in Android/Kotlin/Java, iOS/Swift/ObjC, TypeScript/JavaScript, Rust, Ruby, C#, Python, Go, and more.

Automate the full Git and GitHub coding workflow: intelligent commits, branch cleanup, PR management, changelog and README generation, CLAUDE.md maintenance, and GitHub Actions setup

Analyze Go codebases with AST-aware call graphs, blast-radius impact analysis, and security-flow candidate detection, plus 61 query capabilities for reading, navigating, reviewing, and refactoring Go code.

Automate the full development lifecycle of the Ark Kubernetes operator for AI agents: run Playwright dashboard tests, manage CVEs and OWASP vulnerabilities, generate CRDs, orchestrate OpenSpec feature workflows, provision isolated Kubernetes clusters, and sync documentation.

Load-test websites and APIs with k6, instrument apps with OpenTelemetry and eBPF, ship telemetry to Grafana Cloud, and troubleshoot performance, cardinality, and cost issues across Prometheus, Loki, Tempo, and Pyroscope.

Enforce Project CodeGuard security rules to prevent common vulnerabilities when writing, reviewing, or modifying code across languages like Go, C, and Docker.

Enforces a verification-first engineering workflow across investigation, design, implementation, verification, and shipping phases with structured skills, specialist agents, and evidence requirements for senior ICs and tech leads.

Run comprehensive application security scans including SAST, SCA, secrets detection, and MITM proxy traffic analysis, then validate and prioritize findings for remediation.

Interactively debug source code by setting breakpoints, stepping through execution, inspecting live variables, evaluating expressions, and tracing root causes for crashes, exceptions, or wrong output.

Query SkyWalking BanyanDB time-series data using natural language or BydbQL, inspecting STREAM, MEASURE, TRACE, and PROPERTY resources with schema exploration and read-only execution.

Design, run, and debug multi-agent orchestration workflows using natural language descriptions, with support for parallel/conditional execution, checkpoints, error recovery, and real-time visualization

Write idiomatic Go code with expert guidance on package design, error handling, interfaces, concurrency, testing, and project layout, current through Go 1.25.

Write idiomatic Go code that adheres to community style guides, covering error handling, concurrency, testing, and documentation — with automated code review and linting setup.

Enforces TDD with 80%+ coverage, runs multi-phase verification (build, lint, test, security), reviews code for security and quality issues, and manages learned instincts that evolve from session patterns into reusable skills, commands, and agents.

Enforce a dual-review, state-machine-gated development workflow with hook-enforced code review, pre-commit checks, test coverage analysis, and fail-closed safety gates across feature development, bug fixes, and refactoring.

Perform safe file operations in Go: cross-filesystem moves, copies, and renames with conflict-safe naming, plus filename sanitization for all operating systems.

Build Go CLI applications using Cobra and Viper with expert guidance on command-first architecture, configuration management, environment variable binding, and in-memory testing, authored by the creator of both libraries.

Review Go design documents before implementation to catch over-engineering, missing error paths, interface misuse, and Cobra/Viper convention violations while changes are still cheap

Manage Go module and application releases with semantic versioning, API compatibility checks, go.mod hygiene, tagging, and binary distribution via GoReleaser.

Build native desktop applications in Go with Wails, automatically detecting v2 (stable) or v3 (alpha) to prevent API mixing

Run security best-practice reviews on Python, JavaScript/TypeScript, and Go code, detecting vulnerabilities and suggesting framework-specific improvements when explicitly requested.

Automate code review with language-aware analysis, pre-commit verification for staged changes, and multi-specialist deep reviews that post to GitHub or GitLab. Supports Go, Python, Rust, TypeScript, Java.

Guide ffuf web fuzzing for authorized penetration tests, including directory/subdomain discovery, parameter fuzzing, authenticated raw requests, auto-calibration, rate limiting, and JSON output analysis

Run a comprehensive cybersecurity audit on any local project. Detects code security flaws, dependency vulnerabilities, secret leaks, authentication/authorization issues, cryptographic weaknesses, misconfigurations, supply chain risks, and CI/CD security gaps. Outputs a prioritized report with actionable remediation steps.

Implement structured logging across Node.js, Python, and Go with proper log levels, request context, and PII sanitization; integrate with ELK/CloudWatch to eliminate log bloat, PII exposure, and missing context errors.

Build and manage data processing pipelines, integrations, and ML scenarios in SAP Data Intelligence Cloud. Create operator graphs with Gen1/Gen2 operators, integrate ABAP/S4HANA systems, develop replication flows, and work with JupyterLab notebooks and Data Transformation Language functions.

Run a complete software development lifecycle with 18 specialized agents covering backend (Go/TypeScript), frontend (React/Next.js), DevOps, QA, and security — including gated development cycles, TDD, code review, accessibility/E2E/performance testing, dependency auditing, and infrastructure-as-code validation.

Orchestrates the pre-development phase of product features: conducts research via parallel agents, generates PRDs and TRDs, designs API contracts and data models, maps delivery phases, and cross-references artifacts for consistency. Supports small (4-gate) and large (8-gate) feature tracks with human approval gates.

Work with Neo4j graph databases: Cypher queries, graph modeling, Aura provisioning, GraphRAG pipelines, vector indexes, Graph Data Science algorithms, data imports, Kafka/Spark integrations, and driver management for multiple languages.

Neo4j graph database expert for data modeling, Cypher query writing and optimization, schema design, driver upgrades, and graph performance tuning. Includes CLI tools for database management, modern Cypher 25 query generation, and migration of driver code from 4.x/5.x to 6.x.

Access blockchain data and infrastructure across EVM and Solana via Alchemy, Allium, Dune, and Messari APIs, execute token swaps and bridges, trade prediction markets, manage wallets and fiat on/off-ramps, and automate trading strategies — all from the CLI with API key, x402 micropayment, and hardware wallet auth.

Accelerate development with subagent-based parallel execution, TDD enforcement, git automation, structured planning, and code review across any codebase.

Automate Spark repository development workflows including regenerating proto bindings in Go and TypeScript after file changes, resolving rebase conflicts in Ent and Atlas migrations, and validating wallet features with MCP tools against a local Spark environment.

Auto-detect your project's tech stack from configuration files and generate a CLAUDE.md file with curated coding standards for TypeScript, React, Python, Go, and Rust.

Local-first AI memory and knowledge graph for Claude Code: vector search, RAG, GraphRAG, SPARQL/RDFS/SHACL, scoped agent memory, and corpus-to-graph workflows — bundled as a skill plus live MCP tools.

Explore, map, and document unfamiliar codebases using static analysis, AST navigation, and semantic search. Generate blast-radius reports, interactive code maps, feature documentation, and knowledge graphs with bidirectional source anchoring. Perform semantic code searches and Python-specific symbol resolution via pyright and tree-sitter.

Scan Submariner Go repositories for CVEs with grype, apply deterministic fixes, run tests, and generate a pull request command.

Automate statistical software development with multi-agent teams that plan, implement, test, and ship R/Python packages via GitHub workflows, including Monte Carlo simulation studies and knowledge sharing across sessions.

Validates multi-language tool installations across Python, Node.js, Java, Go, Rust, and C/C++; generates HTML artifacts and Preact SPAs; creates MCP servers and bookmarklets; produces git patches for local application; and queries Markdown documents structurally.