genesis

• ALTHOUGH THIS WORKS BETTER THAN 5 MODELS BY THEMSELVES. IT IS NOT GOOD ENOUGH AND I AM CREATING AN ENTIRE NEW SYSTEM AS OF THIS MOMENT *

Genesis

Ultimate Opus 5 builder. Genesis creates and transforms any setup into the ultimate setup for generation 5 models.

Genesis turns an empty folder into a working SaaS, web app, API, or CLI, running autonomously on your machine in Claude Code. It can also take a codebase you already have and bring it up to the same standard.

Built for frontier models and agentic engineering — not a template pack.

Install · The three modes · Quick start · How it works · Safety · Upgrading · FAQ

Live examples of what it can build: movietq.com · brandcrafter.app

---

What it is

Most scaffolders open with "which framework?" and hand you a folder of files. Genesis opens with the problem. It researches the domain, designs the architecture, and picks the stack fourth — deriving it from the design instead of assuming it, with the reasoning for every choice written into docs/DECISIONS.md. Then it plans the work exhaustively and builds it item by item, running to completion rather than stopping to ask what to do next. Anything that needs your accounts, keys, or money is written into a deployment handoff and left for you at the end.

What keeps the output coherent is one document — the standard — that every mode measures against. It asks two things of a repository, in the first two lines of its CLAUDE.md: what it is and who is exposed. The first decides which rules apply at all; the second, how much rigour they demand. And it draws one line through everything: an instruction either describes the model's conduct or a property the artifact must have. The second is the standard. The first is scaffolding, and current models do it better without being told.

Everything runs on your machine, on your Claude subscription.

The three modes

Mode	You have	Genesis does
create	an empty folder	researches, designs, picks the stack, plans, then builds and tests it — autonomously
transition	a codebase already	brings it up to the same standard, without deleting what only that repository knows
system	neither	audits the Claude Code setup that loads in every session, and reports what it costs you

Every run opens with the system check, because that setup loads into every session — so a repository fixed underneath a stale one has the fix undone on the next turn. It reads and proposes; nothing outside the project changes without your say-so.

Transition covers two cases that need the same procedure: a repository primed for an older model, where instructions written to compensate for old weaknesses now fight the current model's strengths, and one that was simply never brought to standard. Both are fixed by removing what instructs conduct, keeping what states properties, and saying each thing once.

The second half is the one that matters. Verification ritual is re-derivable from any document; the fact that one query silently truncates past a thousand rows, or that reordering two middleware lines breaks webhook signature checks, exists in exactly one place. Genesis will not delete a line it cannot explain.

Each mode ends the same way: the change applied, a request that you run Anthropic's /doctor and paste the output back, and your own test command run with its real output recorded.

Requirements

Required:

• Claude Code (terminal, VS Code, or desktop app) with a paid Claude plan.
• Node.js 18+ — runs the task-archive hook genesis installs in every project it scaffolds.

Recommended:

• Claude Max for create — a full build is long and usage-hungry. Works on Pro, with more waiting. transition and system are cheap by comparison.

• Auto mode — what makes an unattended build actually unattended. Genesis pairs it with the limits it sets up, but you enable it at your own risk.

• Higher reasoning effort for create — /effort xhigh before starting a long build. A long build is mostly decisions made while you are not watching, and effort is what buys those.

• rtk (brew install rtk on macOS and Linux) — strongly recommended for long builds. It's a CLI proxy that filters the output of ordinary shell commands before it reaches the model, and it reports 60–90% fewer tokens on common dev commands. That matters more than it sounds: command output is where most of an agentic session's context actually goes — one git diff on a real branch, one failing test run, one npm install can cost more than the whole conversation around it. Spend less there and a build simply gets further before it hits a usage limit. It hooks into Bash transparently, so nothing about how you work changes, and rtk gain shows you what it actually saved. Genesis never requires it.

  Install from rtk-ai/rtk — an unrelated project publishes a binary with the same name. If rtk gain isn't a recognised command after installing, you have the other one.

Platforms: macOS, Linux, WSL2 and native Windows. The one executable genesis registers on your machine is a Node script, so it runs the same everywhere — there is no .sh hook to fail on a PowerShell host, and no jq to install. What is not platform-neutral is the shell inside the skills: their commands are written for bash, and on native Windows without Git for Windows Claude Code runs commands through PowerShell instead, so it translates them as it goes. Installing Git for Windows removes that translation step.

Install

Two steps everywhere: 1) register this repo as a plugin source, 2) install the plugin from it.

Terminal / VS Code / desktop app — at the Claude prompt (not your shell), one command at a time:

/plugin marketplace add gabrieldabbah/genesis

/plugin install genesis@genesis-marketplace

Through the /plugin menu (any surface): type /plugin, add a marketplace and enter gabrieldabbah/genesis as the source, then install genesis from the plugin list.

From your shell (scriptable — e.g. for dotfiles or machine setup):

claude plugin marketplace add gabrieldabbah/genesis
claude plugin install genesis@genesis-marketplace

Note the two formats: marketplace add takes a source (owner/repo, a URL, or a path); install takes an address (plugin@marketplace — here, plugin genesis from the marketplace named genesis-marketplace). Don't paste the @ form into "add marketplace".

To confirm, type /genesis — it should appear in the command list. Installed once, it is available in every project on that machine.

Quick start

Build something new

mkdir my-app && cd my-app && claude

Type /genesis. It asks a few plain-English questions — what you're building, who it's for, how cautious to be — and then gets out of your way. It decides the rest itself and writes down why, so you can argue with the reasoning later instead of guessing at it.

The things it genuinely can't do without you — creating accounts, pasting API keys, the production deploy — don't interrupt the build. They pile up in docs/DEPLOYMENT.md as a checklist waiting at the end.

Long builds can outlast a usage window. Genesis checkpoints after every task, so stopping costs you the task in flight and nothing else — reopen the folder and type resume genesis.

Fix up something you already have

Open the project and say what you want — "bring this repo up to standard", "my CLAUDE.md is out of date", or just /genesis transition.

It reads everything before it changes anything, tells you which of the two situations it thinks you're in, and works through the repository: the instructions your agent loads, the skills it can reach for, your task list, the notes Claude has saved about the project, your settings. Then it asks you to run Anthropic's /doctor, applies what that turns up, runs your test command, and stops so you can read the diff.

Check your Claude Code setup

/genesis system

Everything in ~/.claude loads into every session you ever start, and most people set it up once and never look again. This reads it back to you: what's in there, what it costs you per session, and what's actively working against you.

The two worst offenders are worth naming, because they're common and they're invisible until you know to look. One kind of hook stops Claude from ending its turn; another stops it from asking you a question. Install both and you get an agent that can't stop and can't ask — which mostly produces confident, wrong work. Genesis used to ship both. It doesn't anymore.

Nothing in your home directory changes unless you say so.

How it works

create — the order is the point

Genesis never starts with "which framework?". The stack is chosen in phase 4, after the problem is understood and the architecture is designed:

flowchart LR
    P0["0 · Capture<br/>the problem"] --> P1["1 · Foundation"]
    P1 --> P2["2 · Research"]
    P2 --> P3["3 · Architecture"]
    P3 --> P4["4 · Choose<br/>the stack"]
    P4 --> P5["5 · Plan"]
    P5 --> P6["6 · Build 🔁"]
    P6 --> Done(["Done — hands<br/>you the keys"])

Phase	What happens
0	Your goal, in plain English
1	Foundation — CLAUDE.md, docs skeleton, secret denials, the archive hook
2	Research the domain and candidate approaches, with sourced claims
3	Design the architecture and write it down
4	Choose the stack, derived from the design, rationale logged
5	A full task list, ordered by what depends on what, each item with a way to prove it's done
6	Build, one item at a time, to the plan

Phase 6 works that list one item at a time, in dependency order, running your test command after each. Genesis ships no agent definitions and installs none: whether to hand a piece of work to a subagent is decided per item, against what the item actually is. Work that finishes in a handful of tool calls costs more to delegate than to do. And it never sends a second agent to double-check the first — current models check their own work, and stacking agents on top of that just burns time.

That task list is a contract in both directions. Genesis builds everything on it, and it doesn't bolt on features that aren't on it just because they'd be nice.

transition — subtracting is the easy half

A lot of what's in an older CLAUDE.md was written to push a weaker model around: verify before you claim done, use a second agent to check the first, never leave a placeholder, you MUST use this skill. Current models already do the first two and don't do the third, so those instructions now just take up room and pull against better judgment. Genesis strips them, along with hooks that override a decision rather than check a fact.

Deleting is easy. Not deleting the wrong thing is the hard part, and it's where most of the care goes.

Buried in the same file is the stuff nobody can reconstruct: that one query silently stops at a thousand rows.