Rails is opinionated software, and that opinion comes from creator David Heinemeier Hansson (DHH) and the Rails core team. Understanding Rails philosophy is essential to working effectively with the framework. Rails 8 doubles down on these principles while introducing new ones that reflect modern web development realities.
This skill inherits all available tools. When active, it can use any tool Claude has access to.
examples/convention-over-configuration.rbreferences/core-principles.mdreferences/majestic-monolith.mdreferences/no-build.mdreferences/solid-suite.mdRails is opinionated software, and that opinion comes from creator David Heinemeier Hansson (DHH) and the Rails core team. Understanding Rails philosophy is essential to working effectively with the framework. Rails 8 doubles down on these principles while introducing new ones that reflect modern web development realities.
Rails is designed to make programming web applications easier by making assumptions about what every developer needs to get started. It allows writing less code while accomplishing more than many other languages and frameworks. Experienced Rails developers report that it makes web application development more fun.
The framework makes the assumption that there is a "best" way to do things, and it's designed to encourage that way—and in some cases to discourage alternatives. If you learn "The Rails Way," you'll discover a tremendous increase in productivity. If you persist in bringing old habits from other languages to Rails development, and trying to use patterns learned elsewhere, you may have a less happy experience.
DRY is a principle of software development stating that "Every piece of knowledge must have a single, unambiguous, authoritative representation within a system." By not writing the same information over and over again, code is more maintainable, more extensible, and less buggy.
In practice, DRY means:
Rails has opinions about the best way to do many things in a web application, and defaults to this set of conventions rather than requiring endless configuration files.
Key conventions:
user_id, created_at)index, show, new, create, edit, update, destroy)This means a Product model automatically:
products tableProductsController for web requestsapp/views/products/resources :productsNo configuration files needed—it just works.
Omakase (Japanese for "I'll leave it up to you") means trusting the chef to serve what's best. Rails is omakase software. DHH and the Rails team curate a full-stack experience with carefully chosen defaults.
This means:
Fight this and you'll struggle. Embrace it and you'll fly.
Rails prioritizes developer joy and productivity over other concerns. This manifests in:
Code should be a joy to write and maintain. If it's painful, Rails wants to fix it.
Rails values code aesthetics. Beautiful code is:
This isn't vanity—beautiful code is easier to understand, modify, and debug.
Rails gives you powerful tools and trusts you to use them responsibly. It doesn't infantilize developers with excessive safety rails.
Examples:
find_by_sql)eval and metaprogramming availableWith power comes responsibility. Rails assumes you're a professional.
Rails champions the integrated monolith over distributed microservices for most applications. Benefits:
Microservices have their place, but most applications don't need that complexity. Start with a monolith, extract services only when truly necessary.
See references/majestic-monolith.md for detailed discussion.
Rails values moving forward over maintaining perfect backward compatibility. But this doesn't mean breaking changes without reason:
Rails 8 removed deprecated features from Rails 7, ensuring the codebase stays clean and modern.
Business logic belongs in models, not controllers. Controllers should:
They should not:
Models encapsulate domain logic. Controllers coordinate HTTP concerns.
Rails empowers small teams to build big things. A single developer can:
This doesn't mean you must work alone—it means you can if you want to.
Rails 8 introduces new philosophical directions while maintaining core principles.
Rails 8 eliminates complex JavaScript build toolchains for most applications. No webpack, no esbuild, no complex configurations.
Instead:
Build tools add complexity, slow development, and break frequently. Modern browsers support ES modules natively. Most apps don't need a build step.
See references/no-build.md for implementation details.
Rails 8 replaces external dependencies with database-backed solutions:
Benefits:
FOR UPDATE SKIP LOCKED)This is the integrated systems philosophy applied to infrastructure.
See references/solid-suite.md for technical details.
Rails 8 includes Kamal 2 for zero-downtime deployments to any Linux server. No PaaS lock-in, no Kubernetes complexity.
Philosophy:
kamal deploy)This embodies self-sufficiency and simplicity.
See references/kamal-philosophy.md for deployment approach.
Rails 8 includes a session-based authentication generator—but not authorization (roles, permissions).
Philosophy:
The generator creates:
You customize from there.
Rails 8's Dockerfile includes Thruster, a Rust-based proxy that:
Philosophy: Production should be fast by default, without complex reverse proxy setup.
With conventions, you don't decide:
You follow the convention and move on to actual problems.
Running rails generate scaffold Product name:string price:decimal creates:
Everything follows conventions. You customize what you need, delete what you don't.
Rails is opinionated and integrated. You work within its structure, not alongside it. This trade-off gives:
You sacrifice some flexibility for massive productivity gains.
While conventions dominate, Rails is configurable when necessary:
config/application.rb for app-wide settingsconfig/routes.rb for custom routingconfig/database.yml for database configConvention first, configuration when needed.
Q: Why not microservices?
A: Most apps don't have the scale or team size that justifies microservices complexity. Start with a monolith, extract services only when truly necessary. See references/majestic-monolith.md.
Q: Why not TypeScript?
A: TypeScript adds build complexity and ceremony. Ruby is dynamically typed and that's intentional. Tests provide safety. See references/no-build.md.
Q: Why include so much in the framework?
A: Integration is a feature. Curated defaults reduce decision fatigue. Everything works together smoothly. See references/integrated-systems.md.
Q: Why the strong opinions? A: Opinions enable conventions. Conventions eliminate configuration. Less configuration means more time solving actual problems.
Q: What if I disagree with Rails opinions? A: You can configure around them, but you'll fight the framework. Better to find a framework aligned with your preferences or embrace "The Rails Way."
Rails 8's major features demonstrate philosophy in practice:
Kamal 2: Deploy anywhere simply (self-sufficiency, simplicity) Thruster: Fast by default (performance without complexity) Solid Cache/Queue/Cable: Database-backed infrastructure (integrated systems) Propshaft: No build needed (NO BUILD, simplicity) Authentication Generator: Code over frameworks (sharp knives, pragmatism) Local CI: Run tests locally (developer productivity, fast feedback) Markdown Rendering: Modern needs met simply (pragmatic evolution)
Every feature reflects philosophical principles.
To work effectively with Rails:
Rails optimizes for building and shipping. Let it.
For deeper exploration of Rails philosophy:
references/core-principles.md: Detailed examination of DRY and Convention over Configurationreferences/majestic-monolith.md: Why monoliths beat microservices for most appsreferences/no-build.md: Rails 8's NO BUILD philosophy and implementationreferences/solid-suite.md: Database-backed infrastructure (Solid Cache/Queue/Cable)references/integrated-systems.md: The value of integration over distributionreferences/kamal-philosophy.md: Deployment philosophy and Kamal 2For code examples demonstrating principles:
examples/convention-over-configuration.rb: How conventions eliminate codeexamples/dry-in-practice.rb: DRY principle in actionexamples/fat-models-skinny-controllers.rb: Proper logic placementRails philosophy is about:
These aren't arbitrary opinions—they're battle-tested principles from building thousands of successful applications.
Embrace the philosophy, trust the framework, and ship amazing software.