Ruby plugins

Orchestrate swarms of specialized AI agents to automate end-to-end software development: plan features, implement code with Rails/Python/TS patterns, conduct multi-perspective reviews for architecture/security/performance, resolve todos/PR feedback in parallel, run browser/iOS tests, sync Figma designs, generate docs/videos, and ship PRs.

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

Scan Python, JavaScript, Ruby, and Docker configurations for insecure defaults like hardcoded secrets, fallback credentials, weak authentication, permissive settings, and dangerous production values. Run during security audits, config reviews, and pre-deployment checks to block fail-open vulnerabilities.

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.

Run mutation testing on JavaScript, Python, Java, Go, C#, or Ruby codebases to evaluate test suite quality. Introduce code mutants with tools like Stryker, mutmut, PITest, or go-mutesting, check detection rates, identify coverage gaps, and generate reports with survival scores and improvement suggestions.

Generate realistic test data for users, products, orders, technical fields, and custom schemas to populate fixtures, factories, seeds, edge cases, and databases in JS/TS/Python/Ruby apps using Faker.js, Fishery, pytest fixtures, and factory patterns.

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.

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.

Bootstrap Stripe projects with CLI, implement official best practices for payments via Checkout Sessions or PaymentIntents, Billing subscriptions, Connect Accounts, Treasury, Payment Element, and upgrade APIs/SDKs across Python, Ruby, Node.js, Java, Go, .NET.

Build and customize Shiny dashboards with modern Bootstrap 5 theming, including brand management, page layouts, cards, value boxes, navigation, sidebars, and dark mode support

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.

Upgrade Rails apps from version 2.3 to 8.1 by analyzing codebases to generate reports on breaking changes, deprecations, and step-by-step migration guides, supporting direct jumps or multi-hop plans and version-specific queries.

Perform AI-native security audits on repositories: scan source code for SAST vulnerabilities like SQLi and XSS, dependencies for CVEs via SCA, leaked secrets and API keys; validate findings by tracing data flows, testing exploits, and analyzing controls; proxy HTTP/HTTPS traffic for inspection; aggregate prioritized reports with remediation guidance.

Create and run multi-agent orchestration workflows from natural language descriptions, with parallel execution, conditional flows, checkpoints, visual progress tracking, and error recovery — all managed through a Socratic designer and interactive CLI.

Connect to MongoDB databases, explore schemas, generate queries and aggregation pipelines from natural language, analyze query performance with index recommendations, implement Atlas Search and Vector Search, and manage stream processing workflows — all from within Claude.

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.

Analyze Rails codebases for layered architecture violations like god objects, bad callbacks, and misplaced logic; review PRs and git changes with prioritized reports; generate phased refactoring roadmaps, extraction recommendations, and annotated test skeletons to enforce patterns.

Automate code reviews, refactoring, PR analysis, cleanups, and structural audits using specialized agents that detect dead code, duplication, naming issues, test gaps, abstractions, and artifacts in JavaScript, Python, Ruby/Rails codebases, files, directories, branches, or GitHub PRs, with reports, fix plans, and parallel resolutions.

Develop Ruby code with Claude Code, getting authoritative docs, version-manager-aware execution, and test framework guidance to avoid common errors

Provision phone numbers, send SMS/MMS/RCS, control voice calls/conferences, build/deploy AI voice assistants, manage WebRTC clients/pushes, handle 10DLC compliance/porting, and configure SIP/IoT via multi-language Telnyx SDK code examples, curl, CLI.

Accelerate Ruby on Rails app development by generating idiomatic code for Hotwire, GraphQL, background jobs, state machines, admin panels; performing DHH-style reviews, performance audits, data integrity checks; writing RSpec/Minitest; optimizing PostgreSQL/SQLite queries; deploying via Kamal/Docker; researching/building gems—all powered by 50 specialized skills, agents, commands.

Score your codebase's agent readiness across 8 dimensions using parallel AI agents to get a weighted 0-100 score, band rating, and actionable improvement roadmap based on Stripe AI benchmarks. Analyze Ruby, Python, PHP, TypeScript, JavaScript, or Go projects in one workflow.

Query and manage Faultline error tracker from Claude Code — investigate error groups with full backtraces and local variables, compare occurrences to isolate root causes, inspect APM traces for slow endpoints and N+1 queries, and manage error lifecycle (resolve, ignore, reopen, delete) with confirmation guards.

Write Ruby code with advanced OOP, metaprogramming, blocks, procs, lambdas, and gems/Bundler management, backed by Solargraph LSP for code intelligence and diagnostics.

Write and maintain Cucumber BDD tests using Gherkin syntax with guidance on feature file structure, scenario outlines, tags, and step definitions in JavaScript/TypeScript, Java, and Ruby. Includes hooks for tracking tool usage during test development.

Build production-grade Ruby on Rails apps using MVC controller patterns for routing, filters, and REST APIs; optimize Active Record models with associations, queries, validations, and scopes; add reactivity with Hotwire Turbo Drive/Frames/Streams, Stimulus, and ActionCable over Redis.

Scan codebases to auto-generate Mermaid diagrams (ER schemas, API sequences, service architectures, state diagrams from files). Generate diagrams from text descriptions, validate syntax in Markdown files/directories, render .mmd or Markdown blocks to themed SVGs, and configure themes/output via wizard.

Bootstrap VS Code with ATV's full suite of 81 AI skills and agents to automate end-to-end engineering workflows: swarm-parallel feature planning and implementation, tiered code reviews, auto-fixes for slop/todos/PR comments, pattern learning from git history, security/database/UI audits, browser testing, PR video recording, and deployment checklists.

Generate and maintain a project's Memory Bank—a living documentation system capturing tech stack, workflows, and knowledge—via AI agents that detect dependencies across Python/JS/Go/Ruby/Java/PHP, create/update docs with 3-way merges, import from URLs/files/text, fix broken links, check redundancy, and automate commits.

Write and review RSpec test suites for Ruby projects using BDD patterns, including custom matchers, shared examples, mocking, and stubbing.

Enforce Ruby code quality standards using RuboCop with customizable YAML configuration, built-in and custom cops, auto-correction, and integration into CI pipelines via GitHub Actions.

Maintain CocoaPods iOS/macOS libraries: create and validate podspecs, add privacy manifests, organize into subspecs, configure test specs, and publish to Trunk.

Write and collaborate on behavior-driven development scenarios using Gherkin, with support for Three Amigos sessions, example mapping, and living documentation to align developers, testers, and stakeholders on acceptance criteria and test coverage.

Review and simplify Rails codebases to Vanilla Rails style: thin controllers, rich domain models, minimal service layers. Analyze architecture for over-engineering, review PRs and changes with Markdown reports, generate phased refactoring plans with code examples, effort estimates, and risks.

Orchestrates a structured Research, Planning, Implementation (RPI) workflow for AI-assisted development, automating context engineering, ticket-to-PR pipeline for Rails features, session handoffs, and multi-agent code reviews.

Scan codebases in Python, JS/TS, Ruby, Go to auto-generate D2 diagrams for ER schemas, API sequences, service architectures, and classes. Convert Mermaid diagrams to D2 syntax, validate .d2 files or Markdown code blocks, configure themes/layouts, and render to SVG/PNG images.

Learn Claude Code features through a D&D-themed quest system with progressive levels, interactive dungeon mapping, custom slash commands, permission rules, event-driven hooks, and an agent guide — all built as a gamified tutorial inside your project.

Orchestrate Claude Code sessions as a kanban board with role-based agents, lifecycle management, and end-to-end testing of web, CLI, HTTP, database, and library APIs via browser automation, snapshot diffing, and log verification.

Integrate Claude AI agents into Ruby and Rails applications using the claude-agent-sdk gem. Implement and modify code via one-shot queries, interactive Client sessions, streaming inputs, 27 hook events, permission callbacks, MCP servers, structured outputs, session management, sandbox settings, and custom transports for AI-assisted development workflows.

Orchestrates a full research-plan-implement pipeline with parallel subagents, including brainstorming, architectural decisions, git worktrees, TDD, code review, security review, and verification checks to ensure quality and correctness.

Build production-ready Claude Code plugins by creating skills, subagents, and hooks from scratch; refining and validating structures for clarity and efficiency; empirically testing performance against baselines with metrics; automating manifests, safety checks, and marketplace publishing.

Perform pre-coding security assessments on tasks to identify risks and OWASP mitigations, generate developer-focused threat models with attack scenarios and fixes, and review code for vulnerabilities like injections, XSS, and deserialization in Python, JavaScript/TypeScript, React, Java, Go, Ruby.

Configure lifecycle hooks in Claude Code to automate project setup on session start, enforce git safety with auto-checkpoints and cleanups, intelligently manage permissions for safe operations, block risky bash commands and secrets, verify tests and task completion on session end.

Build server-driven SPAs with Rails backend and Inertia.js frontend in React, Vue, or Svelte by applying skills for project setup, architecture patterns, controllers with props and redirects, full-stack forms and validation, page components with layouts and navigation, TypeScript type generation from Ruby resources, shadcn UI adaptations, and RSpec/Minitest response testing.

Accelerate Rails development with DHH-style code reviews, architecture analysis, and convention enforcement. Manage git workflow with intelligent commits, branch reviews, and Dependabot safety checks. Build and deploy Dockerized Rails apps via Kamal, create MCP servers, and optimize AI prompts with benchmarking.

Execute read-only queries against Rails 8.2+ app databases via `rails query` CLI, using ActiveRecord or SQL for counts, lookups, aggregates; introspect schemas/models; analyze EXPLAIN plans; paginate results; run locally or remotely via Kamal on deployed environments.

Build 2D games in Ruby using DragonRuby Game Toolkit patterns to implement tick loops, sprite rendering, input handling, collisions, animations, state management, and performance optimization.

Manage project tasks via CLI: add prioritized tasks with blockers/subtasks/tags, time-track with start/stop, list ready ones sorted by priority, complete with guided learnings capture. Record decisions/insights scoped to files, reflect on git changes to extract patterns, promote to docs like CLAUDE.md.

Orchestrate multi-agent development workflows with persistent memory and automated knowledge capture. Manage tasks as beads with specialized agents for code review, design, testing, and research. Automate planning, implementation, review, and shipping with self-healing execution and institutional memory.

Follow sorah's coding guidelines for general code quality, Ruby, Rails, Rust, Terraform, security vulnerabilities, git commits, and Japanese docs while writing or reviewing code. Auto-generate styled git commits and GitHub PRs from changes. Perform security reviews and audits on code diffs, files, or repos via commands and agent.

Implement Linear issues in Rails apps via full TDD workflow: fetch details, set up Git worktrees, develop features with RSpec tests using specialized agents, run parallel security and best-practices code reviews, apply fixes, and create integrated PRs.

Incrementally upgrade Rails config.load_defaults by walking through each new_framework_defaults config, using an uncomment-test-commit workflow to safely align settings across versions.

Upgrade Rails apps from 6.0 to 8.1.1 by generating bash scripts that scan for breaking changes and deprecations across versions, then creating tailored reports with code diffs, config previews, and migration checklists from your app's analysis.

Generate complete MVP documentation for Rails apps from an idea, including competitor research reports, business plans, brand guides, technical architecture diagrams, and Claude setup instructions. Delegate planning for SaaS concepts and projects to streamline startup workflows.

Bootstrap Warp terminal for Rails projects with one command, creating colored tabs for dev server, Claude, shell, console, logs, and jobs to streamline switching between common workflows.

Enforce an opinionated 5-phase development lifecycle (speculate → plan → code → review → ship) with git worktree isolation, TDD-driven commits, CI enforcement, multi-agent code review, and automated issue management — all delegated through local bin/* scripts that work with any language or framework.

Refine Ruby on Rails code to follow 37signals patterns and One Person Framework philosophy, boosting clarity, consistency, and maintainability. Targets recently modified files without altering functionality, enabling solo developers to maintain clean, idiomatic codebases effortlessly.

Socratic-guided Rails development and client consulting: pressure-test assumptions, break features into shippable slices, review code with design/security questioning, write polished client updates with git context, and execute strict TDD workflows.

Generate, fix, and refactor RSpec tests for Ruby on Rails apps using describe/it blocks, expect matchers, test doubles, FactoryBot factories, and TDD best practices. Triggers on spec files or test-related queries to streamline test development workflows.

Audit Rails Gemfile for missing dev gems like strong_migrations, bullet, herb, and letter_opener, then install and configure them automatically—updating Gemfile, running bundle install, executing generators, and providing setup instructions for safer migrations, N+1 detection, ERB linting, and email previews.

Orchestrate multi-agent swarms to automate end-to-end engineering workflows: brainstorm and plan features, implement code in Ruby/Rails/Python/TS/React, conduct parallel reviews and audits, resolve todos/PR comments, run browser tests, record demos, and create PRs with changelogs.

Automates adding and maintaining Ruby type signatures (RBS and Sorbet) in projects, supporting inline annotations, separate .rbs/.rbi files, and auto-detecting the type system for uncommitted Git changes.

Orchestrate an AI agent mesh to auto-detect tech stacks and test frameworks across JavaScript, Python, Ruby, and C# projects; bootstrap dev infrastructure with constitutions, docs, and gitignores; log sessions; optimize context files; scaffold templates; and proactively monitor changes to prevent context drift.

Build interactive terminal user interfaces in Ruby using the RatatuiRuby gem. Manage event loops with RatatuiRuby.run, render widgets including paragraphs, lists, tables, gauges, and charts, handle user events through polling, and run in full-screen or inline viewport modes with testing support.

Web scraping and data extraction across websites using ScraperAPI's MCP, SDK, and CLI interfaces, including async jobs, crawlers, structured data, and integrations with Python, Node.js, Java, PHP, Ruby, and n8n.

Coordinates Rails 8+ development with domain skills for Hotwire, TDD, security, TDD, and modern best practices — scaffolds controllers, models, views, and background jobs while enforcing team conventions and preventing vulnerabilities

Integrate Paymob payment gateway across regions, handling Intention API, Unified Checkout, Pixel SDK, HMAC validation, webhooks, subscriptions, and regional endpoints for Egypt, KSA, UAE, and Oman.

Provision and manage isolated cloud sandboxes on the Daytona platform, providing secure compute environments with dedicated runtimes for Python, TypeScript, Go, and Ruby development.

Conduct exhaustive interactive interviews on spec files to identify ambiguities, gaps, and missing details, iteratively refining them with Ruby/Rails checklists until implementation-ready. Implement features methodically from specs. Validate completed code against specs via git diffs and conventions.

Implement Draper decorators in Rails to separate presentation logic from models and views. Follow guided best practices for structuring decorators, delegating model methods, and using view helpers to keep views clean and maintainable.

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

Record TikTok-style MP4 videos walkthroughing your local dev server UI on ports like 3000/5173/8080, scaffold tiktest.md configs automatically from README/package.json, run checks-only validation passes without rendering, and summarize changes via tik-test CLI.

Build Model Context Protocol (MCP) servers in Ruby using the mcp gem, applying design principles for context preservation, domain vocabulary, tool budgeting, prompts, resources, and security to enable secure AI model integrations.

Enable full LSP code intelligence for Ruby and ERB files in your IDE, powering diagnostics, go-to-definition, reference finding, hover information, and symbol outlines across .rb, .ru, .erb, .rake, and .gemspec files to streamline Ruby development workflows.

Build and optimize Rails models using ActiveRecord patterns: write migrations, define associations like belongs_to, has_many, and through, fix N+1 queries with includes, preload, and eager_load, add validations and callbacks, and enforce database constraints.

Persists long-term memory across Claude Code sessions so it recalls a project's tech stack, architecture, conventions, and past decisions without re-reading files. Automatically ingests project facts, stores episodic observations, and diagnoses memory issues.

Perform structural find, replace, delete, and insert operations on code using AST-aware patterns instead of regex, enabling safe renaming of functions, changing API signatures, or removing logging statements across multiple languages.

Enforce Rails quality gates with linting, tests, and security scans; audit for vulnerabilities like XSS and SQL injection; apply safety checklists to code changes; diagnose root causes of performance and reliability issues; generate scored architectural alternatives; and optimize dev workflows—all via specialized Claude Code skills for the full Rails lifecycle.

Audit Ruby and Rails projects for breaking changes before upgrades, then apply automated fixes, generate phased migration plans, and verify with RSpec and RuboCop.

Streamline Ruby on Rails development by generating scaffolds and code via custom generators, scanning for security vulnerabilities with Brakeman, optimizing PostgreSQL queries for performance, guiding RSpec and Cucumber TDD/BDD workflows, enforcing style and quality with RuboCop RubyCritic and SimpleCov, and reviewing changes against Sandi Metz SOLID principles with actionable reports.

Generate, add inline or standalone Ruby RBS type signatures to codebases, convert between formats, review for correctness and improvements, maintain with Steep validation, and eliminate untyped code to gradually type Ruby projects.

Invoke Claude to run RubyCritic on Ruby and Rails codebases for autonomous quality analysis: receive A-F scores per file, detect smells in complexity/duplication/churn, compare branches, and get prioritized refactoring suggestions.

Automatically detect and fix newly added type ignores (e.g., @ts-ignore, eslint-disable, pylint:disable) across multiple languages by grepping codebases and spawning parallel fixer agents with type check verification, or fix individual file type errors by adding imports, annotations, or declarations.

Automate end-to-end CVE hunting in open source packages: discover under-audited targets, systematically detect 20+ vulnerability classes (injection, auth bypass, XXE, SSRF, etc.), build proof-of-concept exploits, eliminate false positives, and generate professional disclosure reports for submission to HackerOne or GitHub Security Advisories.

Audit dependencies across npm, pip, Cargo, Bundler, and Go: scan for vulnerabilities, review lockfiles, compare package alternatives, evaluate trustworthiness, and manage supply chain security risks.

Transform vague feature ideas into validated standalone task beads for multi-agent execution using a 6-stage planning pipeline: clarify requirements, research codebase, generate plans, cross-model reviews, synthesize finals, and validate beads with TDD enforcement, simplicity checks, and self-improvement.

Automate iterative PR review and autofix loops: review code changes, fix issues above a criticality threshold using auto-detected test/lint commands, and repeat until clean. Supports Ruby, Node, Python, Go, and Rust.

Automate end-to-end GitHub product development workflows: create PRDs and break them into estimated epics/tasks, execute TDD on tasks with PRs, generate and run QA tests via Playwright, review code, resolve merge conflicts, monitor CI failures, and produce changelogs.

Automate DevOps workflows by creating and optimizing GitHub Actions CI/CD pipelines for Ruby/Rails and TypeScript/Node.js projects with deployments to Heroku or Fly.io, deploy containerized web apps to Linux servers using Kamal for zero-downtime rollbacks and multi-env setups, and configure Tailscale VPN networks including subnet routers, ACLs, and API automation.

Validate project documentation quality by linting Markdown formatting and naming, checking broken and orphan links, verifying glossary terms and synonyms, detecting contradictions and gaps, and auditing completeness. Apply interactive fixes, run in batch mode, and generate Mermaid graphs for reviews via skills and commands.

Fetch and manage Bugsnag organizations, projects, errors, events, comments, and stats; analyze error trends; resolve errors and add comments directly using integrated Ruby API scripts.

Securely install, scan, audit, and monitor packages across 14 ecosystems (npm, yarn, pnpm, bun, pip, uv, poetry, cargo, go, gem, composer, nuget, hex, pub) with CVE detection via OSV.dev, auto-fixes, severity triage, dependency audits, and continuous email alerts using INFYNON CLI and agent.

Bootstrap consistent developer environments in minutes by analyzing project files to detect tech stacks, languages, and dependencies, then auto-generate Docker/docker-compose configs, .env templates, pre-commit hooks, VSCode/Cursor settings, and troubleshoot setup issues for instant productivity.