Project: Veridian Resonance
Role: Technical Creator / Pipeline Architect
Live: https://veridianresonance.com/ The foundation of Veridian Resonance didn't start with a blank canvas; it began as a structured data translation problem. Evolving from a homebrew tabletop campaign, the worldbuilding was initially managed through interconnected markdown nodes in Obsidian and formatted via Homebrewery.
The core engineering challenge was immediately clear: how do you take dense, text-based relational data — complete with established lore, specific game mechanics, and rigid character definitions — and scale it into a full 28-page visual production? Going from isolated session notes to a cohesive digital comic required more than illustration; it demanded a systemic approach to preserve the integrity of the original universe while adapting it for a new medium.
Relying on generic generative models out-of-the-box yields inconsistent, unscalable results. I ran structured A/B testing across multiple aesthetic checkpoints against a clear set of production criteria: consistency across panels, manual rework required, and reproducibility at volume — not aesthetics alone.
Early attempts using "Grim Dark" and "Marvel" styles were rejected against those criteria: while visually detailed, they typically needed 20 to 30 iterations per panel before post-processing to fix hatching and lighting inconsistencies, making them unviable for a multi-page pipeline. The decision was to engineer a strict "Cel-Shaded" visual formula — clean, bold black outlines, flat colors, minimal to no traditional ink shading, and a heavily limited color palette — drawing structural inspiration from Vox Machina and Avatar: The Last Airbender.
Achieving this consistency wasn't just about what to prompt, but what to restrict. I spent iterative cycles optimizing negative prompts to block the model's natural pull toward generic 3D hyper-realism. This constraint engineering established a stable baseline output that could be systematically color-graded and refined using predefined palettes in Krita — turning a one-off aesthetic choice into a repeatable production standard.
Generating a single high-quality image is trivial; maintaining state across 100+ sequential panels is a true architectural problem.
Not every approach got there. Early experiments running local models fine-tuned with LoRA held the target art style well, but made character consistency nearly impossible to maintain across panels — a limitation I later saw resurface with newer Midjourney model versions too. That failure mode is what pushed the pipeline toward a stricter, reference-based system rather than relying on style transfer alone.
Using Nano Banana 2 (an AI image model) alongside character sheets and structured prompt engineering, I built a reproducible template system to hold the visual identity of Kaelith (Kae) stable across the full production run. The technique that ended up working best: maintaining two dedicated character sheets per character — one for the face, one for the full body — which preserved detail fidelity far more reliably than a single reference image. This required granular prompt manipulation to force the model to respect specific, non-standard design choices rather than drifting toward its defaults.
For instance, Krix required iterative structural commands — explicitly instructing the model to adjust his scale — to render correctly as a short goblin rather than drifting back to his base kobold archetype. For Vespera, I enforced rigid asset constraints ("no glasses, no weapon, no glow") to prevent the model from hallucinating default elements that would break visual continuity mid-sequence.
Toward the end of the production run, I identified a further optimization: processing characters and backgrounds as separate generation passes instead of together, since the model reliably struggled to hold fidelity on both at once when combined. It's also worth noting the timing of this work — it predates tools like Google Flow and the native character-locking features now common in mainstream image models. I've since tested several of these, and they would meaningfully simplify parts of this workflow today.
A raw folder of generated images is not a product. To bridge AI output and final layout, I built custom Python and Node.js tooling — regex-driven text parsing and batch-processing routines to handle file management, standardize naming conventions, and prepare assets for assembly.
This wasn't incidental scripting — it was a deliberate decision to treat production-line friction as an engineering problem rather than a manual-labor problem. By automating file handling and running structured find-and-replace text formatting in VS Code, I removed a recurring bottleneck from the workflow, freeing time for the parts of production that actually required human judgment (layout, lettering, art direction in Clip Studio Paint).
Two related decisions were deliberately kept manual rather than automated. Every panel was reworked by hand in Clip Studio Paint to match the target color palette — at this volume, manual correction was faster and more reliable than building and maintaining an automated color-matching step. Each image also passed through a local upscaling model before insertion into CSP, keeping output resolution consistent without per-image manual work.
Estimated time saved: roughly 15 hours across the production run (see TL;DR). That figure is a conservative, defensible one — with 100 panels moving through multiple revision passes for renaming, folder organization, and format prep, even 5–8 minutes of manual file-ops per panel per pass adds up to 8–13+ hours before automation, before accounting for re-runs across revisions.
Scaling the project meant reaching a broader audience, which required a seamless bilingual reading experience — treated as an architectural requirement from the start, not an afterthought.
To keep control over rendering, UX, and performance, I bypassed third-party comic hosts and engineered a custom, mobile-optimized static comic reader. The deployment leverages GitHub Pages for version-controlled static hosting, routed through Cloudflare for low-latency global delivery of high-resolution image assets.
By keeping text/lettering layers strictly separated from base artwork during the Clip Studio Paint layout phase, the project structure stays modular: automation scripts swap English and French dialogue assets at build time, so the static site always serves the correct regional variant without duplicating heavy visual files — avoiding a meaningful storage and bandwidth cost that a duplicated-per-language approach would have carried at this asset volume.
Volume 1 was a successful proof of concept, but it also exposed hard limits of current generative models: weak dynamic spatial reasoning in complex combat scenes, and a ceiling on subtle acting and micro-expressions.
Rather than pushing more prompts at a problem the tooling couldn't solve, I made a deliberate architectural pivot for Chapter 2: a "Human-in-the-Loop" hybrid workflow. Models were repositioned as compositional assistants — generating background studies and perspective drafts — while I took manual control on a Huion Kamvas Pro 16 2.5K pen display, hand-inking final lines, anatomy, and character expressions on vector layers in Clip Studio Paint. This is a resourcing decision as much as a creative one: recognizing where automation adds leverage and where it doesn't, and reallocating effort accordingly rather than over-investing in a tool past its point of diminishing returns.
That technical pivot wasn't the only signal driving the shift. Sharing the work on personal social channels and in niche online communities largely fell flat — posts were ignored, whether due to audience skepticism toward AI-assisted art, algorithmic suppression of AI-tagged content, or both. That distribution signal mattered as much as the spatial-reasoning and micro-expression limits above: technical quality alone wasn't enough to earn attention or trust for this kind of work, so increasing the visible hand-crafted component became both a craft decision and a credibility one.
Veridian Resonance is more than a digital comic; it's a case study in applying software engineering principles — constraint design, automation, and pragmatic build-vs-buy-style trade-offs — to a creative production pipeline. Combining prompt engineering, custom automation, and a deliberate hybrid human-AI workflow, the result is a scalable production process that prioritizes consistency and quality over blind automation. Just as importantly, it's a case study in reading real-world signal honestly — recognizing when technical excellence alone isn't sufficient, and adjusting the approach in response rather than defending the original plan.