# Rust off Rails: frequently asked questions

> Straight answers about the framework that ships zero lines of code. Framework version 0.7.3. HTML version: https://rustoffrails.org/faq

## Getting started

### Which agents work?

**Claude Code** with the plugin is the recommended setup: you get nine skills, from `/offrails:new` to `/offrails:upgrade`, and the guardrail hooks. **Codex** and **opencode** work too (the `offrails` command can start either for you), and so do **Cursor** and any other agent that reads `AGENTS.md`: every generated app carries `AGENTS.md`, a Cursor rule and Copilot instructions pointing at it. The docs are the framework, so any agent that reads Markdown can follow them. [How to start without Claude Code](https://rustoffrails.org/start#other-agents).

### Which models?

Rust off Rails itself was built mostly with Claude Opus 5.5 in Claude Code, with one human steering. Any capable coding model can follow the docs, but results vary with the model: the stronger it is at long, multi-step work, the fewer times you'll be asked to "fix the red test".

### Do I need to know Rust?

No. You write intent (specs in `product/`, answers in the interview) and the agent writes every line. Knowing some Rust helps when you want to review a diff, and the compiler plus the test suite on two databases catch most mistakes before you'd ever see them.

### How long does `new` take?

Honestly: a full app skeleton takes roughly 40 to 60 minutes of agent time, because everything (the job queue, the dev mailbox, the jobs dashboard, the tests) is generated from the docs rather than installed from a library. Then the first `cargo` build takes about 10 minutes. Make a coffee; the agent asks its interview questions up front, so you can walk away after you say "yes" to the plan.

### What does it cost?

The framework is free and open source, dual licensed **MIT OR Apache-2.0**. You pay for your agent (tokens or a subscription) and for wherever you host the app.

## Using it

### Can I edit the code myself?

Yes, nothing stops you. The rule is that humans write intent, but when you paste a fix, the agent doesn't revert it: it keeps it working, records the intent in the spec or `docs/decisions.md` so it survives future changes, and owns that code again from then on. `/offrails:doctor` looks for hand edits too. Usually it's quicker to tell the agent what you wanted.

### SQLite or Postgres?

Both, with the same code. Apps use SQLite locally, and you pick production in the interview: Postgres managed by your host (recommended), or SQLite on the server's disk for a single, cheap server. Every test suite runs on **both** databases, and "green" means green on both.

### Can it do realtime, background jobs and email?

Yes, all built in, with no Redis: the database is the only infrastructure. An Oban-style persistent job queue with cron and a live `/admin/jobs` dashboard; a Swoosh-style dev mailbox at `/dev/mailbox` with mailer previews; live page updates over SSE; and channels with presence over WebSockets (from 0.4.0 on the framework's own `offrails.v1` protocol, with resume after downtime and fallbacks).

### How do I upgrade an app?

Commit, run `offrails update`, then `offrails upgrade` in the app (framework 0.4.0+; in Claude Code, `/offrails:upgrade`). Your agent reads the CHANGELOG's migration steps, reconciles instead of re-creating, never edits applied migrations, and shows you the plan first. [The full upgrade guide](https://rustoffrails.org/guide#upgrading).

### Can my agent read the docs without installing anything?

Yes. Connect it to the [hosted MCP server](https://rustoffrails.org/mcp), `https://rustoffrails.org/mcp`. In Claude Code that's one line: `claude mcp add --transport http rustoffrails https://rustoffrails.org/mcp`; [the MCP page](https://rustoffrails.org/mcp) has the setup for Claude, Cursor, ChatGPT and Codex. Your agent can then search the docs, read any guide, look up the Rails and Phoenix map, list the skills and get a starter prompt. It's read-only, public and needs no account. To build an app you still [install the framework](https://rustoffrails.org/start).

### What's llms.txt for?

For your agent. [`/llms.txt`](https://rustoffrails.org/llms.txt) is an index of the whole site in Markdown, [`/llms-full.txt`](https://rustoffrails.org/llms-full.txt) is every doc in one file, and every page has a Markdown twin (add `.md`, or send `Accept: text/markdown`). Tell your agent "read rustoffrails.org/llms.txt" and it gets clean Markdown instead of HTML soup.

## Code and contributions

### Can I contribute?

Yes! Read [CONTRIBUTING.md](https://github.com/rust-off-rails/rustoffrails/blob/main/CONTRIBUTING.md). The most valuable contribution is a report of where an agent got stuck, improvised or built the wrong thing while following the docs. Next best: a verified doc fix (have your agent fix the guide, then prove it by building a real app from the corrected docs), and new eval cases that catch agents doing the wrong thing.

### Is AI-written code accepted?

Yes. Ideally, it's the only code we accept: the framework's founding rule is that all code is written by AI, and that applies to the framework's own repository too.

### Is hand-written code accepted?

We may consider it, but you must explain why you had to write it by hand: what the agents got wrong, which agent and model, what you tried. Usually we'll turn it into a doc fix instead, so agents get it right next time.

### With no code provided, can different people get different results?

Exactly! The docs pin the decisions (the stack, the structure, the conventions, security, the tests), not the lines. Two people with different agents can get different code for the same spec, and both are right if they pass the same Definition of Done. We tested shipping sample code, and for now it isn't in the framework's best interest; it may come later as optional, verified reference implementations.

### Is this all AI slop?

Well, it's up to you (or your AI agent) to judge. The evidence we'd offer: every app proves itself with its test suite on SQLite and Postgres, dependency and secret scans and an OWASP ZAP baseline in CI, and this website, generated the same way, scores 100 on Lighthouse.

### Is the name a joke?

A little. It's Rust, off the Rails: the logo is an R tipping off two rails. The acronym is still RoR, on purpose, as a thank-you. Rails fans are very welcome here.

## Trust and production

### Is it production-ready?

Honestly: it's young. It is dogfooded on real apps (a bookshelf with accounts and live reviews, the Linkdrop magic-link demo, an API-only demo, and this website), and its guides are verified against the current versions of the crates they use. This site runs on it in production at roughly 10 to 30 MB of RAM, and a load test pushed about 1,445 requests per second through a tunnel with zero errors. Every app carries its own tests on two databases, a security checklist and a Definition of Done, so judge your app by its tests, not by our word, and run `/offrails:security` before you ship anything sensitive.

### Why Rust?

Because the compiler is the best reviewer an agent can have. Queries are typed Rust, templates are checked at compile time, and front-end types are generated from Rust, so most of an agent's mistakes become compile errors in seconds instead of bugs in production. What types can't prove, the tests prove on both databases. And the result is one fast binary in one Docker image.

### Why not just use Rails or Phoenix?

We love them, and we borrow from both: Rails' conventions, generators and Solid trifecta; Phoenix's Oban, mailbox, LiveDashboard and channels. Rust off Rails is what those ideas look like when an agent writes all the code and a compiler checks it. If you're happy writing Rails by hand, keep going.

### How seriously do you take security?

It's the framework's gold standard: a strict CSP and the full header matrix, authorization on every route and socket join, hashed tokens, rate limits, a threat model in every feature spec, and dependency, secret and ZAP scans in CI. A flaw in the guidance would spread to every app built from it, so doc vulnerabilities count as real vulnerabilities. Report them privately on GitHub (Security → Report a vulnerability); see [SECURITY.md](https://github.com/rust-off-rails/rustoffrails/blob/main/SECURITY.md).

## Help

### Where do I get help?

Ask in [GitHub Discussions](https://github.com/rust-off-rails/rustoffrails/discussions). If your agent got stuck or built the wrong thing while following the docs, open an issue with the "Agent got stuck" form: those reports make the framework better for everyone.