The Procedural Fog Machine

2026-05-02 • 7 min read

An AI experiment in procedural overload, longform document generation, and the economics of slop.

I built The Procedural Fog Machine for the Slow Ventures Slop Cannon hackathon on May 2, 2026. It was conceived, designed, and built in roughly six hours.

Try the live demo

The app takes a simple dispute, complaint, or bureaucratic problem and turns it into a massive structured response packet: formal language, procedural sections, factual questions, appendices, escalation paths, and enough institutional texture to make a copier sigh.

It is satirical and experimental. It is not legal advice, and it is not intended to generate filings, threaten anyone, or abuse formal processes. The project is a builder artifact about controlled excess, AI-native UX, prompt orchestration, streaming generation, and the economics of cheap longform output.

The Procedural Fog Machine command dock, showing the live app interface and status panels.

The app presents generation as a command dock: source material in, procedural fog out.

The Idea

The central joke is simple: what if the best way to respond to bureaucracy was with even more bureaucracy?

Many institutions rely on process asymmetry. A person receives a confusing notice, automated rejection, legal threat, or administrative demand, and the burden shifts to them to respond clearly, formally, and thoroughly.

The Procedural Fog Machine flips that dynamic as a product experiment. Instead of optimizing for concision, it explores what happens when an AI interface intentionally produces structured overproduction.

Product Concept

The user describes a situation in plain English, then chooses a “slop level” that controls how large and elaborate the output should be.

The slop density controls set to maximum bureaucracy with the fire button armed.

The slop density control turns output size into part of the product interaction.

Depending on the prompt and setting, the generated packet can include formal response letters, procedural objections, request-for-information sections, escalation timelines, compliance-style matrices, factual clarification questions, appendices, footnotes, supporting documentation checklists, and passive-voice institutional language.

The goal was not to build a serious legal product. It was to test a product mechanic: controlled excess as an interface primitive.

Most AI writing tools try to summarize, simplify, or compress. The Procedural Fog Machine asks what becomes possible when the product is designed to generate a lot of coherent structure on purpose.

How It Works

The app uses a natural-language front end. The backend generation flow runs in stages:

The user describes the situation and sets the desired level of procedural excess.
The app turns that input into an outline for a full response packet.
The selected slop density controls how many sections the packet should contain and how expansive each section should be.
Each section is generated separately, then streamed back into the interface as it is written.
The preview assembles those streams into a single formal packet, so the user can watch the document take shape.
At the maximum setting, the app runs a second pass that adds supplemental material to each completed section.

This makes the system more reliable than asking one model to produce the entire document in a single pass.

The app generating sections, with status cards and a live shell log updating during generation.

Streaming status and shell-log copy make the long generation feel like an artifact being assembled, not a chat response waiting to finish.

Why the Architecture Matters

A naive version of this project would ask a single model to “write a huge bureaucratic document.”

That approach is brittle. It tends to lose structure, repeat itself, or collapse into generic filler. The Procedural Fog Machine instead decomposes the output into an outline, streamed sections, and optional max-density addenda. That gives the system more control over length, pacing, structure, and tone.

The project is intentionally absurd, but the underlying pattern is useful: for longform AI generation, orchestration matters as much as prompting.

The quality of the output depends on model choice, but also on how the system breaks the task apart, routes each stage, streams progress, and preserves a clear document shape for the user. The implementation is deliberately modular: outline generation, streamed section generation, fallback generation, and maximum-density expansion are separate pieces of the pipeline.

A generated procedural response packet with dense sectioned output and status metrics.

The generated packet keeps a formal document shape even as the output gets intentionally excessive.

Inference Economics

One of the most interesting parts of the build was how cheap large-scale text generation has become.

Using low-cost, high-throughput models through OpenRouter, the app is designed around a striking cost curve: very large structured packets can be generated for a fraction of a cent when routed to inexpensive section-generation models.

That changes the product design space. When longform generation is expensive, products optimize for brevity. When longform generation becomes nearly free, new interaction patterns become possible: procedural packets, generated dossiers, synthetic documentation, simulated institutions, narrative worlds, fake compliance systems, and other forms of structured abundance.

The Procedural Fog Machine is tongue-in-cheek, but it points at a real shift: AI makes it possible to generate enormous amounts of legible structure on demand.

What I Learned

AI UX is not just chat. The experience depends on pacing, streaming, loading states, section structure, and how the output reveals itself. This project worked best when it felt like a machine generating an artifact, not just a chatbot answering a prompt.

Longform generation needs decomposition. Breaking the output into outlines, streamed sections, and optional addenda produced better structure than a single large generation call.

Model selection is a product decision. The app keeps outline and section models configurable, which makes routing a product lever rather than a hardcoded assumption.

Cost curves create new product surfaces. When large packets of coherent text can be generated cheaply through model routing, “generate a lot of structured material” becomes a viable design primitive.

Absurd products can still teach serious lessons. The project was playful, but it was a useful way to explore prompt orchestration, streaming UX, inference cost, model routing, and AI-native product design under a tight build constraint.

Stack

Next.js app deployed on Vercel, with the interface, generation controls, live log, and packet preview handled in the client.
Natural-language input form for the dispute, optional source context, domain, stance, and slop density.
Split API routes for each generation stage: one route creates the outline, another streams section bodies, and a separate max-density route expands completed sections.
OpenRouter for model routing, so outline generation and section expansion can use different models without changing the product code.
Grok for high-level packet outlining, where the model’s job is to plan the structure before generation begins.
DeepSeek v4 Flash Nitro for streamed section writing in production, optimized for fast, low-cost longform expansion.
Streaming response handling that converts section output into incremental chunks the UI can assemble into the live document preview.
Density planning logic that maps the slop slider to section count, target length, and token budget.
A density-11 expansion pass that sends completed sections back through the section-writing model to generate supplemental addenda.