PROMPTBLOX

user prompt
     │
     ▼
┌─────────────────┐
│   CLASSIFIER    │ ──► trigger-eval tests
│  (LLM, intent)  │     (CI-gated regression)
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│    RESOLVER     │ ──► single source of truth —
│ (data-driven)   │     routing, aesthetics,
└────────┬────────┘     archetypes, decoration
         │
   ┌─────┼─────┬─────┐
   ▼     ▼     ▼     ▼
 ┌────┐┌────┐┌────┐┌────┐
 │STRU││DECO││ASSET││SCRIPT│
 └──┬─┘└──┬─┘└──┬─┘└──┬─┘
    │     │     │     │
    └─────┴──┬──┴─────┘
             ▼
     ┌───────────────┐
     │   STITCHER    │
     └───────┬───────┘
             ▼
     playable game file

legend:
  STRU   structure gen — deterministic TypeScript
  DECO   decoration — LLM code-gen + theme context
  ASSET  asset pipeline — self-hosted GPU 3D + texturing
  SCRIPT script injector — gameplay snippets + runtime APIs

# How features actually ship.

┌──────────────┐
│   PLANNER    │ ──► plan doc on disk
└──────┬───────┘
       │
       ▼
┌──────────────┐
│ ENGINEER A   │ ─┐
├──────────────┤   │
│ ENGINEER B   │ ─┤──► REVIEWER ──► PASS / FAIL
├──────────────┤   │                        │
│ ENGINEER C   │ ─┘                        │
└──────────────┘                            ▼
  (file-claim                  parent merges
   isolation,                          │
   parallel)                            ▼
                                   production deploy

// Intent classifier — LLM returns a 4-way decision.
// Output schema is validated before anything downstream touches it.

export async function classifyPrompt(prompt: string): Promise<ClassifierResult> {
  const { object } = await generateObject({
    model:  /* frontier LLM */,
    schema: ClassifierSchema,
    prompt: buildClassifierPrompt(prompt),
  });

  // Ambiguous prompts trigger a clarifying-question conversation loop
  // before anything expensive runs.
  if (object.intent === "ambiguous") {
    return { intent: "ambiguous", questions: object.questions };
  }

  // Resolver: single source of truth for prompt -> pipeline.
  // Versioned as data, not baked into code paths.
  const routed = await resolve(prompt, object);
  return { intent: "clear", ...routed };
}

// LLMs design (WHAT), TypeScript builds (WHERE).
// Spatial archetypes replace O(n) template duplication with
// a small set of parameterized layout algorithms.

export function generateStructure(spec: GameSpec): GameState {
  const archetype = ARCHETYPES[spec.archetype];
  const parts: Part[] = [];

  for (const zone of spec.zones) {
    const layout    = archetype.layoutFor(zone);
    const obstacles = pickObstacles(zone);

    for (const slot of layout.slots) {
      parts.push(placePart(obstacles.next(), slot, zone));
      // position is computed, never LLM-predicted — avoids
      // the spatial-reasoning failure mode entirely.
    }
  }

  return { parts, scripts: collectSnippets(spec) };
}

# Self-hosted GPU worker: text prompt -> textured 3D mesh.
# Exact model chain, timeouts, and cache-key strategy redacted;
# the architectural point is the separation of concerns.

@app.cls(gpu="…")
class MeshWorker:
    @modal.enter()
    def load(self):
        self.geometry_model = load_geometry(…)   # text -> untextured mesh
        self.texturing_model = load_texturing(…) # image -> PBR texture

    @modal.method()
    async def generate(self, prompt, theme):
        if hit := await cache.get(prompt, theme):
            return hit                         # warm path

        mesh    = self.geometry_model.run(prompt)
        concept = await render_concept_image(prompt, theme)
        glb     = self.texturing_model.run(mesh, concept)
        return await cache.put(prompt, theme, glb)