The Architecture of Spisce: Building a 10-Stage AI Pipeline for Cinematic History

When people see AI-generated video, they usually assume the workflow is a simple, one-time operation: type a prompt into an interface, wait, and get a video.

That is not how Spisce works.

Spisce is a short-form video platform built for intellectually curious people—specifically addressing the massive trust deficit on platforms like TikTok and YouTube, where algorithms structurally reward exaggerated drama over truthful, nuanced storytelling. To date, this project has generated 1.55M organic views and an elite 80%+ Average View Duration (AVD) on 80-second videos.

To achieve that level of retention without sacrificing historical truth, you can't rely on a basic LLM wrapper or a single "living assistant" agent. You need a highly orchestrated, multi-stage production pipeline.

As a solo software engineer, I didn’t just build an automated content farm; I built a deterministic, Human-in-the-Loop (HITL) engine that bridges code, LLMs, and heavy compute. Here is the actual architecture under the hood.

Stage 1 & 2: Narrative and Scripting

It starts with source material. An LLM ingests the historical text and is instructed to extract the most compelling thesis. It doesn't just spit out one idea; it returns structured data: [option 1, option 2, option 3, recommendation].

From here, the system relies on either a Human-in-the-Loop (me, approving the direction) or an "auto-mode" that runs the recommendation against a strict internal criteria list. Once the narrative direction is locked, it moves to the Script Stage.

Scripts are generated under strict character constraints (e.g., maximum 1300 characters for short-form) using context prompts. Raw LLMs are terrible at counting characters, so a separate validation tool checks the length. For longer formats, the pipeline loops through an "Act Stage" first, outlining the pacing before drafting the final text.

Stage 3: Voiceover and Literal Translation

You can’t just feed standard text to an API and expect perfect historical pronunciations. If you write "Louis," an AI might say "Lou-is" instead of "Lou-ie." If you write "1715," it might say "one thousand seven hundred and fifteen" instead of "seventeen fifteen."

Before the script hits the ElevenLabs API, it is passed through a literal pronunciation translator. This ensures total phonetic consistency across every single video.

Stage 4: The Interval Stage (Temporal Anchoring)

Once the audio and SRT files are generated, the system passes them through a specialized interval prompt. This breaks the voiceover down into specific interval lengths.

Because we aren't generating "talking head" videos yet, we need to programmatically map exactly what is happening when on screen. This interval logic becomes the backbone for the video’s pacing, passing precise timestamps down the pipeline.

Stage 5 & 6: Visual Story and Composition

The visual generation process is arguably the most complex part of the pipeline.
First, an LLM generates three cinematic narrative directions for the visuals, again outputting a structured array for HITL or auto-mode selection.

Then comes the Composition/Prep Stage. Flowery, descriptive LLM language actually confuses image models. So, the pipeline runs the visual ideas through an "Image Translator" tool, converting beautiful cinematic concepts into mechanistic, literal prompts for models like Midjourney (v6/v7) and Flux 2.

This stage also extracts Character and Setting Reference Prompts. This requires immense context anchoring. We need the system to understand that a historical figure looks different at the start of their life versus when they are about to be hanged. We also use temporal context prompts so the model doesn’t accidentally render a 19th-century scene with a modern Toyota RAV4 in the background.

The output is a highly structured JSON array ready for generation:
[{shot: 1, prompt: "...", ref:[{type: "person", llm_identifier: "louis xiv", image: url}]}, ...]

Stage 7 & 8: Image and Video Generation

With mechanistic prompts and reference images locked, the system calls our primary image models (including Gemini 3 Pro for spatial consistency).

Once the base frames exist, they are passed to third-party video models (like Veo 3.1, Kling 3, or Wan 2.2). Because AI video models often struggle with jarring transitions, I use a framework I call FFLF (First Frame, Last Frame).

A multimodal LLM analyzes the first frame and last frame of a shot, alongside their prompts, to generate a "Bridge Composition." It creates a First-Frame-to-Bridge-Frame, and then Bridge-Frame-to-Last-Frame transition (FFBFLF). Combined with specific camera movement parameters (speed ramps, pans), this creates smooth, cinematic motion instead of random AI morphing.

Stage 9 & 10: Music and Assembly

Context from the era is passed into a Suno prompt to generate historically resonant music, timed exactly to the voiceover intervals.

Finally, the Assembly Stage combines the generated video clips, voiceover, music, and brand-aligned caption overlays. (Currently orchestrated via Python into CapCut for final QA, but transitioning to a 100% programmatic FFmpeg render). Sound effects are currently handled contextually, but the next evolution involves running multimodal models over the final frames to inject precise, timestamped SFX programmatically.

Why Build This?

When my 66-year-old father watched one of my historical videos, he loved it, verified it on Wikipedia, and told me: "If I ever find out you are lying, I can never trust you again."

That is the entire thesis of Spisce.

Platforms like YouTube and TikTok are structurally incapable of serving intellectually curious users consistently because their algorithms demand sensationalism for raw retention.

By building this 10-stage AI pipeline, I’ve created a zero-cost production engine capable of generating TV-quality, heavily researched deep-dives. We are currently capturing a starved audience on rented algorithmic land with the ultimate goal of funneling them into our own native 9:16 app—the definitive, trusted environment for bite-sized learning.

AI isn't about letting a single agent run wild. It’s about building the exact deterministic architecture needed to tell the truth, beautifully, at scale.