Ritual for developers
Give your coding agent better context.
Turn the thing you’re building right now into a build brief. Ritual runs structured discovery, then hands your coding agent a brief it can build from.
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.
What a run actually looks like
The one-liner above, start to finish. You bring the sentence — Ritual does the rest.
“Let people invite teammates into their workspace.”
- 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
- 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?
- 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
- 04
Writes the build brief your agent works from
The recommendations become a spec, not a chat transcript. This file lands in your repo.
# Build brief — Add team invitations## 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.
What better context changes
The same task produces a very different build
A prompt leaves important decisions unstated. Ritual resolves them before your coding agent starts.
TaskAdd real-time collaboration to our editor
Add real-time collaboration #412
The agent filled in the blanks
- Interprets "real-time" as polling every two seconds
- Overwrites local work with the latest remote version
- Re-renders the editor after every poll
Files changed (9) +412 −168
- src/editor/Editor.tsx+96 −41
- src/editor/useDocument.ts+74 −38
- src/editor/sync/poll.ts+88 −0
- src/editor/sync/merge.ts+52 −0
- src/api/documents.ts+39 −27
- src/api/routes/documents.ts+31 −19
- src/state/editorStore.ts+18 −30
- src/editor/Toolbar.tsx+9 −8
- src/editor/__tests__/Editor.test.tsx+5 −5
Review · Last-write-wins will lose edits. Nine files touched for an approach nobody chose. Expect rework.
Add presence and soft locks to the editor #412
Decisions resolved in the brief
- Start with presence, not simultaneous co-editing
- Preserve single-writer editing and prevent lost work
- Make the rollout reversible
What the agent built
- Adds live cursors
- Uses soft locks
- Places full co-editing behind a beta flag
Files changed (5) +190 −12
- src/editor/Presence.tsx+68 −0
- src/editor/useSoftLock.ts+54 −0
- src/editor/Editor.tsx+31 −6
- src/api/routes/presence.ts+29 −0
- src/flags.ts+8 −6
Review · Smaller, safer, reviewable. Five files, no destructive path, and the risky part is behind a flag.
How Ritual works
Every stage of the AI-native SDLC, grounded in your build brief
Ask an agent for intent and you get a plausible document. Ritual works the problem with you first, so the intent, spec, and audit chain your agent runs are based on powerful reasoning.
Define the problem
Your one-liner becomes a sharp, scoped problem statement your agent can build against.
Break it into sub-problems
Each sub-problem gets the discovery questions that pin its trade-offs, dependencies, and edge cases.
Reason into recommendations
A first cut of recommendations with the reasoning attached: not just what to do, but why.
Ritual writes intent.md from the discovery above: problem, sub-problems, recommendations with the reasoning. Your agent plans from it, not from your prompt.
Requirements
Each recommendation becomes a requirement with its constraints and dependencies stated.
Acceptance criteria
Every requirement gets the checks that prove it shipped, written before any code exists.
Ground the brief in your code
Every code reference in the brief is resolved against the real codebase. Anything that doesn’t match is flagged before it becomes a requirement.
Requirements and acceptance criteria land in the build brief, grounded in your repo and committed next to your code, so design decisions have history.
Requirements checklist
The checks the coding agent must satisfy before the build merges. Read first; missing items block review.
Goal and non-goals
One sentence stating the outcome, and what the agent must not build this round.
Required outcomes
Testable results the build is measured against.
Your agent implements from Ritual’s brief, in order, one commit per outcome. The checklist decides what counts as done.
Audit the requirements
Checks that every constraint you set still shows up in the recs and requirements, with acceptance criteria that enforce it.
Audit the plan
The agent’s plan is checked against the brief for anti-goal violations, scope creep, and skipped decisions. Findings come with a repair.
Verify with a second model
Audits run on a different model family than the one that did the work, so the plan isn’t grading its own homework.
Every finding and repair is logged to the audit chain, so you can see what Ritual caught before any code was written.
CI/CD
Acceptance criteria from the brief run as the pipeline’s checks, so the build is measured against what was agreed.
Create PR
The PR description is generated from the brief: goal, non-goals, and the checklist with each item’s status.
Code review
Agentic review works through the checklist first. Human review is routed to the files the audit flagged.
The brief travels with the PR: acceptance criteria run in CI, the checklist is the review rubric, and humans review only what the audit flagged.
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.
What better context changes
The same task produces a very different build
A prompt leaves important decisions unstated. Ritual resolves them before your coding agent starts.
TaskAdd real-time collaboration to our editor
Add real-time collaboration #412
The agent filled in the blanks
- Interprets "real-time" as polling every two seconds
- Overwrites local work with the latest remote version
- Re-renders the editor after every poll
Files changed (9) +412 −168
- src/editor/Editor.tsx+96 −41
- src/editor/useDocument.ts+74 −38
- src/editor/sync/poll.ts+88 −0
- src/editor/sync/merge.ts+52 −0
- src/api/documents.ts+39 −27
- src/api/routes/documents.ts+31 −19
- src/state/editorStore.ts+18 −30
- src/editor/Toolbar.tsx+9 −8
- src/editor/__tests__/Editor.test.tsx+5 −5
Review · Last-write-wins will lose edits. Nine files touched for an approach nobody chose. Expect rework.
Add presence and soft locks to the editor #412
Decisions resolved in the brief
- Start with presence, not simultaneous co-editing
- Preserve single-writer editing and prevent lost work
- Make the rollout reversible
What the agent built
- Adds live cursors
- Uses soft locks
- Places full co-editing behind a beta flag
Files changed (5) +190 −12
- src/editor/Presence.tsx+68 −0
- src/editor/useSoftLock.ts+54 −0
- src/editor/Editor.tsx+31 −6
- src/api/routes/presence.ts+29 −0
- src/flags.ts+8 −6
Review · Smaller, safer, reviewable. Five files, no destructive path, and the risky part is behind a flag.
How Ritual works
Every stage of the AI-native SDLC, grounded in your build brief
Ask an agent for intent and you get a plausible document. Ritual works the problem with you first, so the intent, spec, and audit chain your agent runs are based on powerful reasoning.
Define the problem
Your one-liner becomes a sharp, scoped problem statement your agent can build against.
Break it into sub-problems
Each sub-problem gets the discovery questions that pin its trade-offs, dependencies, and edge cases.
Reason into recommendations
A first cut of recommendations with the reasoning attached: not just what to do, but why.
Ritual writes intent.md from the discovery above: problem, sub-problems, recommendations with the reasoning. Your agent plans from it, not from your prompt.
Requirements
Each recommendation becomes a requirement with its constraints and dependencies stated.
Acceptance criteria
Every requirement gets the checks that prove it shipped, written before any code exists.
Ground the brief in your code
Every code reference in the brief is resolved against the real codebase. Anything that doesn’t match is flagged before it becomes a requirement.
Requirements and acceptance criteria land in the build brief, grounded in your repo and committed next to your code, so design decisions have history.
Requirements checklist
The checks the coding agent must satisfy before the build merges. Read first; missing items block review.
Goal and non-goals
One sentence stating the outcome, and what the agent must not build this round.
Required outcomes
Testable results the build is measured against.
Your agent implements from Ritual’s brief, in order, one commit per outcome. The checklist decides what counts as done.
Audit the requirements
Checks that every constraint you set still shows up in the recs and requirements, with acceptance criteria that enforce it.
Audit the plan
The agent’s plan is checked against the brief for anti-goal violations, scope creep, and skipped decisions. Findings come with a repair.
Verify with a second model
Audits run on a different model family than the one that did the work, so the plan isn’t grading its own homework.
Every finding and repair is logged to the audit chain, so you can see what Ritual caught before any code was written.
CI/CD
Acceptance criteria from the brief run as the pipeline’s checks, so the build is measured against what was agreed.
Create PR
The PR description is generated from the brief: goal, non-goals, and the checklist with each item’s status.
Code review
Agentic review works through the checklist first. Human review is routed to the files the audit flagged.
The brief travels with the PR: acceptance criteria run in CI, the checklist is the review rubric, and humans review only what the audit flagged.
"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."
Ready to own the frontier?
Join thousands of users already using our platform to drive growth and innovation.
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.