From Romergo development
From endless revisions to a film set: how I’m learning to generate stories
In the previous article, I wrote about why a working visual novel needs a whole process between the source text and the finished game: preserve the facts, prepare the characters, assemble the scene and look at what the player actually sees.
Since then, that process has become more complicated. Not because I wanted to invent a few more impressive names for AI. While creating stories, I kept running into an unpleasant problem: it’s easy to lose a good image while trying to make it a little better.
First you ask for a hand to be fixed. Then for a piece of clothing to be restored. Then for an extra leg to be removed—yes, that happens too. Eventually you notice that, through all these revisions, the face has changed, the shadows have darkened and the clean background has turned muddy.
You fix one area while the entire image keeps changing. At some point you have to admit: it looked better five versions ago.
Fixing an image doesn’t mean preserving it
A major frustration for me is the accumulation of changes. We start with image A, make B from it, then C from B, and continue for several more attempts. Each new version inherits both the intended correction and everything that quietly changed before it.
In my generations, faces would “melt,” shadows became heavier, artifacts appeared on surfaces and small details disappeared. The next frame isn’t necessarily worse every time. But a long chain of revisions offered far too many opportunities to drift away from the original look.
To a person, “keep everything the same, just turn the head” sounds obvious. We recognise the character, understand the room and assume the jacket stays on even if nobody mentions it again. With the generator, those things need to be negotiated explicitly. It can produce a convincing new image while breaking something we took for granted.
So yes, much of the work is learning to negotiate with AI. Sometimes that literally means explaining that we still don’t need a third leg.
GENERAL: somewhere to return to
My first response was GENERAL: an approved reference image of a character, place or object. As neutral as possible, with permanent features clearly visible and few details specific to one episode.
From there, I try to avoid an endless chain of “latest revision → next revision.” A new state is created from GENERAL, taking into account what should be happening now.
When revising a scene, the task can have three points of reference:
- GENERAL establishes what the character or place looks like;
- the previous frame helps preserve the desired pose, composition or state;
- the complete requirements describe the intended result, including the new correction.
The previous version remains a secondary reference. It shouldn’t quietly become the new standard, complete with all its accumulated mistakes.
*This illustrates the approach, rather than comparing real generations. GENERAL provides a stable reference point, but doesn’t guarantee that every pixel will remain unchanged.*
There’s no magical way to stop a generator making mistakes. But there is now a clear answer to “what do we return to when everything starts drifting?” The purpose of a correction also changes: create the scene we need with the same character, rather than simply edit the latest unsuccessful version.
Render Eye: what exists in the world and what appears in frame
The next problem was more subtle. Suppose we have a well-described character: jacket, gloves, belt, boots. Right now, though, the shot is waist-up, one hand is behind their back and a door obscures part of their body.
Which details should be drawn? Which should be hidden? And how do we distinguish a hidden glove from one the generator simply forgot?
That’s why I’m developing Render Eye. It has two jobs: prepare requirements before generation and inspect the resulting image afterwards.
First it consults the story bible: saved descriptions of characters, locations, objects and their states. It then compares them with the staging—the camera position, the action and what should attract the player’s attention.
Each important detail receives a decision: fully visible, partly visible, obscured by another object or outside the frame. If a hand is behind someone’s back, the glove doesn’t disappear from the world. It just can’t be inspected from this angle.
This produces a specific brief for the frame. Not just “draw the hero in a corridor,” but “this hero, in these clothes, from this viewpoint, with these details visible.” If an object is necessary to understand the scene, it mustn’t accidentally be hidden beyond the image’s edge.
After generation, Render Eye returns to that same brief. It checks clothing, objects and character placement, and separately checks anatomy and artifacts. A detected error or uncertainty sends the image back for revision. It mustn’t accept a missing jacket and then rewrite the character description as though the jacket had never existed.
It’s important not to give the system imaginary superpowers. The image is being examined by AI, which can also miss things. An obligatory check makes the process more disciplined; it doesn’t turn a vision model into an infallible observer.
The director: why do we need this particular frame?
You can draw the clothes correctly, preserve the face and place every character properly—and still end up with a bland scene.
A story is more than the things present in it. It matters when the player notices them, which line comes first, how much time a reaction gets and what can be heard at that moment.
That led to a separate director role. It works close to the scene itself: ordering dialogue and reactions, deciding character presence, lighting, colour, music, sounds, pauses and interface composition. The source text remains working material throughout the process, rather than a brief read once at the beginning.
Take an imaginary sentence: “Footsteps could be heard behind the door.”
We could simply show a door and display the text. Or we could fade out the music beforehand, keep a quiet room ambience, let the footsteps sound offscreen, linger on the character’s reaction and only then continue the conversation. If the source hasn’t revealed who arrived, the camera shouldn’t helpfully show that person.
In a mystery, that same corridor might draw attention to a clue; in a romantic scene, to the anticipation of a meeting. The difference comes from specific decisions. Adding “mood: horror” to a brief doesn’t achieve that on its own.
The director saves these decisions in a staging plan. Facts from the work remain separate from interpretation: cold light can be an artistic choice; introducing a new pursuer changes the events.
Games have another complication: players read at their own pace. A pause before a line and waiting for someone to finish reading it are different things. You can’t plan a beautiful four-second moment and close the text on someone who needed six.
I also don’t want to replace a bland scene with a mechanical collection of effects. Sometimes the right choice is a still frame, a simple cut and no music. A technique needs a purpose.
The quality director: did we achieve what we intended?
The names “director” and “quality director” sound almost identical, but I separate their responsibilities. The director stages the scene. The quality director checks the result.
It compares the source and staging plan with what actually ended up in the game, examining the finished sequence rather than just individual attractive images.
Has the interface covered an important object? Did the listening character disappear when the dialogue changed? Is music from the previous room playing? Did the composition fall apart on a phone? Does the scene convey the tone that motivated the lighting, pauses and sound?
A useful check also needs to know where to send the problem. A defect inside an image belongs back in generation. If a good character image is badly positioned onscreen, the assembly needs adjusting. A sound that starts too early doesn’t require the background to be redrawn.
*In the diagram, Director is the staging director and QA is the quality director. The diagram is simplified: the source remains a reference during assembly and final review. The return arrow means revising the affected stage, not necessarily restarting the entire job.*
People shouldn’t have to stand watch over the generator either
Even when images arrive faster, another cost remains: constantly switching attention. Open the chat, look at a frame, leave a comment, return to your work. A few minutes later, do it again.
That’s another area I’m working on: GENERAL in batches. Independent reference images can be prepared in advance and brought to a person as a group. They can view them together, notice inconsistencies and leave shared or individual feedback.
Only the necessary frames are then revised. Approved images shouldn’t be lost because of one failed attempt. Dependencies still matter: if the next image relies on a reference that hasn’t been accepted, that reference needs resolving first.
This isn’t a promise to make the generator itself several times faster. What matters more to me is reducing how often someone has to drop what they’re doing for another review.
A small film crew instead of one enormous instruction
In the end, I really am trying to assemble a small AI film crew. It has a described world, reference images, staging, frame production, assembly and quality control.
These are responsibilities within an agent’s workflow. That doesn’t automatically mean each role already has its own continuously running AI. What matters is that decisions are saved, requirements aren’t changed retrospectively and each revision makes it clear what needs checking again.
The new stages now have tools and persistent plans behind them. Next comes testing them on real, long chapters: how much do they help preserve characters, mood and the author’s attention throughout a story?
My ultimate goal is to bring a large book, choose a chapter and progressively turn it into a playable quest. With the freedom to stop, inspect the result, correct what matters and continue where the work left off.
Generating stories has proved much harder than “write a good prompt.” But I can now break that difficulty into specific tasks. Sometimes we need a stable reference, sometimes careful reading, sometimes silence before a line. And sometimes we still need a person to look at the scene and say: “No, I don’t believe you here.”