Ari's Space, Rebuilt With Kimi

I tore this site down to the studs.

Not a reskin. A rebuild. New design system, new architecture, new money path, new content machine, then an OS skin you can walk into.

The crew was not a crew. Kimi carried the groundwork: swarm night, architecture kill, wave plans, money, gen, migration. Grok took the baton for art-direct: live render, one note per round, rapid iteration on the desk face. Same doctrine. Different job for the seat.

This is the making-of. How V2 got decided, how it got built in waves, how the look got directed, what broke, what we refused to ship soft.

If you want the older speedrun (V1, eight hours, five sessions), that still lives here: Building Aris Space: 8 Hours, 5 Sessions, One Site. Different era. Same instinct: protocol over heroics.

Stop prompting. Start defining outcomes. This is what that looks like when you point it at your own website.

   /\
  /  \
 | == |
 | || |
/|_||_|\
  /||\
 ' '' '

Night zero: the swarm that argued first

I dumped a mess into one session. Membership tiers. An image tool. A forum. A design language built around a pixel rocket shaped like the letter A. Chaos.

The session did not start writing code. It started by arguing with itself.

Five discovery agents went out in parallel:

1. Map what already existed
2. Stress-test the stack
3. Hunt every way the plan could fail
4. Walk the site as a visitor
5. Sequence the work

They came back with digests, not noise. I made a short stack of hard decisions in about ten minutes.

Then three architecture drafts went head to head. Three adversarial judges tried to kill them. Two drafts died. The survivor is the skeleton of what you are looking at now.

[ fig ] Argue first. Code second. Five agents, t…

  ideas
    |
    v
┌─────────┐
│  swarm  │──> digests
└────┬────┘
     | decide
     v
┌─────────┐
│  build  │
└────┬────┘
     |
     v
   ship_

The public name of the model lane that carried that night and the wave groundwork is Kimi. The method is load-bearing either way: swarm discovery, kill weak architecture, lock a written plan, then build in waves.

What the night locked (before a single product page)

Three surfaces, one domain

Not three marketing sections. Three machines that share a domain:

One domain so cookies stay first-party. Public content deploys when content changes. Product deploys when product changes. That split is why a content ship does not have to rattle the ledger.

[ fig ] Three surfaces. One domain. Different de…

  reading   working   LLM
  machine   machine   packs
  -------   -------   -----
  essays    /app/*    agents
  courses   tools     context
     \        |        /
      \       |       /
       +------+------+
         one domain_

Design system before product

Cream paper. Purple rocket. Type that looks like it escaped a terminal. Whimsy is the wrapper, never the content. If body copy is hard to read because we got cute with a pixel font, that is a bug.

  ~~~~~~~~~~~~~~~~
 ~  sparkles etc  ~
~   ┌──────────┐   ~
~   │  content │   ~
~   │  (clear) │   ~
~   └──────────┘   ~
 ~   wrapper only ~
  ~~~~~~~~~~~~~~~~

The design package shipped as the first real artifact of the rebuild. Showcase route. Tokens. Window chrome. Lint that keeps decorative noise out of the MDX body.

Rules that outlived the night

• Outcome over path. Public copy never needs private harness names.
• Paid value close to login. No maze.
• Rocket intro once, skippable, reduced motion honored.
• Ledger is law for credits: integer pence, atomic debit, idempotent webhooks, reconcile when reality drifts.
• GEO is not an afterthought. Agents are a first-class reader of the site.

Those lines went into a written design. Everything after was execution against that contract.

Seats: Kimi groundwork, Grok art-direct

I do not treat models as interchangeable wallpaper.

Kimi held the long groundwork seat: discovery swarm, design lock, identity, money path, gen surface, content migration. High structure. High proof. Written plans and definitions of done.

Grok took the art-direct seat when the machines already worked and the face needed to move fast: live page open, one note per round, cream field and window chrome, library graph, loginwindow, guest desktop. Rapid iteration against pixels, not another architecture debate.

[ fig ] Same desk. Different job for the baton.

 [ Kimi seat ]
  groundwork
  swarm · plan
  waves · ship
       |
       v handoff
 [ Grok seat ]
  art-direct
  live render
  one note / round_

That split matches how I direct film: some days you need a planning room. Some days you need a monitor and a call sheet of tiny moves. See I directed a website live....

How we actually built it: waves, not one heroic session

V1 taught me the session cap. V2 taught me the wave cap.

Each wave had a definition of done. Merge-request only on main. Preview, then promote. Written handoff into the next wave so a cold session could not invent a new plan.

[ fig ] Waves, not one heroic session that limps…

 W5 desk_
 W4 content
 W3 product
 W2 money
 W1 identity
 W0 foundations

W0 - Foundations

Monorepo. Design package. Context-pack validator ported, not rewritten. This announcement drafted as the first page of V2. A real content-scale spike so we knew whether the essay corpus would blow the worker before we promised the world a migration.

W1 - Identity

Auth on the working machine. Users mirrored into the data plane. Public header that knows if you are signed in without gating the library. A hard spike: one domain, two workers, route dispatch for /app/*, one cookie. Sign-in had to work for real before money touched anything.

W2 - Money

Orbits on a real checkout path. Founding prices shown next to standard from day one so the jump is never a surprise. Ultra scarce by design. Credits as a ledger, not a vibe number in a row.

The craft here is boring on purpose: idempotent webhook handling, atomic debit so two gens cannot spend the same pence twice, a portal for cancel, ops paths to inspect and replay when the edge of the internet lies to you.

I ran a full £0 loop in the browser before anything live charged a card. Sign up, pick a tier, coupon, grant lands, cancel cleans the tier. That kind of proof is the opposite of a launch tweet.

W3 - Product surface

Image gen behind login. Prompt enhance on the server. Cap enforcement on the ledger. Community read on the public worker, write on the app worker. AutoMod posture: hide above threshold, review queue, not theater.

The model slot on the gen path changed when the first planned backend refused credentials on this account. We probed live, picked a quality peer that actually answered, left a one-var upgrade path if the gate ever clears. That is the method: probe, record, ship what works, do not romanticise the brief when the wire says no.

W4 - Content machine

This was the heavy lift.

The old corpus was not "a folder of markdown." It was hundreds of kilobytes of essays welded to a component library, fidget blocks, glossary runtime, and a few whimsy-in-content habits the new lint had to kill.

We staged migration. Ported or shimmed the load-bearing blocks. Kept URL shape 1:1 so the library did not become a redirect storm. Courses as multi-page paths. Privacy that matches what the site actually loads. Context packs and llms-full as build-time static assets, because the worker has no disk at runtime.

That last line burned once for real. Green tests on a machine with a filesystem do not prove production. If a route handler tries to read content from disk on the worker, it fails closed in prod while your laptop smiles. Fix: generate the payloads at build, ship them as assets, probe a route that only exists in the new version after deploy.

W5 - OS skin and the desk you walk into

After the machines worked, we art-directed the face. This is where the Grok seat earned its keep.

Login window. Guest desktop. Menu bar. Constellation of windows. Library as a graph of topic clusters with ASCII icons, not a flat blog index. Deep dives in paper clearings inside the field. Motion law: whole-pixel steps so text stays sharp. No greens. Cream and purple and brown.

Live render open. One note per round. Call the next change when the frame settles. Agents held the hands. Taste stayed human.

Then the apex cutover: the preview host stopped being the main door. The desk is the public site.

Hard lessons (the ones that should transfer)

Write the handoff

A session that ends in chat lore is a session that steals from the next one. Done means a document: what shipped, what is open, what must not be re-litigated.

Small sessions, then waves

Context windows rot. Waves keep the plan honest. Definitions of done keep vanity work out of main.

Swap the seat when the job changes

Groundwork and art-direct are different sports. Route the model (and the human mode) to the job. Do not force a planning seat to paint, or a paint seat to re-litigate the ledger.

Pathspec commits, staged deploys

Stage only what you meant. Deploy web when content or chrome moved. Deploy app when money, auth, or gen moved. Do not "just ship everything" because the terminal is warm.

Dual readers

Humans get the notebook. Agents get the pack. Needles stay verbatim. See Context pack dispatch.

 ┌─ context pack ─┐
 │ hash           │
 │ claims         │
 │ sources        │
 │ must-not       │
 └───────┬────────┘
         | open
         v
      new agent_

Fail closed on gen that looks fake

On the product path and on my own desk craft:

• Two independent looks before anything is finished
• If it looks obviously AI, it fails
• Staging before promote
• Still before motion when video is in play
• Log recipes so a morning pass can see what is red

Studio is where members run gen. Essays are where the floor gets taught. The private sharpen work on my machine stays private; the discipline is public.

Probe production truths

Workers have no disk. Webhooks hit real WAF rules. Auth widgets behave differently on test keys. £0 loops beat confidence. Replay paths exist for when the world is wrong and your ledger must still be right.

What the experience of building this way felt like

I did not "prompt a website into existence."

I sat in the conductor seat. Discovery argued. Architecture died in public (inside the swarm). Waves merged under tests. Art direction happened against a live page. Money was proven on a zero charge. Content migration was measured before it was promised.

The intelligence is not any single model. It is the system around them: who goes first, who gets to kill a draft, when to swap the baton from groundwork to paint, what done means, what ships only after eyes are on it.

That is the same doctrine as the rest of this library. V2 is just the week I pointed it at the house itself.

Where the desk is now

You can walk the guest desktop. Open the library graph. Take a course. Sign in for the working machine. Read privacy that matches the loaders. Agents can fetch packs instead of scraping pretty HTML.

I am not going to re-sell you the orbit table here. That is a different page, and it should stay a different page.

This essay's job is narrower: show the rebuild.

What does not change

V2 is not a paywall on the teaching.

• Free deep dives stay free. The library essays keep shipping for anyone who can open a browser. Membership is not a replacement for that corpus.
• Skool cadence stays. I still post in Clief Notes the way I already do. The desk does not eat that habit or turn the community into a paid-only drip.
• Membership is an extra layer of access. Studio, gen, member machines, tighter seats when you want hands on the tools. New tools to try. Not a swap for the public work.

If you only ever read free and hang on Skool, you are still in the room. The orbits buy machines, not permission to learn the basics.

// The rocket launches once. Then it's all content.