Rails-Like Productivity in Next.js: Conventions That Ship

Next.js gives you Legos. Rails gave you a house.

A Rails developer in 2005 famously built a blog in 15 minutes on stage.

Not because Rails developers type faster.

Because Rails had already decided everything.

Models here.

Controllers there.

Migrations this shape.

Tests in that folder.

The demo took 15 minutes because a thousand decisions were pre-made.

Next.js hands you the opposite. Magnificent Legos. Zero blueprint.

Every project re-decides folder structure, data layer, auth shape, billing flow and deploy target.

Senior teams encode the answers in lore.

Solo founders re-decide weekly.

AI agents invent fresh architecture per session.

What developers envy in Rails was never the language. It was convention over configuration.

And conventions can be written down.

Rails in 2005, Next.js by default

Undecided stacks are slower than they feel. Three reasons.

Decisions compound into dialects. Six choices per feature across fifty features is a private dialect only you speak. Onboarding, human or agent, starts with archaeology.

Agents amplify indecision. A human re-decides occasionally. An agent re-decides every session. Four mailers, three auth helpers, two database clients. Unopinionated stacks plus tireless agents produce divergence at machine speed.

Reversible decisions still cost. "We can change it later" is true and irrelevant. Later costs a migration with live data. Deciding upfront costs one line in a file.

Productivity is decisions you never make. Write them down once and Next.js out-ships the nostalgia.

What to do

Decide everything in one conventions file.

A one-page contract that says where each kind of thing goes and what shape it takes: a new entity, a new endpoint, a new UI piece, a new setting.

No new top-level folders without updating the file. No debates in PRs, because the file debated once, forever.

It is the Rails routes file's energy applied to the whole stack.

Make the big choices switchable.

Rails had one database answer, which was good for 2005. Give yourself three engines behind the same behavior, picked by one setting. Give yourself several payment providers behind the same behavior too.

"Which database" becomes deployment trivia, not architecture.

Let AI build inside the fences.

Any feature decomposes into the same pipeline.

Define the data on every engine.

Add the shared actions.

Add the thin route.

Add the UI.

The prompt has one shape: add this entity, obey the conventions file, run the checks before calling it done.

The agent never architects, because that is decided. It only implements.

Rails gave humans scaffolding. Conventions give agents guardrails.

Undecided or conventioned

The cost

Conventions ossify. Rules that fit today chafe tomorrow, so the file needs pruning every quarter.

Dead rules teach agents that rules are decorative. Schedule the pruning like box maintenance. Small, regular, non-optional.

Know this first

Conventions ossify. Prune the file every quarter.

Rails keeps its magic. This system matches the mechanism, not the tooling.

Why BoringPush is the way to do this

Decisions, already made.

BoringPush ships the contract.

Where things go.

What shape they take.

Which database.

Which payment provider.

You skip the debates. Your agent skips them too.

FAQ

Is this real, or does Rails still win on magic?

Rails keeps its magic: generators, a console and decades of ecosystem depth. What this system matches is the productivity mechanism, which is pre-made decisions, not the tooling surface. Choose by ecosystem needs, not nostalgia.

How is this different from just using a boilerplate?

Boilerplates ship answers, and conventions ship answerability. A boilerplate without the rules decays from the first agent session. The conventions file plus the checks keeps answers enforced, so every diff stays reviewable.

What stops conventions strangling unusual features?

An amendment process. Sessions propose changes to the file as separate diffs, reviewed like code, never as drive-by violations. Genuinely new needs earn new conventions on purpose.

Do I need Rails experience to benefit?

None. Django, Laravel and Phoenix all run the same idea. What transfers is the taste: decisions documented, contracts uniform and switching designed in.

Can conventions cover taste in UI and copy, or just architecture?

Both. BoringPush keeps its visual style and its copy rules beside its structural rules. Agents with taste constraints produce coherent products, and without them every session imports a new design era.

When should a solo founder write the file?

Before the third agent session. Session one explores, session two sets patterns, and session three fossilizes them without a file. An afternoon of writing pays back every session after.

Keep reading

• OpenCode SaaS Starter: Stop the Every-Session Redesign — the file this system centers on
• Build Features With AI That Don't Need Rewrites — the pipeline conventions enforce
• AGENTS.md Is a Wish List Until You Add Teeth — the enforcement half of the triangle