Building Aris Space: 8 Hours, 5 Sessions, One Site

The punchline

8 hours from concept to live site. 5 sessions. None of them above 50% context.

The site is aris-space.com. Built on Next.js 15, Tailwind v4, MDX, Zustand and react-rnd, deployed on Vercel. By the time it shipped: 14 commits on the website repo, 4 on the orchestration root, 19 of 19 unit tests green. None of that's the interesting bit.

The interesting bit is the protocol that made an 8-hour build feel like five clean half-hour blocks instead of one chaotic session that limps over the line.

The constraint that made it work

One rule: no session goes above 50% context budget.

That sounds defensive. It's the opposite. It's the constraint that lets Claude actually finish things.

A session above 50% context starts dropping precision. It re-reads files it already read, re-litigates decisions it already made, hedges on commits it already understood. The output looks fine. The signal-to-noise quietly halves. By 80% you've got an expensive autocomplete that vaguely remembers your project.

So I cap it. When a phase is done, the session is done. Written handoff before close. New session opens cold and reads the handoff like a contract.

The trade-off is an extra ten minutes per phase boundary writing the handoff. The win is that every session opens at peak signal and closes before it degrades. Across 8 hours, that compounds into something that looks suspiciously like quality.

How it worked

Five sessions. Each one had a single phase to deliver and a written handoff to leave behind.

Session 1. Workspace setup. Spec, decisions log, manifest, repo scaffolding. Closed at handoff: "Phase 1 complete, foundation ready."

Session 2. Desktop shell. Window manager, draggable panes, the System 7.5.3 aesthetic. Closed at handoff: "Phase 2 complete, shell working, content empty."

Session 3a. Content layer mid-phase. MDX pipeline, topic routing, the registry. Closed at: "Halfway through Phase 3, here's what's wired and what's left."

Session 3b. Phase 3 mid-2. Picked up the handoff, finished the content layer.

Session 4. Tonight's mega-session. Analytics, MCP wiring, deploy, smoke tests, two posts live.

Each handoff doc is the same shape. What's done. What's next. What I tried that didn't work. What state is on disk vs. in my head. The next session reads it once and can act.

The other rule: brainstorm before you build, on anything non-trivial. A short conversation about shape, edge cases, what done looks like. Cheap. Catches the wrong abstraction before it costs an hour to unwind.

What MCP unlocked

The analytics wiring is the cleanest example.

I didn't write it. I asked Claude to do it. Claude reached the live PostHog project through an MCP server, read the project settings, retrieved the project key, set the Vercel env vars on the website, and flipped session recording on. End to end. I read the diff and confirmed.

Generalise. Any MCP server is a tool that Claude can drive directly inside the same session. No copy-paste. No "go grab this from the dashboard". The tool is part of the workspace.

That's the shift. The agent isn't just writing code that talks to your tools. It's using your tools the same way you do.

The system around the AI is the intelligence.

The numbers

• 5 sessions
• 8 hours total
• 14 commits on the website repo
• 4 commits on the orchestration root
• 19 of 19 unit tests passing
• 0 sessions above 50% context

The takeaway

The system around the AI is the intelligence.

A capable model with no protocol burns context, drifts, hedges, and ships something that's almost right. The same model with a 50% cap, a brainstorm gate, written handoffs and tool access through MCP ships a live site in 8 hours.

I architected. Claude executed. The protocol made both roles legible.

Build the protocol once. Then run it.