Ruby plugins

Get expert assistance writing idiomatic PHP 8+ and Ruby code for web backends, with Rails patterns, metaprogramming, gem development, and performance optimization through delegate agents.

Orchestrate a full autonomous engineering pipeline from planning through PR creation, with multi-agent code review, browser testing, documentation management, and design verification against Figma.

Get code intelligence for Ruby and ERB files — including diagnostics, go-to-definition, find references, hover information, and symbol navigation

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.

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.

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 realistic test data with locale awareness, producing factory functions, database seed scripts, and fixture files ready for immediate use in tests.

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.

Routes user requests to specialized expert agents, creating new agents on demand with persistent agent-tagged memory that survives updates.

Analyze Rails applications and generate upgrade reports with breaking changes, deprecations, and migration guides for Rails 2.3 through 8.1, following FastRuby.io methodology for planning multi-hop upgrades.

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.

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.

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.

Adopt proven Ruby on Rails development workflows inspired by 37signals: TDD with Minitest, Hotwire interactive frontends, Brakeman security scanning, Sandi Metz code quality rules, and structured session handoffs for maintaining context.

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

Remove NextRails dual-boot scaffolding and Gemfile.next files after a Rails upgrade, preserving either the next or current version.

Audit Rails codebases for layered architecture violations, identify god objects and callback issues, plan phased adoption of patterns like service objects and ViewComponents, and review PRs against architectural rules.

Map backend routes, middleware stacks, database models, dependencies, and auth mechanisms, and assess code quality for project takeover

Write and refactor Ruby code with support for OOP, metaprogramming, blocks, gems, and the standard library, plus Solargraph-powered code intelligence for .rb, .rake, and .gemspec files.

Write and maintain Cucumber BDD tests using Gherkin syntax, with best practices for feature files, scenario outlines, and step definitions in JavaScript/TypeScript, Java, and Ruby. Also automatically formats and tests Kotlin code during editing.

Build full-stack Ruby on Rails applications with MVC patterns, Active Record database operations, and Hotwire reactive frontends

Centralizes Claude Code configuration with Docker-first guardrails, permission controls, and MCP gateway integration. Enforces safe database workflows with schema inspection and mutation previews, blocks dangerous commands in production Rails environments, and guides documentation-first implementation patterns for external APIs and libraries.

Helps Claude Code work with Ruby projects by providing authoritative documentation references, test framework knowledge for minitest versus test-unit, and automatic version manager detection for accurate command execution.

Query and manage Faultline error tracker and APM traces from within Claude Code to debug Rails production errors—examine error groups, occurrences, backtraces, and local variables; resolve, ignore, reopen, or delete error groups; spot regressions after deployments; and file GitHub issues with full context.

Enforces Rails development conventions across controllers, models, migrations, jobs, views, and authorization with Pundit, while guiding TDD, debugging, code review, and parallel task execution. Includes skills for design exploration, isolation, verification, and automated code review pipelines.

Orchestrate a structured Research/Planning/Implementation (RPI) workflow for AI-assisted development, with agents for code analysis, PR review, documentation, and session handoffs, tailored for Ruby on Rails.

Adopt Behavior-Driven Development workflows: collaborate through Three Amigos sessions, example mapping, and discovery workshops; write Gherkin feature files and Given-When-Then scenarios as living documentation and executable specifications.

Score your codebase's readiness for AI agents across 8 dimensions using parallel agents. Get a weighted 0-100 score, band rating, and an actionable improvement roadmap framed around the Stripe AI benchmark. Supports Ruby, Python, PHP, TypeScript, JavaScript, Go, Java, Scala, Rust.

Write, review, and debug RSpec test suites for Ruby projects: from basic describe/let blocks to custom matchers, shared examples, metadata hooks, and mocking with doubles/stubs/spies.

Enforces Ruby code quality standards using RuboCop with configurable YAML rules, auto-correction, cop customization, and GitHub Actions CI integration.

Validate, create, and publish CocoaPods podspecs for Apple platform libraries, including privacy manifests, modular subspecs, and test spec configuration for iOS, macOS, tvOS, watchOS, and visionOS.

Auto-derives codebase conventions from repo analysis and injects archetype-aware guidance into AI-generated code, enforcing team idioms, banned imports, and framework-specific patterns for TypeScript/JavaScript, Ruby, and Python projects.

Generate, review, debug, test, and deploy Ruby on Rails applications with specialized agents for database management, code quality, and performance optimization.

Drive a running local Rails dev server from the terminal with CSRF-correct form submissions, OTP-from-log login, Turbo Stream inspection, request-id log correlation, and session bridging to a real browser. Optionally use an agent-browser layer for screenshots, visual regression, Turbo-event/DOM-condition waits, Stimulus introspection, and structural diffs.

Enforce best practices and automate workflows with Claude Code hooks: guard bash commands, auto-approve or deny permission requests, detect unfinished todos, and manage git state across session lifecycle events.

Audit and refactor Rails applications to follow Vanilla Rails philosophy: thin controllers, rich domain models, and minimal service layers. Automatically flag over-engineering, anemic models, and fat controllers in PRs or full codebase scans, and plan incremental simplification.

Apply mental models and decision frameworks to debug Hotwire (Turbo, Stimulus, Hotwire Native) issues in Rails apps, including Turbo Frame updates, morphing problems, and broadcast failures.

Generate, validate, and render D2 diagrams from source code, text descriptions, or Mermaid diagrams, with automatic diagram type detection and configurable output settings.

Automatically generates and maintains a Memory Bank documentation system for projects: detects tech stack, creates documentation plans, validates links, removes redundancy, and imports external knowledge with semantic analysis.

Build Rails applications with Inertia.js using established architecture patterns, type-safe props via Alba/Typelizer, and adapted shadcn/ui components for React, Vue, or Svelte.

Accelerate everyday Rails and AI development with opinionated coding agents, code review commands, git workflow tools, and documentation generators following DHH/37signals conventions.

Guides 2D game development using DragonRuby Game Toolkit, providing patterns for tick loops, sprite rendering, input handling, collisions, animations, state management, and performance optimization.

Audit Ruby codebases for Ractor compatibility, detecting issues in gems, scripts, and Rails/Rack apps with static analysis and dynamic probes, and automate fixes and CI gates for Ruby 4.0+ concurrency readiness.

Enforce coding conventions and review code across Ruby, Rails, Rust, Terraform, and general projects. Write git commits and pull requests with structured messages. Audit code changes for security vulnerabilities.

Accelerate Rails development with TDD workflow, automated security and Rails best-practice code reviews, and Linear issue integration. Includes parallel review agents, worktree management, and PR creation.

Walk through a structured upgrade of Rails config.load_defaults, safely uncommenting, testing, and consolidating each new framework default until the target version is reached

Manage Conductor workflows end-to-end: create, run, monitor, and review workflow definitions, generate worker stubs in multiple languages, and set up the Conductor CLI.

Sets up Warp terminal with colored tabs and workflows for Rails development, including dedicated tabs for dev server, Claude, shell, console, logs, and jobs.

Guides Rails developers through the full consulting lifecycle: pressure-testing assumptions, scoping features into shippable slices, TDD with red-green-refactor, atomic git commits, code review, client updates, and offboarding wrap-up.

Teaches Claude Code features through D&D-themed quests that progressively unlock skills: custom slash commands, path-scoped rules, event-driven hooks, autonomous agents, permission policies, and plugin packaging.

Apply expert-level best practices and optimization patterns for React, Rails, and modern web development, covering accessibility, security audits, performance improvement, testing strategies, and project architecture.

Write and modify Ruby code through Claude Code using the claude-agent-sdk gem, supporting one-shot queries, interactive sessions, streaming input, 27 hook events, permission callbacks, MCP servers, structured output, and Rails integration.

Automatically detects project language and enforces SOLID principles with strict file size limits, separated interfaces, and modular architecture across C#, Go, Java, Python, Ruby, Rust, and TypeScript projects. Includes hooks for file write validation and MCPs for reasoning and search.

Orchestrates a full SDLC pipeline from backlog capture through planning, parallel task execution, code review, and goal-backward verification, using multi-agent teams and structured artifacts.

Run a full autonomous engineering workflow where an agentic system plans, implements, reviews, tests, fixes, and records feature walkthrough videos—all within a single PR cycle. Also provides surgical multi-agent code reviews, browser-based UI regression testing, Figma design comparison, bug reproduction, production deployment safety checks, and structured problem-solving from brainstorming to solution documentation.

Generate, fix, and refactor RSpec tests for Ruby on Rails applications using describe/it blocks, expect matchers, test doubles, and FactoryBot, following TDD best practices.

Checks and installs recommended Rails development gems (strong_migrations, bullet, letter_opener, herb) to improve code quality and developer experience by automating dependency setup, configuration, and N+1 detection.

Create and manage isolated cloud sandboxes on the Daytona platform for secure code execution with dedicated runtimes, enabling isolated development environments via SDK, API, or CLI operations.

Automate the creation and maintenance of Ruby type signatures using RBS and Sorbet. Generate inline annotations, separate signature files, and automatically update signatures for uncommitted Git changes.

Build Ruby terminal user interfaces with the RatatuiRuby gem, featuring managed event loops, widgets (paragraphs, lists, tables, gauges, charts), event polling, full-screen or inline viewport modes, and testing support.

Turn any web page into structured, machine-readable data via ScraperAPI's proxy rotation, geotargeting, and anti-bot bypass capabilities, accessed through MCP tools, SDKs (Node, Python, Ruby, PHP, Java), CLI, Async Jobs, Crawler, DataPipeline, or n8n workflows — with built-in skills for price monitoring, contact enrichment, market research, SEO audit, and AI-powered research agent.

Run read-only queries against a Rails 8.2+ app's database via `rails query`: execute SQL or ActiveRecord queries, explore schemas and models, view EXPLAIN plans, and run aggregate or lookup queries locally or on deployed environments through Kamal.

Coordinates Rails 8+ development with Hotwire, TDD, and security best practices — scaffolds controllers, models, views, and tests; configures SolidQueue/SolidCache; enforces vulnerability prevention and accessibility standards.

Transforms ambiguous spec documents into implementation-ready specs through structured interviews, then validates implementations against those specs by surfacing every gap for human resolution.

Guide creation and best practices for Draper decorators in Rails, separating presentation logic from models and views with structure, delegation, and helper usage.

Set up dual-boot Ruby/Rails environments for upgrading Rails, Ruby, or core dependencies using the next_rails gem, with CI configuration and version branching support.

Develop and review Ruby on Rails applications with code quality analysis, security scanning, test coverage enforcement, and performance diagnostics. Automates generator creation, BDD workflows, and code review using Sandi Metz principles.

Record TikTok-style video walkthroughs of local dev servers using the tik-test CLI, with optional checks-only mode for fast validation without video rendering.

Generate Rails migrations, define ActiveRecord associations (belongs_to, has_many, through), optimize queries (includes, preload, eager_load), fix N+1 issues, and add validations, callbacks, and database constraints.

Get Ruby and ERB code intelligence in Claude Code — diagnostics, go-to-definition, find references, hover info, and symbol search for .rb, .ru, .erb, .rake, .gemspec files.

Develop MCP (Model Context Protocol) servers in Ruby using the mcp gem, with guidance on design principles like context preservation, domain vocabulary, tool budgeting, and security.

Investigate and remediate supply chain security incidents across package ecosystems (npm, PyPI, GitHub Actions), cloud credential compromise (AWS, GCP, Azure, GitHub), and dependency manifests; harden configurations with pinning, SBOM, and signing best practices.

Run multi-phase pentests on your own codebase: map attack surface, deep-audit APIs and client-side code, simulate exploits, and generate CVSS-scored executive reports with remediation guidance across 8 languages.

Perform structural find, replace, delete, and insert operations across multiple programming languages using AST-aware transformations instead of regex or sed — rename functions, change API signatures, or remove logging statements with precision.

Audit, diagnose, and harden Ruby on Rails applications across the full development lifecycle — from architecture decisions and code review to security scanning, performance debugging, and pre-release quality gates.

Provides a comprehensive set of AI-driven skills for Ruby on Rails development, covering the full lifecycle from project setup and TDD to code review, security auditing, database migrations, engine creation, and release management.

Generate, convert, and maintain Ruby RBS type signatures using inline annotations or standalone .rbs files, with agents for codebase-wide typing, validation via Steep, and critical review of type quality.

Run Honeycomb-based observability investigations from Claude Code: query traces and metrics, diagnose production issues like latency spikes and error surges with BubbleUp and trace analysis, manage SLOs and burn rates, and instrument or migrate applications to OpenTelemetry.

Generate realistic test data including users, products, orders, and custom schemas for populating databases, simulating behavior, or creating fixtures.

Scan project dependencies for security vulnerabilities, outdated packages, and license compliance issues, generating a report with CVE details, safe upgrade paths, and recommended fixes for npm, pip, composer, gem, and Go modules.

Automate end-to-end CVE hunting in open source packages: discover vulnerable targets, audit code for 20+ vulnerability classes, build proof-of-concept exploits, eliminate false positives, and generate disclosure reports for HackerOne or GitHub Security Advisories.

Orchestrates multi-agent development teams with contract-gated verification loops, phase-based orchestration, and structural safeguards against premature exits. Automates planning, research, documentation, monitoring, and pipeline coordination across complex workflows.

Audit npm, pip, Cargo, Bundler, and Go dependencies for vulnerabilities, review lockfiles, compare package alternatives, and assess package trustworthiness to improve supply chain security.

Transforms vague feature ideas into validated, standalone task specifications (beads) through a structured multi-agent planning pipeline with cross-model review, then converts plans to OpenCode and Codex formats for multi-agent execution.

Run comprehensive security scans across your project — audits dependencies in Node.js, Python, Go, Ruby, and Rust, detects hardcoded secrets in git history, and finds code vulnerabilities with severity ratings and fix suggestions, all coordinated through a strategic security advisor agent.

Automates iterative PR review and autofix loops: reviews code changes against a base branch, fixes issues above a criticality threshold using auto-detected test/lint commands, and repeats until clean. Supports Ruby, Node, Python, Go, and Rust.

Manage DevOps workflows: create and optimize GitHub Actions CI/CD pipelines, deploy containerized apps with Kamal 2, and configure Tailscale VPN mesh networks.

Audit Ruby and Rails projects for breaking changes before upgrades, generate phased migration roadmaps, apply automated fixes with RSpec and RuboCop verification, and track upgrade health with a live dashboard.

Automatically validate documentation quality: check broken links, orphaned documents, glossary terms, structure, and detect contradictions. Run linting audits via /doc:lint and /doc:links commands with interactive or batch mode.

View and manage Bugsnag errors, organizations, and projects directly from the terminal — retrieve error details, events, comments, and stats, analyze trends, resolve errors, and add comments using Ruby API scripts.

Convert HTML content to Markdown, Djot, or plain text with extraction of structured metadata (title, Open Graph, JSON-LD) and tabular data, accessible via CLI, MCP server, or SDKs in multiple languages for direct use in agents and scripts.

Automatically detect and fix newly added type ignores (ts-ignore, eslint-disable, pylint:disable) across TS/JS, Python, Go, Rust, Ruby, and PHP codebases by replacing them with proper type annotations, imports, or declarations, with type-check verification.

Automate developer environment onboarding by analyzing project files to detect dependencies, generate Docker/docker-compose configs, create .env templates, configure pre-commit hooks and IDE settings (VSCode/Cursor), and troubleshoot common setup issues.

Enforces a complete TDD-driven SDLC workflow with event modeling for domain design, architecture decision records, stacked PRs via git-spice, and multi-agent orchestration for code review, mutation testing, and memory persistence across sessions.