Claude's Corner: GRU Space, The Moon Factory That's Actually Building One

# How to Build a GRU Space Clone with Claude Code

> A step-by-step guide to building the software stack behind a lunar infrastructure + space tourism platform. Note: the Moon Factory itself is left as an exercise for the reader.

---

## Step 1: Database Schema, Reservations, Missions, and Telemetry

Start with Postgres (Supabase works great). You need four core tables:

```sql
-- Guests who have made reservations
CREATE TABLE reservations (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  full_name TEXT NOT NULL,
  email TEXT NOT NULL UNIQUE,
  tier TEXT NOT NULL CHECK (tier IN ('standard', 'premium', 'vip')),
  deposit_cents INTEGER NOT NULL,
  stripe_payment_intent_id TEXT,
  status TEXT NOT NULL DEFAULT 'waitlisted' CHECK (status IN ('waitlisted', 'confirmed', 'cancelled', 'completed')),
  mission_id UUID REFERENCES missions(id),
  created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Mission definitions (I, II, III and future)
CREATE TABLE missions (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  name TEXT NOT NULL,
  mission_number INTEGER NOT NULL,
  target_launch_date DATE,
  status TEXT NOT NULL DEFAULT 'planning' CHECK (status IN ('planning', 'launch_prep', 'in_transit', 'active', 'completed', 'failed')),
  landing_coordinates JSONB,
  objectives TEXT[],
  created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Real-time telemetry from the lunar payload
CREATE TABLE telemetry (
  id BIGSERIAL PRIMARY KEY,
  mission_id UUID NOT NULL REFERENCES missions(id),
  recorded_at TIMESTAMPTZ NOT NULL,
  sensor_type TEXT NOT NULL,
  value NUMERIC NOT NULL,
  unit TEXT NOT NULL,
  location_lat NUMERIC,
  location_lng NUMERIC,
  metadata JSONB
);
CREATE INDEX ON telemetry (mission_id, recorded_at DESC);

-- Bricks manufactured by the Moon Factory
CREATE TABLE bricks_produced (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  mission_id UUID NOT NULL REFERENCES missions(id),
  produced_at TIMESTAMPTZ NOT NULL,
  batch_number INTEGER,
  compressive_strength_mpa NUMERIC,
  dimensions_mm JSONB,
  qc_passed BOOLEAN,
  qc_image_url TEXT,
  regolith_composition JSONB
);
```

---

## Step 2: Reservation + Payments API

Build a Next.js API route that:
1. Creates a Stripe Payment Intent for the deposit amount
2. Stores the reservation as `waitlisted`
3. Confirms on Stripe webhook and flips to `confirmed`

```typescript
// app/api/reserve/route.ts
import Stripe from 'stripe';
import { createClient } from '@supabase/supabase-js';

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
const supabase = createClient(process.env.SUPABASE_URL!, process.env.SUPABASE_SERVICE_ROLE_KEY!);

export async function POST(req: Request) {
  const { name, email, tier } = await req.json();
  
  const depositMap = { standard: 25000_00, premium: 50000_00, vip: 100000_00 };
  const depositCents = depositMap[tier as keyof typeof depositMap];
  
  const paymentIntent = await stripe.paymentIntents.create({
    amount: depositCents,
    currency: 'usd',
    metadata: { email, tier },
  });
  
  await supabase.from('reservations').insert({
    full_name: name, email, tier,
    deposit_cents: depositCents,
    stripe_payment_intent_id: paymentIntent.id,
  });
  
  return Response.json({ clientSecret: paymentIntent.client_secret });
}
```

Handle Stripe webhooks (`payment_intent.succeeded`) to flip reservation status to `confirmed`.

---

## Step 3: Mission Control Dashboard

A Next.js + shadcn/ui dashboard with real-time telemetry via Supabase Realtime:

```typescript
// components/TelemetryFeed.tsx
'use client';
import { useEffect, useState } from 'react';
import { createClient } from '@supabase/supabase-js';

export function TelemetryFeed({ missionId }: { missionId: string }) {
  const [readings, setReadings] = useState<any[]>([]);
  const supabase = createClient(/* ... */);
  
  useEffect(() => {
    // Load last 100 readings
    supabase
      .from('telemetry')
      .select('*')
      .eq('mission_id', missionId)
      .order('recorded_at', { ascending: false })
      .limit(100)
      .then(({ data }) => setReadings(data ?? []));
    
    // Subscribe to live updates
    const channel = supabase
      .channel('telemetry-live')
      .on('postgres_changes', {
        event: 'INSERT', schema: 'public', table: 'telemetry',
        filter: `mission_id=eq.${missionId}`,
      }, (payload) => {
        setReadings(prev => [payload.new, ...prev].slice(0, 100));
      })
      .subscribe();
    
    return () => { supabase.removeChannel(channel); };
  }, [missionId]);
  
  return (
    <div className="space-y-2">
      {readings.map((r) => (
        <div key={r.id} className="flex gap-4 text-sm font-mono">
          <span className="text-muted-foreground">{new Date(r.recorded_at).toISOString()}</span>
          <span className="font-medium">{r.sensor_type}</span>
          <span>{r.value} {r.unit}</span>
        </div>
      ))}
    </div>
  );
}
```

Key telemetry sensors to track: temperature (surface/internal), atmospheric pressure, power levels (solar/battery), factory motor RPM, seismic activity, radiation dose, camera feeds.

---

## Step 4: Autonomous Factory State Machine

The Moon Factory runs a state machine with no human in the loop. Implement this in Python running on the payload's flight computer:

```python
from enum import Enum, auto
from dataclasses import dataclass
from typing import Callable
import time

class FactoryState(Enum):
    IDLE = auto()
    MINING = auto()
    PROCESSING = auto()
    MOLDING = auto()
    CURING = auto()
    QC_INSPECTION = auto()
    STACKING = auto()
    FAULT = auto()
    EMERGENCY_STOP = auto()

@dataclass
class FactoryContext:
    regolith_hopper_kg: float = 0.0
    processed_material_kg: float = 0.0
    bricks_in_mold: int = 0
    bricks_cured: int = 0
    fault_code: str | None = None
    consecutive_qc_failures: int = 0

class MoonFactory:
    def __init__(self, telemetry_sink: Callable, brick_logger: Callable):
        self.state = FactoryState.IDLE
        self.ctx = FactoryContext()
        self.telemetry = telemetry_sink
        self.log_brick = brick_logger
    
    def tick(self):
        """Called every second by the main loop."""
        handlers = {
            FactoryState.IDLE: self._handle_idle,
            FactoryState.MINING: self._handle_mining,
            FactoryState.PROCESSING: self._handle_processing,
            FactoryState.MOLDING: self._handle_molding,
            FactoryState.CURING: self._handle_curing,
            FactoryState.QC_INSPECTION: self._handle_qc,
            FactoryState.STACKING: self._handle_stacking,
            FactoryState.FAULT: self._handle_fault,
        }
        handlers[self.state]()
        self.telemetry('factory_state', self.state.name)
    
    def _handle_idle(self):
        if self.ctx.regolith_hopper_kg < 5.0:
            self.state = FactoryState.MINING
    
    def _handle_mining(self):
        # Actuate regolith scoop, increment hopper level
        self.ctx.regolith_hopper_kg += 0.1  # ~0.1 kg/tick
        if self.ctx.regolith_hopper_kg >= 5.0:
            self.state = FactoryState.PROCESSING
    
    def _handle_processing(self):
        # Mix with geopolymer activator solution
        # Check temperature (needs 60-80°C for reaction)
        temp = self._read_sensor('mixing_temperature')
        if temp < 60:
            self._actuate_heater(True)
        elif temp > 80:
            self._actuate_heater(False)
        
        if self._reaction_complete():
            self.ctx.processed_material_kg = self.ctx.regolith_hopper_kg * 0.95
            self.ctx.regolith_hopper_kg = 0.0
            self.state = FactoryState.MOLDING
    
    def _handle_fault(self):
        # Log fault, attempt recovery, escalate if repeated
        self.telemetry('fault_code', self.ctx.fault_code)
        if self._can_self_recover():
            self._attempt_recovery()
        else:
            self.state = FactoryState.EMERGENCY_STOP
            # Send high-priority alert to Earth (knowing it takes 2.6s to arrive)
    
    def _read_sensor(self, name: str) -> float:
        raise NotImplementedError  # Implement with actual hardware HAL
    
    def _actuate_heater(self, on: bool): ...
    def _reaction_complete(self) -> bool: ...
    def _can_self_recover(self) -> bool: ...
    def _attempt_recovery(self): ...
    def _handle_molding(self): ...
    def _handle_curing(self): ...
    def _handle_qc(self): ...
    def _handle_stacking(self): ...
```

---

## Step 5: Brick Quality Control with Computer Vision

Deploy a fine-tuned ResNet or EfficientNet model to inspect each brick for cracks, voids, and dimensional compliance:

```python
import torch
import torchvision.transforms as T
from torchvision.models import efficientnet_b0
from PIL import Image
import numpy as np

class BrickQCModel:
    CLASSES = ['pass', 'crack', 'void', 'dimensional_fail']
    
    def __init__(self, model_path: str, device: str = 'cpu'):
        self.model = efficientnet_b0(num_classes=len(self.CLASSES))
        self.model.load_state_dict(torch.load(model_path, map_location=device))
        self.model.eval()
        self.transform = T.Compose([
            T.Resize((224, 224)),
            T.ToTensor(),
            T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
        ])
    
    def inspect(self, image_path: str) -> dict:
        img = Image.open(image_path).convert('RGB')
        tensor = self.transform(img).unsqueeze(0)
        
        with torch.no_grad():
            logits = self.model(tensor)
            probs = torch.softmax(logits, dim=1).squeeze().tolist()
        
        result_class = self.CLASSES[np.argmax(probs)]
        return {
            'passed': result_class == 'pass',
            'defect_type': result_class if result_class != 'pass' else None,
            'confidence': max(probs),
            'class_probs': dict(zip(self.CLASSES, probs)),
        }

# Training: use ~5,000 labeled brick images from Earth analogue tests.
# Simulate lunar lighting (harsh shadows, no atmosphere) in your capture setup.
# Fine-tune for at least 50 epochs. Target >99% recall on the 'crack' class.
```

---

## Step 6: Telemetry Ingestion API + Anomaly Detection

A FastAPI service that ingests sensor data and runs rule-based + ML anomaly detection:

```python
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from datetime import datetime
from supabase import create_client
import numpy as np

app = FastAPI()
supabase = create_client(SUPABASE_URL, SUPABASE_KEY)

class TelemetryReading(BaseModel):
    mission_id: str
    recorded_at: datetime
    sensor_type: str
    value: float
    unit: str

# Rolling window for anomaly detection (last 100 readings per sensor)
_sensor_history: dict[str, list[float]] = {}

@app.post("/telemetry")
async def ingest_telemetry(reading: TelemetryReading):
    # Store in DB
    supabase.table('telemetry').insert(reading.dict()).execute()
    
    # Anomaly detection: flag if >3 sigma from rolling mean
    key = f"{reading.mission_id}:{reading.sensor_type}"
    history = _sensor_history.setdefault(key, [])
    history.append(reading.value)
    if len(history) > 100:
        history.pop(0)
    
    if len(history) >= 20:
        mean = np.mean(history[:-1])
        std = np.std(history[:-1])
        z_score = abs((reading.value - mean) / (std + 1e-9))
        if z_score > 3.0:
            await _raise_alert(reading, z_score)
    
    return {"status": "ok"}

async def _raise_alert(reading: TelemetryReading, z_score: float):
    # Page mission control, send SMS/email, log to alerts table
    print(f"ALERT: {reading.sensor_type} = {reading.value} (z={z_score:.1f})")
```

---

## Step 7: Deployment, Earth-Side and Space-Side

**Earth-side (mission control + reservation app):**
- Deploy Next.js on Vercel or AWS App Runner
- Postgres on Supabase (managed, global replicas for latency)
- Telemetry ingestion API on Railway or Fly.io (needs WebSocket support)
- Redis for real-time aggregation buffers
- Stripe for payment processing with deposit escrow

**Space-side (the hard part):**
- Flight computer: radiation-hardened single-board computer (e.g., SpaceCube Mini or RAD750)
- OS: VxWorks or a hardened Linux build with watchdog timers
- State machine: compiled C or Rust (no garbage collection pauses, deterministic timing)
- Communication: X-band radio to Earth relay or DSN (NASA Deep Space Network)
- Local storage: NOR flash (more radiation-tolerant than NAND, slower but reliable)
- Power: RTG or high-efficiency solar + LiFePO4 battery bank with battery management

**Key embedded software requirements:**
- Watchdog timer that reboots the system if the main loop hangs for > 60 seconds
- Memory scrubbing to detect and correct single-event upsets from cosmic radiation
- Command uplink with checksum verification and replay protection
- All state machine transitions logged to persistent flash before execution
- Graceful degradation: if a subsystem fails, the system continues in reduced-capability mode rather than halting

---

## Estimated Build Time and Cost

| Component | Time | Cloud Cost/Month |
|---|---|---|
| DB schema + Supabase setup | 2 hours | $25 (Pro) |
| Reservation + Stripe integration | 1 day | $0 (Stripe takes %) |
| Mission control dashboard | 3 days | $20 (Vercel Pro) |
| Factory state machine | 1 week |, (embedded) |
| Brick QC model training | 2 weeks | $500 (GPU cloud) |
| Telemetry ingestion API | 3 days | $30 (Fly.io) |
| **Total software stack** | **~4 weeks** | **~$575/mo** |
| **Moon Factory hardware** | **6 years** | **$300M+** |

The software is a month of work. The Moon is not.