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

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 browser interactions from the command line or AI agents: navigate pages, fill forms, take screenshots, scrape data, and test web applications using a fast, Rust-based CLI.

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.

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.

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.

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

Run SQL queries and perform multi-format data wrangling on CSV, TSV, Excel, JSONL, and Parquet files using qsv's 51 skill-based commands. Profile, clean, validate, join, convert, and chart tabular data with reproducibility logging and ontology inference.

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.

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 a comprehensive Rust development assistant with skills for coding guidelines, error diagnosis, refactoring, crate management, and domain-specific patterns (web, embedded, fintech, ML). Includes commands for security audits, clippy linting, documentation fetching, and news aggregation, plus agents for multi-layer code analysis and web fetching.

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.

Search and resume prior Claude-Code/Codex-CLI sessions to recover task context, decisions, and code patterns without bloating the current workspace.

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.

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.

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.

Generate API reference docs by scanning source code for routes, types, params, schemas, responses, and auth; produce Markdown project docs with module overviews, function details, examples, and configs; automatically update README.md to reflect current project state including installation, usage, badges, and verified examples with diffs.

Scan direct and transitive dependencies across Node, Python, Java, Rust, Go package managers for license compliance, classify licenses, flag issues with counts and statuses in reports, and generate NOTICE files attributing third-party licenses with full texts, copyrights, and project notices.

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.

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.

Adds 48 reusable skills and 9 domain-specific agents for Godot 4.x game development, covering GDScript/C# code generation, 2D/3D systems, multiplayer, AI navigation, UI/HUD, animation, shaders, physics, editor plugins, performance profiling, testing, CI/CD, and mobile export.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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 structured multi-domain code reviews combining architecture analysis, API surface inspection, blast radius risk scoring, bug detection, test quality evaluation, and language-specific audits (Rust, shell, math) into unified reports with actionable recommendations for pre-release and pre-PR quality gates.

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.

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.

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.

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.

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.

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

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.

Enforces architectural, clean code, DDD, security, and test-quality rules across the full SDLC — from design and requirements through code generation, review, and refactoring — with project-specific configuration and per-feature context preservation.

Enforce a structured development workflow with TDD, code review, acceptance testing, and knowledge curation. Plan features, delegate implementation to subagents, verify branches against criteria, and persist lessons as repository memory.

Generates Mermaid diagrams visualizing codebase architecture, dependencies, data flows, call chains, class hierarchies, community-detected module boundaries, and workflows — helping developers understand, document, and analyze system structure for onboarding, PR reviews, and refactoring

Hardens production AI coding agent sessions with quality gates, security guards, continuous QA, and structured agent modes. Enforces behavioral rules, blocks dangerous operations, runs tests on file writes, and scores session quality 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.

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.

Automatically discover and load 410+ production-ready skills across 33 domains — from API design and cloud infrastructure to ML/AI and distributed systems — activating relevant expert capabilities based on project context and conversation.

Enforce a governed development workflow with ADRs, RFCs, work items, and verification guards using the govctl CLI. Review and audit governance artifacts, run premortem risk analysis on design decisions, and automate commit checks with phase gates for compliance.

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.

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.

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.

Automate syncing solana-keychain crate to latest version in Cargo.toml for Rust projects, detect new upstream signer backends, and generate config structs, enum variants, and adapter functions. Bundle git repositories into LLM-optimized markdown files via local server.

Orchestrate multi-agent coding workflows with built-in TDD, code review, security scanning, and automated pattern learning across Go, Java, Python, TypeScript, Rust, and C++ projects.

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.

Review and improve Rust projects with deep checks for ownership, lifetimes, async/tokio, serde, sqlx, axum, FFI, macros, unsafe code, and testing patterns — including git-diff auditing, false-positive verification, and project scaffolding with linting and CI.

Automate comprehensive code review workflows including conventional git commits/PR creation, fetching/responding to GitHub PR feedback, detecting/fixing LLM artifacts in multiple languages, enforcing verification protocols to minimize false positives, generating release notes, and logging outcomes for review skill improvement.