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

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

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.

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.

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.

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

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.

Provides comprehensive Rust skills, commands, and agents for code style enforcement, ecosystem queries (crates, docs, versions), compiler error diagnosis (ownership, lifetimes, mutability), domain-specific patterns (web, ML, fintech, embedded, cloud-native), code review (anti-patterns, unsafe), and project navigation via LSP. Includes workflow hooks for automated prompt-based actions.

Provides 48 domain-specific skills and 9 agents for Godot 4.x game development in GDScript and C#, covering 2D/3D systems, animation, AI, UI, multiplayer, performance optimization, and editor tooling.

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.

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.

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.

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.

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

Search prior CLI-agent sessions for code patterns, decisions, and context; recover the last task status and next steps to resume work without losing progress. Conditionally trigger actions on every user prompt.

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.

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.

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.

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.

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.

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.

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.

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.

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

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

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.

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.

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.

Conduct comprehensive, multi-domain code reviews with automated blast radius analysis, architecture assessment, API surface evaluation, bug detection, test suite quality checks, and language-specific audits for Rust, shell, and math-heavy code. Orchestrate specialized reviews and enforce commit policies.

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.

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.

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.

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.

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.

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

Enforce a structured development workflow around TDD, code review, acceptance testing, and memory documentation by routing Claude Code's behavior through specialized skills, subagents, and git-based branch lifecycle automation.

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 a codebase's architecture by generating Mermaid diagrams for dependencies, data flow, call chains, class hierarchies, and community structure. Supports Python, JavaScript/TypeScript, and Rust, with automatic detection of circular dependencies and architectural clusters.

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.

Hardens AI coding agent sessions with quality gates, security guards, and continuous QA — blocks dangerous operations, enforces structured development modes, and scores session work with handoff artifacts.

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.

Orchestrate complex development workflows with subagents: decompose tasks, plan execution, enforce TDD and code quality, manage git commits and PRs, and run automated checks across multiple languages.

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

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.

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.

Auto-discovers and loads 410+ production-ready skills across 33+ domains (ML, API, database, testing, infrastructure, security, frontend, backend, mobile, devops, etc.) based on project context, enabling progressive skill discovery and just-in-time access to specialized capabilities for any development task.

Enforce governed development workflows with ADR/RFC creation, review agents, compliance audits, and git-integrated work item tracking via the govctl CLI.

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.

Write and debug Rust code with advanced language support including ownership, async patterns, and error handling, plus automated logging of file writes and web fetches to a knowledge base.

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.

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.

Assess codebase readiness for AI coding agents across 8 pillars—git setup, testing, code quality, secrets, file sizes—using /readiness, then bootstrap enforcement tooling with /setup for TDD, secret scanning, file limits, git hooks, and auto-generated docs in Node/TS, Python, Go, or Rust projects.

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

Provides 14+ agents, 56+ skills, and 33+ commands for Claude Code to enforce TDD, run security scans, review code, manage multi-agent workflows, and continuously learn from sessions across languages like Go, Rust, Java, Kotlin, Python, TypeScript, and C++.