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.

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.

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.

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.

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.

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.

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.

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.

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.

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 with Gherkin syntax, using best practices for declarative scenarios, independent tests, and step definitions in JavaScript, TypeScript, Java, or Ruby.

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.

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.

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.

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

Enforce Ruby code quality with RuboCop: configure YAML rules, apply built-in and custom cops with auto-correction, and integrate linting into CI pipelines using GitHub Actions.

Write, review, and improve Ruby test suites using RSpec's describe/context/it blocks, matchers, custom matchers, shared examples, metadata, hooks, and mocking with doubles, stubs, spies, and partial strategies.

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.

Deploy, debug, monitor, and migrate applications on Render cloud platform. Automatically generate Blueprint YAML from codebases, troubleshoot deployment failures, provision databases and workers, and migrate Heroku apps—all with deep integration for diagnostics and infrastructure as code.

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.

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.

Progress through 12 D&D-themed levels guided by a dungeon-master agent to master Claude Code: configure .claude/ settings/rules/hooks, create slash commands/agents/skills, build portable plugins, track quest status with /progress and /verify CLI.

Orchestrate Claude Code sessions as Kanban boards — decompose plans into prioritized tasks, assign agent roles, run end-to-end verification across browsers, CLIs, databases, HTTP services, and libraries, then snapshot and diff state to confirm correctness.

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.

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.

Enhance Claude Code with Rails code reviews following DHH conventions, automated git commits, gem upgrade analysis, and AI skill creation tools. Includes hooks to block destructive git actions and hardcoded secrets.

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

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.

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.

Automate iOS and macOS app CI/CD pipelines with Fastlane: install and configure Fastfiles for testing, beta releases to TestFlight, App Store submissions, code signing via Match, and screenshot generation via Snapshot.

Manage compound engineering projects with structured beads for planning, research, implementation, and shipping, orchestrated by multi-agent workflows with persistent knowledge memory that automatically captures and recalls lessons across sessions.

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 inside Claude Code, from issue decomposition through planning, TDD execution, parallel code review, and PR merge, with state persistence and autonomous overnight batch processing.

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.

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.

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.

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

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.

Automates end-to-end CVE hunting in open source packages: discovers under-audited targets, audits code for 20+ vulnerability classes, builds proof-of-concept exploits, eliminates false positives through multi-gate verification, and generates professional disclosure reports.

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.

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.

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

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

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

Retains and recalls project knowledge (tech stack, architecture, conventions, decisions) across Claude Code sessions, so you never repeat context setup and Claude explains unfamiliar codebases without file traversal.

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.

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, generate phased upgrade roadmaps, and apply automated fixes with RSpec and RuboCop verification.

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.

Audit AI-assisted development workflows to measure feedback loop maturity, then generate and enforce typed lint rules from PR review patterns using CLAUDE.md spec files.

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.

Find and fix newly added type ignores (ts-ignore, eslint-disable, pylint:disable) across multiple languages by automatically resolving the underlying type errors with imports, annotations, or declarations.

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.

Manage self-amending knowledge layers (L0/L1/L2) with blockchain-backed auditability, enabling skills to evolve, promote, and audit themselves via MCP tools. Also triggers async workflows when Claude creates task comments in ClickUp.

Automates iterative PR reviews with an autofix loop: analyzes git diffs, runs reviews, and automatically fixes issues above a criticality threshold until clean — supporting Ruby, Node, Python, Go, and Rust projects.

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.

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.