Ritual

Ritual for developers

Turn the thing you’re building right now into a build brief.

Type a real problem. Ritual runs structured discovery, then hands your coding agent a brief it can build from — grounded in the code you already have.

  1. scopes against your codebase
  2. asks the blocking questions
  3. recommends an approach
  4. writes the build brief

Ritual for developers

The strategy behind the build, in minutes

Type a real problem. Ritual frames it, questions it, and hands your agent a build brief with the reasoning attached.

❯ /ritual build one command, inside your coding agent

it’s live · try it out below it’s live · try it below

What a run actually looks like

The one-liner above, start to finish. You bring the sentence — Ritual does the rest.

The task you type

“Let people invite teammates into their workspace.”

  1. 01

    Scopes the problem

    Ritual reads the codebase to figure out what this task actually touches.

    • auth: better-auth sessions (lib/auth.ts)
    • db: postgres + drizzle — `members` table already exists
    • email: resend, transactional templates in /emails
    • blast radius: 1 migration, 2 routes, 1 settings screen
  2. 02

    Asks the questions that would have blocked the build

    The decisions an agent would otherwise guess at, surfaced up front.

    • Q: invite by email, or shareable team link?
    • Q: reuse owner / admin / member, or add a billing role?
    • Q: what happens when an invite exceeds the seat count?
    • Q: should invites expire, and after how long?
  3. 03

    Turns the answers into recommendations

    Each one is a resolved decision, justified against your existing code.

    • Email invite + 7-day signed token — matches your existing Resend setup
    • Reuse owner / admin / member — already enforced in `members.role`
    • Enforce seats server-side on accept, not on send
    • Skip a new billing role — no billing surface in the repo yet
  4. 04

    Writes the build brief your agent works from

    The recommendations become a spec, not a chat transcript. This file lands in your repo.

    .ritual/build-brief.md
    # Build brief — Add team invitationssource: 4 recommendations, all accepted## ScopeInvite teammates by email into an existing org, withseat limits enforced at accept time.## Constraints from the codebasereuse better-auth session in lib/auth.tsextend drizzle schema — do not recreate `members`send through the existing Resend client## Plan1. migration: invitations (token, email, role, expires_at)2. POST /api/invites — validate seat + role, send email3. accept flow at /invite/[token] — verify, then join org4. settings/team UI: list, resend, revoke## Acceptanceexpired + already-used tokens rejected with a clear errorseat overage blocked server-side, surfaced in the UI

Your turn

Same terminal, live. Type the thing you’re actually building.

it’s live · type what you’re building it’s live · type yours

From a one-liner to a build brief your agent can run with

01
Define the problem

Your one-liner becomes a sharp, scoped problem statement your agent can build against.

02
Break it into sub-problems

Each sub-problem gets the discovery questions that pin its trade-offs, dependencies, and edge cases.

03
Reason into recommendations

A first cut of recommendations with the reasoning attached: not just what to do, but why.

04
Hand off to your agent

Greenfield or existing repo, the brief lands in Claude Code, Cursor, or Codex as the structured context your agent builds from.

❯ /ritual build

What the brief changes

Same one-liner. Two very different pull requests.

Agents don't lack skill. They lack context. Everything on the left is a confident guess.

before · the one-liner, straight to the agent
> add real-time collaboration to our editor
I'll add polling: refetch the doc every 2 seconds.approach picked for you
1. add a /changes endpoint to the API
2. merge remote edits by overwriting local statelast write wins
3. re-render the editor on every poll
diff: 9 files · +412 −168rework guaranteed
after · changes you'd actually merge
> /ritual begin · brief: realtime-collab
Working the brief: presence first, co-editing later.decision surfaced
1. ship live cursors on top of the current editor
2. keep single-writer editing, add soft locksno lost edits
3. gate full co-editing behind a beta flagreversible
diff: 5 files · +190 −12review-sized

/ritual build /ritual refine /ritual begin

What Ritual fixes

Solve Problems Agentic Coding Creates

Give Claude Code, Codex, Cursor, Windsurf, and other coding agents the structured context they need before they build, to catch blindspots, clarify scope, and reduce rework.

Accumulating Tech Debt
Context Drift
Wasted Token Burn
Unresolved Trade-offs
Flawed Assumptions
Weak Reasoning
"The context window becomes the new programming surface. You are no longer only writing deterministic instructions for a computer. You are giving context to an intelligent interpreter that can read, reason, call tools, inspect environments, debug errors, and adapt."
Andrej Karpathy
Andrej Karpathy
Founder, Eureka Labs · ex-Tesla, OpenAI

Ready to own the frontier?

Join thousands of users already using our platform to drive growth and innovation.

Install Ritual Schedule a Demo

Ship changes you'd actually merge.

Ritual runs the discovery, the what and the why, so Claude Code, Cursor, and Codex build from real context instead of guesses.

Install Ritual Schedule a Demo