Model or dataset
ThibautBaissac/rails_ai_agents avatar
ThibautBaissac/rails_ai_agents

Nineteen Rails agents, one copy command, and two packs to choose from

Specialized AI skills, agents, rules and hooks for modern Rails AI driven-development + Spec-Driven-Development kit + MCP

674 stars83 forksShellMIT

At a glance

What is it?
rails_ai_agents is a drop-in Claude Code setup for Ruby on Rails projects, shipping 19 specialist agents, 26 slash commands, 18 skills, 14 rules, an Sentry MCP and 6 lifecycle hooks, where each agent declares a domain and a model, the 37signals pack replaces rather than supplements the default one, and Codex support depends on copy scripts because skill discovery is unreliable with symlinks.
Who is it for?
It fits a Rails team that already uses an AI coding assistant and wants conventions encoded rather than repeated in prompts, since the value here is a documented division of labour between nineteen narrow agents rather than any single clever prompt. Three things to check first.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 167 days ago.
What is it written in?
Mainly Shell, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • ThibautBaissac/rails_ai_agents674 ★ · +12
Star history
Repository2026-09-112026-11-15
ThibautBaissac/rails_ai_agents662674

12 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Three of the nineteen agents run on the cheaper model

The agents are the substance of the package, and they are narrower than the headline suggests.

Each one declares a domain and a model, and the domains follow the Rails object graph: models with validations, associations and scopes; thin RESTful controllers with strong parameters; service objects with a Result pattern; Pundit policies; multi-model forms; complex queries and N+1 prevention; presenters built on a delegator wrapper; view components; background jobs on Solid Queue; mailers with previews; Turbo Frames, Streams and Drive; Stimulus controllers; Tailwind styling; RSpec tests; RuboCop linting; and PostgreSQL schema and query review.

Two agents are about the workflow rather than the framework. One orchestrates the green phase of TDD in an isolated worktree, and another handles the refactor phase.

The model column is the part with a signal in it. Sixteen agents run on the middle-tier model, and two run on the cheaper one: the migration agent, which writes reversible database migrations, and the lint agent, which runs RuboCop and auto-corrects. No agent in the table is assigned the top tier, which is a defensible split. Formatting a file correctly does not need the most expensive model, and migrations do not either.

Every agent shares the same four settings: edits are accepted automatically, memory is project-scoped, turns are capped, and each carries a description of when it should and should not be invoked, which is what lets the assistant delegate without being asked.

You copy one directory, and the two packs are alternatives

Installation is a copy, which makes the package choices the whole decision.

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

The default directory carries a layered architecture stack with RSpec, Pundit and PostgreSQL. The alternative is a 37signals-flavoured directory, described as a conventions pack for teams that prefer rich models, concerns and Minitest, and it replaces the default rather than extending it.

That word matters. It is documented as instead of, so copying both gives an assistant two contradictory answers about how to write a test and how to shape a model. There is no merge tool and no compatibility shim, because the two packs are genuinely different opinions about Rails.

Three more directories are optional and additive. A specification directory adds the spec-driven commands, which are namespaced separately from the ordinary ones. A statusline directory is a separate concern. An MCP directory holds the Sentry monitor, which is the single MCP in the package and the only piece that talks to a running production system.

So the practical sequence is: pick one pack, then add the specification directory only if you intend to work spec-first.

The commands are interviews, not prompts

The standalone command set is seven commands, and the pattern is that most of them ask you questions before doing anything.

A feature spec command runs a structured interview and produces a complete spec with Gherkin scenarios. A review command then scores that spec, identifies gaps and generates the missing scenarios. A planning command converts the spec into a TDD implementation plan with a pull request breakdown, and an implementation command guides the red, green, refactor cycle.

The last three are about the conversation rather than the code. One reframes a vague request into a clear problem. One scores and rewrites a vague prompt into a specific, actionable one. One produces a welcome-back report on a feature branch covering commits, authors, themes and risks since your last contribution, which is the kind of thing you want after two days away from a branch.

That last command is the most Rails-specific of the seven, because it presumes branches carry multiple authors and that a returning developer has lost the thread.

So the workflow the commands encode is spec, review the spec, plan the work, implement it, and catch up when you return. Gherkin scenarios as the spec format is the load-bearing choice, since it gives the review command something mechanical to score.

A Sentry fix happens on its own branch

The Sentry command set is the part of the package that touches production, and it is built around isolation.

Five commands. One checks for new production errors and proposes fixes. One launches a background agent in an isolated worktree to fix a specific error. One lists all active fix branches with their status. One generates a markdown summary of error status for standups or pull requests. One resolves, ignores or reopens an issue after a fix has been deployed.

The workflow is legible from those five. An error becomes a branch, a branch becomes a pull request, and the issue is closed only after the change is live. Status is queryable at any point, so two engineers do not fix the same error.

The worktree isolation is the same mechanism the TDD implementation agent uses, which tells you it is a deliberate pattern rather than a one-off: the assistant modifies files in a place the developer is not currently working.

The deployment step is where a human stays in the loop. Nothing in the set describes pushing to production; the resolve command is for after a fix has been deployed, by someone else or by a pipeline.

And the report command is aimed at standups, which is a small detail that tells you this was written for a team that runs them.

Two skill kinds: tasks you call and knowledge that loads

The eighteen skills split into two patterns, and the split is the thing to understand before using them.

Task skills are user-invocable workflows. Knowledge skills are auto-loaded conventions, which means they apply whether or not you ask.

Among the tasks: a read-only code review covering SOLID analysis, N+1 detection and anti-patterns; a security audit of the OWASP top ten using Brakeman; an accessibility audit against WCAG 2.2 AA using axe-core, Lighthouse and Pa11y, with progressive-disclosure references for ARIA patterns and Rails snippets; a review that asks a different assistant, the OpenAI Codex CLI, for an independent second opinion on a plan, a diff or a spec; and a review of dependency upgrade pull requests for breaking changes and whether they are safe to merge.

Among the knowledge skills: guidelines aimed at reducing common coding mistakes made by language models, layered architecture decisions, PostgreSQL query and schema patterns, the Rails 8 built-in authentication flow, caching strategies broken down by fragment, Russian doll and low-level, and performance work starting from N+1 queries.

Three of the skills are assigned the top-tier model: the security audit, the accessibility audit and the architecture decisions. The pattern is consistent with the agent table. Cheap deterministic work goes to a cheaper model, judgement calls about whether code is secure or accessible go to the best one.

The Codex second-opinion skill is the most interesting, because it turns one assistant into a critic of another.

Codex and Copilot get copies, not links

Supporting two more assistants sounds like a documentation exercise and turns out to be a build problem.

The layout is explicit about which file is canonical. A shared high-level instruction file sits at the project root for tools that read it. A mirrored skills directory exists for Codex and is also reusable from Copilot, while the Claude skills directory remains the source of truth. A Copilot entrypoint sits under the GitHub directory, and a set of generated path-scoped bridge files point back at the Claude rules.

Those bridge files are generated. Which means the multi-tool support is a copy pipeline, and there is a reason for it: Codex skill discovery is described as unreliable with symlinks.

So two scripts do the work:

bash
scripts/sync_claude_skills_to_codex.sh
scripts/sync_claude_rules_to_copilot.sh

And the operational rule that follows is the part people miss. Run them after adding, removing or renaming any skill or rule, and if Codex or Copilot is already running, restart or reload the chat session to pick up the changes.

That is a manual step with two parts, and it is the price of supporting three assistants from one source. Nothing detects the drift for you, and a renamed rule that was never synced is a rule that silently stopped applying in one tool while still applying in another.

Fourteen rules, one of which exists to spend fewer tokens

The rules are the smallest layer and the most easily overlooked, and their scope is split.

Fourteen in total: eleven scoped to paths and three always on. A path-scoped rule applies when the assistant is working on files matching a pattern, so a rule about ActiveRecord applies to model files and not to a mailer.

That mechanism is the same one the multi-tool bridge files exploit, which suggests path scoping is the load-bearing idea in this repository rather than the agents.

One rule deserves naming on its own. A caveman rule exists with a full intensity level, and its stated purpose is token reduction. It is unusual to see a rule in a package like this whose goal is to make the assistant say less, and it points at a cost concern the other layers do not address: nineteen agents and eighteen skills are only affordable if the output is compact.

The recent changes point the same way. Alongside the token-reduction rule, there are commands for producing plan, review and pull request artifacts, and a tmux session launcher script for Rails development, which is a workflow convenience rather than an AI feature.

The repository also carries a Claude Code extensibility guide, which is the piece to read if you plan to write your own agent rather than use one of the nineteen.

Editorial conclusion

It fits a Rails team that already uses an AI coding assistant and wants conventions encoded rather than repeated in prompts, since the value here is a documented division of labour between nineteen narrow agents rather than any single clever prompt. Three things to check first. You copy one directory, and the two convention packs are alternatives, so copying both gives you contradictory instructions about testing frameworks. If you use Codex or Copilot you must run two sync scripts after every skill or rule change, because the mirror is a copy and not a link. And nothing is versioned: there are no releases, and the last push is dated 1 June 2026, so pin a commit rather than tracking the branch.

Frequently asked questions

What is ThibautBaissac/rails_ai_agents?

It is an MIT-licensed, drop-in Claude Code setup for Ruby on Rails projects. It ships 19 specialist agents, 26 slash commands, 18 skills, 14 rules split into path-scoped and always-on, one Sentry MCP integration and 6 lifecycle hooks, plus a spec-driven development kit and a separate 37signals-style conventions pack.

How do I install rails_ai_agents into a Rails app?

Copy the .claude/ directory into your Rails project. There are two convention packs and they are alternatives: the default layered setup with RSpec, Pundit and PostgreSQL, and a 37signals-style pack with rich models, concerns and Minitest that replaces it. The .specify/ directory is optional and adds the spec-driven commands, while statusline/ and mcp/sentry_monitor/ are separate optional pieces.

Which AI models do the Rails agents use?

Sixteen agents run on the middle-tier model and two run on the cheaper one, the migration agent for reversible database migrations and the lint agent for RuboCop auto-correction. No agent is assigned the top tier. Among the skills, the security audit, the accessibility audit and the architecture decisions are the ones that run on the top tier.

How does rails_ai_agents support Codex and Copilot?

With copies rather than symlinks, because Codex skill discovery is unreliable with symlinks. The Claude skills directory stays canonical, a mirrored directory serves Codex and Copilot, and generated bridge files point back at the Claude rules. Two sync scripts copy skills and rules across, and they must be re-run after adding, removing or renaming anything, followed by reloading the chat session.

How do the Sentry commands in rails_ai_agents work?

Five commands: one checks for new production errors and proposes fixes, one launches a background agent in an isolated worktree to fix an error, one lists active fix branches with their status, one produces a markdown summary for standups or pull requests, and one resolves, ignores or reopens an issue after a fix is deployed. Nothing in the set deploys to production.

Official sources

  1. Issues
  2. License: MIT
  3. Project website
  4. README
  5. ThibautBaissac/rails_ai_agents on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/thibautbaissac-rails-ai-agents.svg)](https://hysenlabs.com/projects/thibautbaissac-rails-ai-agents)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/thibautbaissac-rails-ai-agents.svg)](https://hysenlabs.com/projects/thibautbaissac-rails-ai-agents)

Was this useful?