Each project runs in a cloud workspace with the app and dev database ready. You reach it through the Claude desktop app — no browser editor, no local setup — and build by describing what you want. Production data never reaches you.
Every idea becomes its own small prototype site, stamped from a starter with SLW branding and email-allowlist login already working. This board is the directory: what's proposed, what's being built, what's live.
| Idea | Proposed by | Status | Links & actions | Updated |
|---|---|---|---|---|
| Loading the board… | ||||
Everything mechanical is automatic. Nothing here touches the production apps.
Name + two sentences. It lands on the board as Proposed — nothing is built yet.
Rivent stamps a private repository from the starter template, gives the idea its own section of the experiments database, and wires up hosting. You never see GitHub, Vercel, or Supabase.
Press Build with Claude on the row — it opens Claude Code with the repo selected and "build it" already typed. Press send; Claude knows the idea and the house rules from the repo. Then just react and iterate in plain English. The live link appears on this board on its own.
Everything you need to go from zero to shipping. Read how it works, do the one-time setup, connect your first project — then you're working. About 10 minutes the first time; seconds every day after.
The Codespace is your environment — a cloud computer with the app running. Claude Desktop is your interface — you connect it to that workspace and build by talking. Nothing runs on your laptop; production data never reaches you.
Open rivent.dev and sign in with your @slw.vc email. Bookmark it — it's the front door to every project.
GitHub builds a cloud workspace from the repo's .devcontainer — dependencies and dev-database wired up, identical for everyone. It runs on practice data; production is never injected. You never open the browser editor — you reach the workspace through Claude Desktop.
The native Claude app connects to that workspace over SSH. You get the Claude interface, with the real running environment behind it — one place to work.
Tell Claude what you want in plain English. It runs inside the Codespace — sees the real code, runs the app, uses the dev database.
Changes are reviewed before they go live, and the workspace persists — reconnect tomorrow right where you left off.
This lets your computer open cloud workspaces. In Terminal:
Choose GitHub.com → HTTPS → login with a browser. If you ever hit a "codespace scope" error, run gh auth refresh -h github.com -s codespace.
Download the Claude desktop app and sign in with your own Claude plan (Pro or Max). This is your interface for every project.
Do this once per project. Already set up your machine (blocks 1–2)? Those are done forever — start right here for each new project. Setting up a second project just adds it alongside the first in your Claude Desktop dropdown.
Pick your project and run the command in Terminal — it spins up the workspace (~30–60s the first time) with the app, dependencies, and dev database ready. No browser editor opens; you'll reach it through Claude Desktop.
One command tells your machine how to reach it, and shows its address:
Your workspace address is cs.<that-name>.main — you'll paste it next.
Click the "Where Claude runs" dropdown (bottom of the Code window) → + Add SSH connection, and fill in the four fields:
Select the connection — Claude installs itself on the workspace (~20s). The dropdown now shows LP Flow instead of "Default."
Claude runs inside the workspace — it sees the real code, can run the app on the dev database, and makes the change. Your work goes up as a reviewed change; nobody edits the live app directly.
Coming back later? Open Claude Desktop → pick the project from the dropdown → keep going. No setup — it's already connected.
Everything after today is: open Claude Desktop, pick your project, build.
Every change lives on our GitHub Project board, from a rough idea to a shipped feature. This is a first draft of how we'll use it.
The flow below is a draft preview — the columns and process aren't finalized. This tab lights up once it's set.
All projects share one GitHub Projects board. Open it from any project card (Project board →) or bookmark it directly. Each card on the board is one piece of work — a fix, a feature, or an idea — and it moves left to right as it progresses.
Raw ideas and requests, unsorted. Anyone can drop one here — a sentence is enough.
Triaged and ready to pick up, roughly in priority order.
Being worked on right now — a branch is open and Claude is on it.
A pull request is open, waiting for a teammate to approve.
Merged and live. The card links to the PR that delivered it.
Add a card to Inbox — or use /capture while working and Claude files it for you.
Move a card to In progress, open the project in Claude, and describe what you want.
Claude does the work on a branch and opens a PR — the card moves to In review.
A teammate approves, CI passes, it merges — the card moves to Shipped.
An App Operator can take an app from idea to fully live in our stack — repo, database, hosting, portal — without being an account admin anywhere. This page is the rulebook: what the role grants, who holds it, the rules of the road, and exactly how a migration works.
Code, hosting, env vars, CI, portal listing. Unrestricted on green CI — this is most of the work.
Creating a database and copying data runs through the migration script (backup → restore → verify), so the one destructive step can’t be fumbled.
Least privilege on every platform: enough to build and run apps, never enough to touch billing or delete an organization.
| Platform | Can do | Can’t do |
|---|---|---|
| GitHubrivent-dev | ✓Create app repos, push, merge PRs, set CI & secrets on their own apps | ✕Change settings on shared repos, delete the org, billing |
| SupabaseSLW Databases | ✓Create & manage project databases, run migrations | ✕Delete the org, billing, manage members |
| Vercelslw1010 | ✓Deploy apps, manage project env vars | ✕Billing, delete the team |
| Cloudflarerivent.dev | ✓Deploy Pages, edit rivent.dev DNS | ✕Account admin, other zones |
| Replitsource apps | ✓Open, edit & export Repls | ✕Team billing & members |
| Person | Role | Status |
|---|---|---|
| Loading the roster… | ||
One command on the server grants the role — it handles GitHub + Vercel automatically and prints the three manual invites (Cloudflare, Supabase, Replit). Remove someone by taking them out of the same five places.
Seven rules cover every scenario. They keep operators fast on the safe things and careful on the few that matter.
You’re admin on any repo you create. Org rules still gate the database and production paths — those changes need review, no matter who you are.
If it’s small and tests pass, ship it. Features, migrations, and anything risky go through a pull request with green CI.
Data moves only through the migration script. It backs up first, restores, and verifies row counts — so the one irreversible step can’t go wrong quietly.
A production DB plus a -dev twin, following the house pattern. Spinning them up is your call — just be intentional: each active database ≈ $10/mo (~$20 for the pair).
Practice data only in dev and experiment databases. Real SLW data or secrets go into a dev environment only with Shawn’s OK.
Named for the app; its database matches the name. Keeps the portal, Codespaces, and databases lined up one-to-one.
Use add-app-operator to grant the role. Reverse it by removing them from the same five platforms — membership is the access.
Five stages, same every time. The one that decides the path is Stage 1 — whether the app has a real database.
Run the report prompt in the Replit Agent. It reports the stack, the secrets it needs, and — the deciding question — whether it has a Postgres database.
A new repo in rivent-dev, code pushed, Replit-specific bits stripped out.
If it has one, the script creates its Supabase project (prod + dev), copies the data across, and verifies it. Skipped entirely for apps with no database.
Deploy to Vercel or Cloudflare, load the secrets, add a devcontainer + CI, and list it on the portal.
Smoke-test the live app, then turn the Replit app off. Nothing is deleted until the new one is proven.
Where it ends up living — the same shape as every other SLW app:
The situations that actually come up — click any to expand.
-dev twin). The migration script copies your data across with a backup taken first and a row-count check after, so nothing is lost. Budget ≈ $10/mo per active database (~$20 for the pair), billed to the org.add-app-operator <github-username> <email> on the server. It adds them to GitHub + Vercel automatically and prints the three manual invites (Cloudflare, Supabase, Replit). They accept the GitHub and Vercel emails, and they’re in.