Rails AI Agents: A Claude Code Configuration Pack for Ruby on Rails

A Configuration Pack for Claude Code on Ruby on Rails

Rails AI Agents solves a specific problem for Rails developers using Claude Code: the default AI assistant knows general programming conventions but not the precise opinions a Rails team needs, such as thin controllers with strong params, service objects using the Result pattern, or Pundit authorization policies. This pack installs that domain knowledge directly into the AI assistant's configuration.

The repository is organized around a single .claude/ directory containing agents, commands, skills, rules, hooks, and a Makefile. The target user is a Rails developer already running Claude Code who wants to stop writing repetitive context into prompts and instead let agents with dedicated scope handle model work, controller refactoring, spec writing, or database query optimization.

The pack also ships a separate .claude_37signals/ directory for teams following the 37signals development style: rich models, concerns, and Minitest instead of the default layered architecture with RSpec.

Nineteen Specialist Agents and Their Dispatch Rules

Each of the 19 agents in .claude/agents/ covers a distinct area of the Rails stack. model-agent handles ActiveRecord models, validations, associations, and scopes. controller-agent focuses on thin RESTful controllers and Pundit authorization. service-agent writes service objects using the Result pattern and SOLID principles. migration-agent produces safe, reversible database migrations. query-agent addresses complex queries and N+1 prevention. rspec-agent writes RSpec tests. database-reviewer handles PostgreSQL query optimization, schema design, and performance analysis.

Each agent definition includes permissionMode: acceptEdits, memory: project, a maxTurns limit, and WHEN/WHEN NOT descriptions for automatic delegation. The model assignment also varies: migration-agent and lint-agent run on haiku for cost efficiency, while most specialist agents run on sonnet.

The implementation-agent and tdd-refactoring-agent split the TDD RED-GREEN-REFACTOR cycle between them. implementation-agent handles the GREEN phase using worktree isolation, and tdd-refactoring-agent takes over for the REFACTOR phase.

Installing the Pack and Choosing Between Configuration Styles

For most projects, installation is a single copy operation. The README gives this command for the default setup:

cp -r .claude/ /path/to/your-rails-app/.claude/

To use the 37signals-style conventions pack instead of the default:

cp -r .claude_37signals/ /path/to/your-rails-app/.claude/

The Spec-Driven Development commands ship separately in a .specify/ directory and are optional. Copy it in addition to whichever .claude* directory you chose if you want the /sdd:* and /sdd-change:* commands.

For teams that also use OpenAI Codex or GitHub Copilot, the repository includes sync scripts. After adding, removing, or renaming any skill or rule, run the relevant script to keep the mirrored directories current:

scripts/sync_claude_skills_to_codex.sh
scripts/sync_claude_rules_to_copilot.sh

The README notes that Codex skill discovery is currently unreliable with symlinks, which is why the sync scripts copy real files rather than using symbolic links. After running either script, restart or reload the chat session to pick up the updates.

The SDD Kit: From Feature Specification to TDD Implementation

The Spec-Driven Development kit adds seven standalone slash commands and two SDD namespaces. The standalone commands cover the full specification-to-implementation pipeline: /feature-spec runs a structured interview to produce a complete spec with Gherkin scenarios, /feature-spec-review scores specs and identifies gaps, /feature-plan converts a spec into a TDD implementation plan with PR breakdown, and /feature-tdd-implementation guides the full Red-Green-Refactor workflow.

The kit also ships /sdd:* and /sdd-change:* namespace commands for standard feature work and for bug fixes requiring lighter specification. These live in .specify/ and are not part of the default .claude/ directory, so they must be copied separately.

The Sentry integration adds five commands in .claude/commands/sentry/: /sentry:monitor checks for new production errors, /sentry:fix-error launches a background agent in an isolated worktree to fix a Sentry issue, and /sentry:report generates a markdown summary for standups or pull request descriptions. These require the Sentry MCP server from mcp/sentry_monitor/ to be configured.

What the Pack Assumes and When GitHub Copilot Is a Better Fit

The default configuration assumes a specific stack: layered architecture, RSpec, Pundit, and PostgreSQL. A project using Minitest, no authorization layer, or a non-Postgres database will find that several agents and rules reference conventions that do not match. The 37signals-style pack is the documented alternative for different conventions, but it is currently a conventions-only pack: it provides instructions, agents, skills, and rules, but the full slash-command set documented in the README lives under .claude/commands/, not under .claude_37signals/.

GitHub Copilot is a widely used alternative for AI-assisted code work in Rails. Copilot operates as inline code completion and a chat assistant without the specialist agent architecture, slash commands, or SDD workflow that this pack provides. Teams already committed to Copilot can import a subset of the configuration via the .github/copilot-instructions.md file and the generated path-scoped bridge files in .github/instructions/claude-rules/, but the full agent delegation model requires Claude Code.

There are no runtime dependencies. The pack adds no gems to your Gemfile and executes no code. A team that switches away from Claude Code loses access to every agent, command, and hook in the pack.

Maintenance Status, License, and Upgrade Path

The last push to the repository was on 2026-06-01. The repository is not archived. The license is MIT.

The repository has no published GitHub releases. There is no version number to pin to, and no changelog per release. Teams adopting this pack take a snapshot of the .claude/ directory and own the update process themselves. When new agents or commands appear in the upstream repository, the update path is a manual re-copy or a diff review.

The 19 agent count, 26 command count, 18 skill count, 14 rule count, 1 MCP, and 6 hooks listed in the README reflect the current state of the repository at the last push date. These numbers will shift as the project evolves.

Because the pack has no versioned releases, a team running it for several months may diverge from the upstream repository without realizing it. The README documents a Latest Updates section with recent additions (the caveman rule, plan and review artifact commands, a tmux session launcher script), but there is no automated mechanism to notify a team that new items have been added upstream.

Editorial conclusion

Rails AI Agents is worth adopting for any team that uses Claude Code for active Rails development and wants expert-level specialization without writing their own agent instructions. Teams that use GitHub Copilot, Codex, or another assistant as their primary tool can still use the mirrored .agents/ and .github/ directories, but they get a subset of the full pack. Before installing, check that the default setup matches your stack: it assumes RSpec, Pundit, and PostgreSQL, and the 37signals-style pack is a conventions-only alternative that does not yet include the full slash-command set.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. Project website
4. README
5. ThibautBaissac/rails_ai_agents on GitHub