The name
“Rails Way App” was descriptive but flat. “Rails Whey App” carries the same phonetic identity, and now it embodies what the project argues.
Whey protein is the simplest, most fundamental building block for strength. No exotic stacks, no over-engineered formulas: just the essential nutrient, applied with discipline. That is exactly what this project does with Rails. Controllers, models, concerns, callbacks: the framework's own building blocks, taken seriously.
The problem
People reach for service objects, interactors and hexagonal architecture not because Rails is weak, but because their Rails code tastes bad.
- Fat controllers with no structure.
- Tangled callbacks nobody dares touch.
- God models that pile up responsibilities until they collapse under their own weight.
That is unflavored whey. Technically nutritious, practically unbearable.
When code tastes bad, developers look for an escape. They bolt on architectural layers from other paradigms, layers that manage complexity instead of eliminating it. They treat Rails as something to contain rather than something to use well.
The problem is real.The diagnosis is wrong.
The answer is not to switch supplements. The answer is to make the fundamentals taste good.
What taste means
Good taste in code is not aesthetics. It is not formatting, naming conventions, or how many blank lines you leave between methods.
Good taste is the ability to see the essential shape of a problem so clearly that accidental complexity dissolves. It is finding the representation where special cases disappear, not through cleverness but through clarity.
This project exists to prove that taste operates within Rails, not outside it.
There is a design gradient within the framework that most developers never explore: from the default scaffold to a fully articulated domain model, each point a deliberate, defensible choice. No gems required. No external architecture imported. Just the framework's own patterns, seen clearly and applied with discipline.
Complete overview. The numbers below identify the families.
Each bar is a branch. Color and height show order, not a quality score.
Explore branches by family
Family 1: controller architecture
Family 2: controller architecture
Family 3: domain structure
Family 4: entry point separation
Family 5: model authority
Family 6: domain naming
Family 7: bounded contexts & isolation
The goal is not to prescribe the “right” architecture. It is to show that the gradient exists, that every point on it is valid, and that the freedom to move along it is what good design actually looks like.
The Rails Way has more room in it than most people think.
Why now
AI commoditizes code generation. Anyone can produce code, and the volume is exploding. What is not exploding is the ability to judge it.
The scarce resource is taste.
This project shows not just what to build with Rails, but how to choose. How to look at the framework's tools, see them clearly, and reach for the simplest mechanism that fits. That judgment is what developers need more than ever, and what no tool can replace.
It applies to AI coding agents too. A well-structured Rails application is not just easier for people to read. It is cheaper, faster and more accurate for agents to process. The clarity that makes code inviting for a developer makes it legible for a machine.
10/25 24/25 Measured on the same app, with the same tests: 10/25 for agents in 1A-fat-controller, 24/25 in 6G-named-orchestrations. Read the report
The shape of the proof
This project does not assert its thesis. It demonstrates it, across a series of branches, each built on the last, each measured against the same behavioral test suite.
- At every stage, the tests pass.
- At every stage, code quality is measured with a verifiable number.
- At every stage, the tradeoffs are named honestly.
The individual branches are not the argument. The arc is. A reader who finishes one branch has seen a clean refactor. A reader who traces the whole arc has seen proof that MVC scales.
Every branch README ties its outcome back to the principles in the Constitution.
The branch is the evidence.The principle is the claim.