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

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

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.

Scaffold, build, and deploy Makepad Rust UI apps with boilerplate generation, widget and layout code, shader creation, event handling, and cross-platform packaging for desktop, mobile, and WASM via GitHub Actions.

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.

Implement Trail of Bits handbook security testing workflows: fuzz Rust, Python, C/C++, Ruby code with AFL++, libFuzzer, cargo-fuzz, Atheris; instrument AddressSanitizer; run static analysis via Semgrep, CodeQL; generate coverage reports, dictionaries, and bypass obstacles for vulnerability detection.

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.

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.

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.

Scan smart contract codebases in Solidity, Vyper, Solana/Rust, Move, TON, or CosmWasm to identify externally callable state-changing functions, categorize them by access levels, and generate structured reports for security audits and access control reviews.

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.

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.

Build secure Rust applications integrating Azure services: authenticate with Entra ID, manage Key Vault secrets/keys/certificates, perform CRUD on Cosmos DB documents and Blob Storage, and stream data via Event Hubs using official SDK patterns and code examples.

Apply best practices, patterns, and conventions when developing Freya Rust GUI applications, including writing components, hooks, elements, and managing projects.

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.

Wrangle, profile, clean, transform, and analyze tabular data (CSV, TSV, Excel, JSONL, Parquet) using 51 qsv skill-based commands — including SQL queries, joins, validation, ontology inference, charting, performance acceleration, and reproducible logging.

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.

Analyze DWARF debug files (v3-v5) in binaries to understand the format and standard, extract information using dwarfdump/readelf/llvm-dwarfdump for verification, and review parsing code in bash/python/rust for compliance and accuracy.

Author, review, and optimize YARA-X detection rules for malware analysis using guided best practices for naming conventions, string selection, performance tuning, legacy rule migration, and false positive mitigation, with built-in linting and quality analysis.

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.

Get expert Rust development assistance: diagnose ownership/borrow errors, apply coding guidelines, manage crate documentation, navigate codebases with LSP, and enforce domain-specific patterns (fintech, embedded, web services, ML).

Write and review Godot 4.x game code in GDScript and C# with 51 domain-specific skills covering 2D/3D rendering, physics, animation, AI, multiplayer, UI, shaders, performance optimization, and editor tooling, plus 9 specialized agents for architecture, code review, animation, UI, shaders, performance, and C#-first development.

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.

Audit C/C++/Rust codebases for missing zeroization of sensitive data and compiler optimizations removing wipes. Analyze source code, LLVM IR, and control flow across optimization levels; generate PoCs to verify exploitability; validate with compilation runs and semantic checks; assemble JSON/markdown reports.

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.

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.

Search codebases structurally across 15+ languages using SQLite-based fast indexing for symbol lookup, implementation discovery, usage tracking, class hierarchy exploration, and project map generation.

Run slash commands to perform security audits: scan dependencies for vulnerabilities and risks, review auth configs and inputs, generate severity-prioritized reports with remediations and code fixes, add secure authentication systems with MFA and RBAC, and automatically harden app configurations across encryption, headers, and infra.

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.

Search and resume prior Claude-Code/Codex-CLI sessions to recover task context, decisions, and next steps without bloating the current chat. Also monitors a visual scratchpad inbox for new items on each prompt submission.

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.

Fully manage Ubiquiti UniFi networks via Rust CLI, TUI, and AI agent for VLANs, SSIDs, firewalls, NAT, DHCP reservations, clients, devices, events, stats, DPI, backups, and raw API access. Audit configurations for security vulnerabilities like open WiFi or permissive rules with ranked remediations. Run health checks on controllers, devices, alarms, and clients. Deploy autonomous agents for diagnostics and ongoing control.

Build and deploy AI agents to trade crypto, stocks, forex, and derivatives on Kraken via bash CLI: monitor markets, execute strategies like DCA, grid bots, basis trades, portfolio rebalancing; manage risks, staking, subaccounts with paper trading default and live opt-in safeguards. Integrates with Claude, Cursor, VSCode for stdio tool calls.

Audit JavaScript, Python, and Rust project dependencies for vulnerabilities, licensing issues, maintenance status, unused packages, and tree depth, generating prioritized reports. Then safely update npm and pip dependencies by risk category (patch, minor, major) with changelog verification, batch tests, git commits, and summary reports.

Detect affected packages in monorepos from git changes to generate targeted build/test/lint/deploy commands, and synchronize versions across packages by analyzing commits, applying semver bumps, updating deps/lockfiles, generating changelogs, and auto-committing/tags.

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.

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

Develop cross-platform Rust GUI apps with Makepad 2.0. Generate app boilerplates with Cargo.toml and hot reload, script UIs using Splash DSL for state, events, layouts, and themes, implement animations, shaders, and vector graphics, migrate from v1.x, optimize performance via batching and GC, and troubleshoot rendering bugs, zero-height issues, and WASM builds.

Perform fast structural code searches for symbols, classes, usages, implementations, hierarchies, and dependencies in polyglot projects spanning Android/Kotlin/Java, iOS/Swift/ObjC, web TypeScript/JavaScript (React/Vue/Svelte), Rust, Ruby/Rails, C#/.NET, Python, Go, and more via ast-index CLI. Use one-command initializers to configure Claude settings, rules, and docs for your stack.

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.

Run specialized commands and switch to expert agents for code quality analysis, PR reviews, GitHub automation, dependency updates, performance optimization, technical debt assessment, and plan generation across JavaScript, TypeScript, Python, Rust, Flutter, and Node projects in Claude Code.

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.

Orchestrate full-cycle development for Python, Rust, TypeScript projects: brainstorm ideas into specs and plans, initialize repos with GitHub Actions CI/CD, Makefiles, pre-commit hooks; execute implementations via TDD, progress tracking, checkpoints, and iterative code polishing with multi-LLM war rooms.

Use 48 Spanish commands and 9 specialized agent roles in Claude Code to switch perspectives for code analysis, refactor safely, automate GitHub PR creation/reviews/issues, update dependencies in JS/TS/Python/Rust/Flutter/Dart, optimize performance/security, generate specs/plans/docs, and verify facts/prompts.

Run 48 specialized commands and delegate to 9 expert agents for code analysis, PR/issue automation, performance profiling, security audits, refactoring with SOLID metrics, dependency updates, doc generation, and multi-role debates to streamline development workflows with Japanese support.

Run Traditional Chinese commands and switch to expert agents for code quality analysis, safe refactoring, performance optimization, security audits, PR reviews, dependency updates, Git automation, and documentation generation across JS/TS, Flutter, Node, Rust, Python projects. Analyze architecture, debate trade-offs, plan implementations, and monitor CI with structured reports and fix suggestions.

Use Portuguese commands and specialist agents in Claude Code to analyze dependencies/circular issues, review PRs with severity feedback, safely update Flutter/Node/Rust deps, switch roles for frontend/backend/mobile/security audits, automate GitHub PR/issue management, generate plans/specs/commits, and optimize performance/docs.

Run 39 specialized Chinese commands and switch between 9 expert agents to analyze code quality, refactor safely, review and automate GitHub PRs/issues, update dependencies across JS/TS/Node/Flutter/Rust/Python, generate implementation plans, perform multi-role debates, and optimize performance/security in dev workflows.

Run Korean-language commands and switch to specialist agents (frontend, backend, security, performance) for codebase analysis, safe refactoring, PR/issue management, dependency updates, performance audits, tech debt scoring, and structured planning in JS/TS/Python/Rust/Flutter projects.

Switch to French-speaking expert roles (security, performance, frontend, backend) and run specialized commands to analyze code quality, review PRs, manage GitHub workflows, refactor safely, update dependencies across JS/TS/Python/Rust/Flutter, generate plans/specs, and monitor CI in Claude Code.

Enforce readability rules like short functions, flat control flow, and idiomatic patterns in C/C++/Rust/CUDA code while writing, reviewing, or refactoring. Fetch precise examples from cppcheatsheet for modern C11-C23/C++11-C++23 features, CUDA GPU computing, system programming, debugging tools, and Rust interop to write correct code or prep for interviews.

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.

Optimize Claude Code sessions by detecting/removing codebase bloat, dead code, and AI-generated hygiene issues; manage token budgets/context windows with MECW principles and subagent delegation; monitor CPU/GPU usage before intensive tasks; automate safe git-backed cleanups and audits.

Automate Git-centric development workflows: generate conventional commit messages from changes, prepare PRs with quality gates and self-reviews, fix review feedback across steps from triage to validation, consolidate ephemeral docs into permanent ones, update tests and tutorials, bump versions with changelogs, and manage dependencies in Python/JS/Rust/Go repos.

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.

Scaffold secure smart contract projects with OpenZeppelin libraries across Solidity (Hardhat/Foundry), Cairo (Starknet/Scarb), Stylus (Arbitrum Rust), and Stellar (Soroban); develop ERC tokens, access control, governance; upgrade via proxies, modules, syscalls with storage safety and testing workflows.

Run multi-dimensional code reviews with specialized analysis for architecture, API surfaces, blast radius, bugs, Rust safety, math correctness, test quality, Makefiles, shell scripts, and code quality — all coordinated by orchestration skills for comprehensive pre-release or pre-PR audits

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.

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.

Automate and test Tauri v2 desktop/mobile apps from the terminal by launching/recovering driver sessions, controlling webviews, capturing UI states/screenshots, executing JavaScript, debugging IPC, and handling remote devices.

Unify Claude Code development workflows with automated code reviews, test execution, git operations (commits, PRs, issues), dependency auditing, debugging, architecture guidance, performance optimization, and documentation generation across JavaScript, TypeScript, Python, Go, Rust, and React.

Measure and optimize code performance by running benchmarks, analyzing flamegraphs, and detecting regressions across Python, Rust, Node.js, and Go projects with CI integration and remote querying of historical performance data.

Validate, classify, and govern knowledge graphs by building and querying RDF/OWL ontologies with an embedded Oxigraph triple store.

Enforce a structured development workflow with TDD, code review, acceptance testing, and knowledge curation. Plan features collaboratively, generate implementation specs, execute tasks via parallel subagents, and finalize branches with git workflows including GitHub PR creation.

Configure tsk Docker container images for Rust, Go, Node, Python, or Java projects by detecting the stack, migrating Dockerfiles to tsk.toml layers, running dry-run builds, and interactively troubleshooting setup issues.

Visualize any codebase with Mermaid diagrams showing architecture, dependencies, data flows, call chains, and class hierarchies. Detects community clusters, circular dependencies, and coupling issues to aid refactoring and onboarding.

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.

Prevents unsafe agent actions with pre-tool guards (rm -rf, data exfiltration, unsafe publishes), enforces structured development modes (TDD, debugging, sprint), and scores session quality with 4D weighting to produce handoff artifacts for production-grade AI coding sessions.

Run automated code quality reviews on pre-commit changes and GitHub PRs with language-aware analysis for idiomatic patterns, test coverage, DRY/SOLID principles, error handling, and build verification. Supports Go, Python, Rust, TypeScript, Java, and custom project profiles like HyperShift.

Enforce IDALIB-specific Rust style guidelines in your editor to ensure consistent code for bindings contributions, covering imports, naming conventions, accessors, error handling, borrowed types, and module layout.

Build production-grade Solana programs with financial correctness patterns for onchain math, escrows, AMMs, vaults, oracle freshness, and slippage, using Anchor, Quasar, Rust, TypeScript clients, and LiteSVM testing

Orchestrate parallel subagent workflows with ultrawork mode, automated git/PR management, TDD enforcement, Ralph Loop autonomous execution, and structured planning with PRD generation, all within Claude sessions

Invoke /cyber-neo on any local project path to scan for vulnerabilities across SAST, SCA dependency CVEs, leaked secrets, auth/crypto flaws, misconfigurations, supply chain risks, and CI/CD issues, covering OWASP 2025 Top 10 and CWE Top 25. Obtain prioritized reports with remediation guidance to secure your codebase quickly.

Debug embedded targets (ARM Cortex-M/RISC-V) via probe-rs using CLI or MCP tools for probe discovery, flashing, memory access, and RTT I/O during hardware bring-up and runtime diagnostics.

Index codebases with Tree-sitter to enable precise navigation across Rust, Python, TypeScript, JavaScript, Go, and Java files: search symbols, trace cross-file callers, read function implementations, discover tests, and grep with scope awareness using integrated skills and CLI commands.

Discovers and loads 410+ context-aware skills across 33+ domains for Rust, Python, TypeScript, Zig, Go, and Swift development — covering backend, frontend, APIs, databases, cloud infrastructure, AI/ML, security, distributed systems, and code refactoring. Skills auto-activate based on project context and conversational intent, enabling progressive discovery of specialized capabilities for engineering, data, mobile, and product management tasks.

Enforce governed workflows with ADRs, RFCs, work items, and review agents that validate decisions, compliance, and quality against project governance rules.

Write Rust code with ownership and lifetimes, handle errors using Result/Option with thiserror and anyhow, and build concurrent async applications with tokio and reqwest.

Build and manage Apollo GraphQL ecosystems: develop GraphQL servers and clients across React, iOS, Kotlin, and Rust; design schemas; compose federated supergraphs; configure routers; and manage schemas via Rover CLI or the GraphOS MCP server.

Orchestrate autonomous AI coding agents to fetch specs from Figma designs, GitHub issues, Linear tickets, or Notion pages; generate structured plans; iteratively implement code in React/Next.js/Vue/Svelte/Astro/HTML or Node/Python/Rust/Go projects; validate with tests/lints; commit changes; create/update PRs/tasks.

Deploy and run a blazing-fast Rust MCP server for multi-engine web search across 9 engines including Bing, DuckDuckGo, and Brave. Invoke 7 MCP tools to perform web searches, fetch web content, GitHub READMEs, and domain-specific articles with configurable API keys, proxies, and no runtime dependencies.

Extend Claude Code with TDD enforcement, security audits, automated code reviews, multi-agent orchestration, and session-based learning across Go, Rust, C++, Java, Kotlin, Python, TypeScript, and more.

Automatically syncs the solana-keychain dependency to the latest version and generates Rust signer adapter code, keeping Solana keychain integrations up to date.

Build type-safe RPC APIs with Vovk.ts in Next.js by defining typed procedures, decorators, and segments; then generate typed clients for TypeScript, Python, and Rust, produce OpenAPI specs, and expose endpoints as LLM tool definitions.