playbooks

home / skills / steveclarke / dotfiles / real-world-rails

real-world-rails skill

/ai/skills/real-world-rails

This skill researches how production Rails apps solve architectural problems by examining real code patterns from the Real World Rails repository.

npx playbooks add skill steveclarke/dotfiles --skill real-world-rails

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
1.5 KB
---
name: real-world-rails
description: Research how production Rails apps solve architectural problems using the Real World Rails repository. Use when the user wants to know how other apps handle something, find patterns, or compare approaches. Triggers on "rails patterns", "how do other apps", "real world rails", "research how apps do".
---

# Rails Pattern Research

## What This Is

The **Real World Rails** repository is a collection of 200+ production Rails
application source code. The `apps/` directory contains the full source of
each app — models, migrations, schema, controllers, views, concerns, gems.
The `engines/` directory contains Rails engines.

## Locating the Repository

Look for a directory called `real-world-rails` with an `apps/` subdirectory.
Check the current working directory first, then `~/src/real-world-rails`. If
not found, ask the user where it lives.

## What To Do

The user gives you a topic. Spin up parallel agents to search the apps for
how real codebases implement that pattern. Read actual code — models,
schemas, migrations, associations, validations, query patterns — not just
file names. Synthesize what you find into a clear analysis.

If the user's wording suggests they want help choosing a pattern for their
current project (words like "compare for us", "which fits best",
"adversarial", "debate", "evaluate for our project"), also spin up adversarial
agents that each argue for a different pattern in the context of the current
project's architecture and goals.

Overview

This skill researches how production Ruby on Rails applications solve architectural problems by inspecting a large collection of real app source code. It helps you find patterns, compare approaches, and synthesize concrete examples from real projects so you can make informed design choices for your own app. Use it when you want practical, code-level evidence of how teams implement features and structure Rails apps.

How this skill works

Given a topic you provide, the skill searches the available apps directory for relevant code: models, migrations, controllers, concerns, and config. It reads actual implementations and extracts common approaches, trade-offs, and representative snippets. When asked to choose among patterns for your project, it can spawn adversarial analyses that argue for competing options in your specific context.

When to use it

  • You want concrete examples of how mature apps implement a Rails pattern (e.g., authorization, background jobs, tenancy).
  • You need to compare multiple real-world approaches before deciding on a design.
  • You’re troubleshooting how to scale or refactor a Rails feature and want proven patterns.
  • You want code-level evidence (migrations, associations, queries) rather than high-level descriptions.
  • You need an adversarial comparison of competing patterns tailored to your project.

Best practices

  • Provide a clear, focused topic (feature, pattern, or component) to get targeted results.
  • Indicate relevant constraints for your project (DB, scale, multi-tenant needs, team size).
  • Request examples from specific high-profile apps if you want inspiration from certain domains.
  • Ask for both synthesis and concrete file references so you can inspect the original code.
  • Use adversarial analyses only when you want a direct, comparative recommendation for your project.

Example use cases

  • Compare approaches to multi-tenancy (schema vs. row-level vs. separate DB) used by real apps.
  • Find how production apps structure background job flows and error handling for retries.
  • Discover common database indexing and migration strategies for large Rails schemas.
  • See how apps implement authorization patterns (Pundit, CanCanCan, custom policies) in practice.
  • Evaluate strategies for file uploads, CDN integration, and background processing from real projects.

FAQ

Where does this skill look for examples?

It inspects a local collection of production Rails app source trees (models, controllers, migrations, etc.). If the collection isn’t found locally, it will ask where the files live.

Can it recommend a single best pattern for my app?

Yes—when you provide project constraints the skill synthesizes trade-offs and can recommend the best fit. For contentious choices it can produce adversarial arguments for multiple options.