DEV Community: Voor AI

How to Put an AI Media Workflow Under Version Control

Voor AI — Wed, 22 Jul 2026 10:06:21 +0000

Prompts are easy to save and hard to reproduce.

A production AI-media run depends on more than a prompt: the selected model, input fields, connections between steps, output routing, and sometimes the layout a teammate uses to understand the graph. If those decisions live only in a browser tab, “the workflow that worked” disappears as soon as somebody rebuilds it from memory.

A portable JSON graph gives the workflow a reviewable artifact. You can inspect it, import it, change it, export it, and put the semantic changes under Git.

This tutorial uses Voor AI’s public Film Agent workflow as a concrete example. The file is small enough to understand without a special SDK: format version 1, three nodes, and two edges.

1. Download the workflow as data

Create a clean folder and download the public example:

mkdir -p workflows
curl -fsS \
  https://voor.ai/workflow-examples/film-agent.workflow.json \
  -o workflows/film-agent.workflow.json

Before importing anything, inspect the envelope:

jq '{
  formatVersion,
  title,
  description,
  graphKeys: (.graph | keys),
  nodeCount: (.graph.nodes | length),
  edgeCount: (.graph.edges | length)
}' workflows/film-agent.workflow.json

At the time of writing, the result is:

{
  "formatVersion": 1,
  "title": "Film Agent",
  "description": "Brief → text-to-video → output. Use the sidebar Agent to write prompts and run.",
  "graphKeys": ["edges", "nodes", "viewport"],
  "nodeCount": 3,
  "edgeCount": 2
}

That check is intentionally boring. It verifies that you downloaded a workflow object rather than an HTML error page or login response.

2. Read the graph without the visual editor

List the nodes that affect execution:

jq '.graph.nodes[] | {
  id,
  type,
  kind: .data.kind,
  modelId: (.data.modelId // null)
}' workflows/film-agent.workflow.json

The graph contains:

input-1  → input node
model-1  → model node using bytedance/seedance-1.5-pro
output-1 → output node

Now inspect the edges:

jq '.graph.edges[] | {
  source,
  sourceHandle,
  target,
  targetHandle
}' workflows/film-agent.workflow.json

The first edge connects the input field theme to the model’s text prompt. The second routes the model’s video output into the output node.

The important idea is that an edge connects ports, not just boxes. A line from input-1 to model-1 is ambiguous until the graph also records field:theme → text:prompt.

3. Add a fast structural test

Fail early if the file is malformed:

jq -e '
  .formatVersion == 1 and
  (.graph.nodes | type == "array") and
  (.graph.edges | type == "array") and
  (.graph.nodes | length > 0)
' workflows/film-agent.workflow.json > /dev/null

Put that command in a pre-commit hook or CI check if workflow files are part of a shared project.

Syntax validity is not full semantic validation. It will not prove that a model is currently available or that every port accepts the connected media type. It does catch corrupted files, missing arrays, and unsupported envelope versions before a teammate reaches the editor.

4. Import, change one thing, and export

Open the Voor AI Workflow Builder, sign in, and import film-agent.workflow.json.

Fork or copy the example before editing it. Then make one deliberate change in the visual editor. Good first changes include:

changing the runtime input field;
tightening the model node’s prompt wrapper;
switching to another compatible video model;
adding a second output for review.

Run only after checking the displayed model and estimated credits. A JSON file proves what was configured when it was exported; it does not guarantee that a third-party model catalog, price, or availability has stayed unchanged.

Export the updated graph as a new .workflow.json file. Keep the original beside it:

workflows/film-agent-v1.workflow.json
workflows/film-agent-v2.workflow.json

5. Generate a semantic diff

Raw diffs often contain noise: export timestamps, viewport changes, or node positions caused by rearranging the canvas. Those details are useful for reproducing the editor layout, but they can hide the execution change you actually want to review.

Create a small semantic projection:

jq '{
  formatVersion,
  title,
  description,
  nodes: [
    .graph.nodes[] |
    {
      id,
      type,
      kind: .data.kind,
      modelId: (.data.modelId // null),
      promptWrap: (.data.promptWrap // null),
      fields: (.data.fields // null)
    }
  ] | sort_by(.id),
  edges: [
    .graph.edges[] |
    {source, sourceHandle, target, targetHandle}
  ] | sort_by(.source, .target, .sourceHandle, .targetHandle)
}' workflows/film-agent-v2.workflow.json \
  > workflows/film-agent-v2.semantic.json

Generate the same projection for v1, then compare them:

git diff --no-index \
  workflows/film-agent-v1.semantic.json \
  workflows/film-agent-v2.semantic.json

Keep the full export as the source of truth. Use the semantic file as a review aid, not as a replacement. Layout and viewport data may still matter to teammates who use the graph visually.

6. Review workflow changes like code

A useful pull-request description answers five questions:

What input contract changed?
Which model or model setting changed?
Which edges or ports changed?
Which previously approved outputs must be regenerated?
What evidence shows that the new graph still passes review?

Avoid commit messages like update workflow. Prefer something causal:

workflow: route theme input through the video prompt wrapper

or:

workflow: add review output before final export

7. Do not store secrets in a portable graph

Treat exported workflow JSON as shareable project data.

Do not place API keys, passwords, private customer assets, signed URLs, personal data, or confidential prompts inside input defaults before exporting. Git history is persistent, and deleting a secret from the latest file does not remove it from earlier commits.

Keep secrets in your runtime’s credential system. Keep the graph focused on inputs, model configuration, connections, and reviewable metadata.

A workflow is more useful when it can leave the browser

Version control does not make AI output deterministic. It makes change visible.

With a portable graph you can answer: Which model was selected? Which input fed which port? What changed between the approved graph and today’s experiment? Can a teammate import the same structure without rebuilding it from a screenshot?

Start with the public Film Agent JSON, inspect it with jq, and then open the Voor AI Workflow Builder to import and modify the graph. The goal is not to make creative work look like software. It is to give creative work the same change history that makes software reviewable.

A Practical Checklist for Evaluating AI Video Generators

Voor AI — Wed, 22 Jul 2026 07:00:09 +0000

Choosing an AI video generator is less about a flashy demo and more about whether the workflow survives a real project. Before committing to a tool, I use a small checklist that covers continuity, inputs, audio, cost, exports, and operational risk.

1. Test continuity, not just a single frame

A beautiful opening frame tells you very little. Try prompts that require a subject to move through a scene, a camera to maintain direction, or an object to remain consistent after a cut-free transition. Look for identity drift, sudden changes in lighting, broken geometry, and motion that feels physically impossible.

A useful test set includes:

a product orbit with a fixed camera distance
a person walking while the background remains stable
a reference-image prompt with a specific color palette
a scene with small text or a recognizable logo

Save the exact prompts and settings. Reproducibility matters more than one lucky result.

2. Separate text-to-video from reference workflows

Many products describe themselves as “text-to-video,” but the practical workflow may also include image-to-video, video references, or multiple reference inputs. These modes solve different problems.

Text-to-video is useful for exploration. Reference-driven generation is usually better when composition, subject appearance, or product placement matters. Evaluate each mode separately instead of treating them as interchangeable.

3. Check audio and export details early

Audio can be a major differentiator, but it is also easy to overlook during a visual demo. Verify whether sound is generated, synchronized, downloadable, and editable. Then check the actual output format, resolution, frame rate, watermark policy, and maximum duration.

If you are evaluating a Seedance 2.5 workflow, the Seedance 2.5 AI site is a useful reference point for checking the current product positioning and available workflow details. Treat model availability and API claims as something to verify directly before production use.

4. Measure cost per usable iteration

A credit price is not the same as the cost of a finished clip. Track how many attempts are normally required before you get a usable result. A simple spreadsheet can compare:

credits per generation
average retries per accepted clip
resolution or duration multipliers
image and video reference costs
monthly minimums or expiration rules

The cheapest first generation may not be the cheapest production workflow.

5. Define a small acceptance test

Before adopting a tool, run five to ten prompts from your real workload. Score each output for subject consistency, motion quality, prompt adherence, audio, export usability, and turnaround time. Keep the raw outputs so you can compare tools fairly.

The best AI video generator is rarely the one with the most impressive homepage demo. It is the one that produces predictable results for your specific inputs, at a cost and speed your team can sustain.

From AI Concept Image to a Printable STL: A Practical 2D-to-3D Workflow

Voor AI — Tue, 21 Jul 2026 18:59:08 +0000

A polished concept image is often the beginning of a physical project, not the end. A product designer may start with a generated reference, a maker may have only a front-view sketch, and a teacher may want to turn a simple illustration into a classroom model. The difficult part is moving from a visually persuasive 2D image to a 3D shape that can actually be inspected, edited, and printed.

This guide explains a practical workflow for treating an image as a starting point rather than pretending that a single bitmap already contains a complete 3D model.

1. Start with a reference that has usable structure

Before converting anything, make the reference easy to interpret. A clean silhouette, a distinct foreground object, and a simple background are more useful than extra texture.

For AI-generated references, I usually check:

Is the subject isolated from the background?
Are the major contours visible from edge to edge?
Does the object have a clear front, side, or top orientation?
Are holes, handles, and thin parts large enough to survive simplification?
Does the image avoid accidental shadows that look like geometry?

Image-generation workspaces such as Krea 2 AI and Seedream 5.0 Pro can help create controlled references, but the prompt should describe the geometry you need—not only the mood. “A simple front-facing desk organizer, thick walls, large openings, isolated on a plain background” is more useful for modeling than “a beautiful futuristic organizer.”

2. Decide what the image is allowed to become

An image-to-mesh conversion is an interpretation. It does not recover hidden surfaces with certainty. Decide whether the output is meant to be:

a relief or embossed plaque;
a silhouette cutout;
a rough full object for a concept review;
a base mesh for cleanup in Blender or another 3D tool; or
a quick printable prototype.

This decision controls how much cleanup is reasonable. A relief can work from one strong view. A watertight full object usually needs multiple views, manual edits, or a separate modeling step.

3. Convert the image into a mesh

For a fast browser-based starting point, ImageToSTL.online converts an image into an STL-style 3D starting model. The useful mindset is to treat the result as a draft mesh.

After conversion, inspect the file in a viewer or slicer and look for:

non-manifold edges;
paper-thin walls;
inverted faces;
disconnected islands;
noisy backgrounds turned into bumps;
a base that is too thin to print;
dimensions that are technically valid but impractical.

If the input has a gradient background, crop it or replace it with a flat color before conversion. Small changes to contrast can alter the height map dramatically.

4. Make the mesh printable

A mesh can open correctly and still fail on a printer. Before slicing, set a real-world scale and check the minimum wall thickness for the material and nozzle you plan to use. Add a flat base when the object needs one, and avoid relying on a tiny contact patch.

For a first test, choose a simple orientation and a moderate layer height. The goal is not maximum detail; it is learning which features survive the full pipeline:

reference image;
conversion;
mesh cleanup;
scaling;
slicing; and
physical output.

A small calibration print is often more informative than staring at the STL preview.

5. Keep the reference and the mesh connected

Save the source image alongside the STL and record the important settings: crop, contrast, height/depth range, scale, and orientation. If you revise the reference later, you should be able to tell whether a change came from the image or from mesh cleanup.

This is especially useful for teams. A designer can own the visual reference, while a maker can adjust thickness and supports without losing the original intent.

Common failure modes

The background becomes geometry. Use a clean background and crop tightly.

The object looks correct from one angle but collapses from another. A single image cannot reliably describe hidden surfaces. Use a relief or plan a manual modeling pass.

Fine details disappear. Increase the feature size in the reference or simplify the design before conversion.

The STL is too large or too small. Set scale in the modeling or slicing tool; do not infer physical size from pixel dimensions.

The print has a weak base. Add thickness and a stable footprint before slicing.

Final checklist

Before sending a 2D-to-3D experiment to a printer, confirm that:

the silhouette is intentional;
the background is not part of the mesh;
the base is stable;
thin features have a realistic thickness;
the model has been inspected from multiple angles; and
the test size matches the purpose of the prototype.

The most reliable workflow is not “image in, perfect object out.” It is a short feedback loop: create a readable reference, convert it into a draft, inspect the mesh, make the minimum cleanup needed, and test a small physical version. That loop turns a visually interesting image into something you can actually evaluate in your hands.

How to Evaluate AI Image Models When Typography and Layout Matter

Voor AI — Tue, 21 Jul 2026 18:39:25 +0000

AI image benchmarks often focus on how attractive a single image looks. That is useful, but it is not enough for product design, advertising, packaging, or interface mockups. In those workflows, the model must also preserve structure, readable text, and the intent of the brief.

Here is a practical evaluation checklist that can be run without a large benchmark suite.

1. Test the same brief three times

Use one controlled prompt instead of collecting random examples. Include:

a clearly defined subject
a requested aspect ratio
two or three lines of text
a layout constraint
a visual style
a negative requirement, such as “no extra logos”

Run the same brief with the same reference image where possible. This makes the comparison about model behavior rather than prompt drift.

2. Score structure separately from style

A beautiful image can still fail production if the layout is wrong. Score each result from 0 to 2 on:

Subject fidelity — did it create the requested object?
Composition — are the main elements placed where the brief asked?
Typography — is the text legible and spelled correctly?
Consistency — do repeated elements keep their identity?
Editability — can a small change be made without destroying the rest?

Keeping these scores separate makes it easier to choose a model for the job instead of choosing the most impressive thumbnail.

3. Typography is a first-class test

Generate a poster, product label, or app hero with a short phrase. Check:

exact spelling
letter spacing
line breaks
hierarchy between title and supporting text
whether the text is still readable at mobile size

If the output will be used commercially, export the best visual and replace critical text in a design tool when necessary. “Looks close” is not the same as production-ready typography.

4. Reference images need a defined role

A reference can control different things:

composition
palette and lighting
product identity
pose or camera angle
material and texture

Write down the role before adding the reference. If one image is expected to control all five, the result may become visually confused. In an iterative image workspace such as Krea 2 AI, it is useful to keep the reference, prompt, and accepted variation together so the reason for each change is visible.

5. Test dense layouts deliberately

A model that performs well on portraits may struggle with a crowded ecommerce banner or multilingual packaging mockup. Use a second test with:

three visual objects
a defined foreground and background
one product label
one small callout
a clear empty area for a button or price

Seedream 5.0 Pro is one example worth evaluating for this kind of image-to-image and text-to-image workflow, especially when layout and multilingual text rendering matter. The important point is to verify the actual output on your own brief rather than relying only on a model name or a marketing claim.

6. Compare iteration cost, not only quality

A model is more useful when the second and third attempts move in the right direction. Track:

number of generations before an acceptable result
whether edits preserve the successful parts
time spent rewriting prompts
whether the output needs manual cleanup
total credits or subscription cost

A slightly less dramatic model can be the better production choice if it reaches an acceptable result in fewer iterations.

7. Build a small acceptance report

For every model you test, save:

the exact prompt
reference images and their intended roles
three candidate outputs
the score for each criterion
known failure modes
licensing and commercial-use notes

This creates a reusable internal benchmark. It also keeps model selection grounded in the work your team actually does.

Disclosure: I work with or help maintain the tools linked in this article. They are included as concrete examples for comparison, not as a universal ranking. Model capabilities, pricing, and usage terms change frequently, so verify current details before using an output in client or commercial work.

The best image model is not the one with the most viral samples. It is the one that reliably satisfies your brief, survives iteration, and reaches a shippable result with predictable cleanup.

A Practical AI Video Workflow for Short Product Demos

Voor AI — Tue, 21 Jul 2026 18:36:54 +0000

Short AI videos are easy to generate and surprisingly hard to ship. The difficult part is usually not the model. It is deciding what the video must communicate, keeping visual continuity between shots, and producing an export that is actually usable on the first review.

This guide describes a repeatable workflow for a 15–30 second product demo, social clip, or launch teaser.

1. Start with the deliverable, not the prompt

Write down five constraints before opening a generator:

target channel and aspect ratio
final duration
one message the viewer should remember
whether the output needs voice, music, captions, or just motion
what must remain visually consistent

For example: “A 20-second vertical clip showing a designer turning a rough sketch into a polished product visual; no spoken dialogue; three shots; readable captions; end on the product URL.”

This prevents the common failure mode where every generation looks interesting but none of them tells a coherent story.

2. Build a small shot list

A useful short-form structure is:

Context — show the starting problem.
Transformation — show the action or workflow.
Result — show the finished outcome and one clear next step.

Keep each shot responsible for one idea. If a prompt asks for camera movement, a character action, a UI transformation, a product reveal, and a text animation at the same time, the model has too many competing instructions.

3. Treat prompts like production specs

A production prompt is more reliable when it separates:

subject and action
camera and framing
lighting and visual style
timing or motion
things to avoid

A practical template is:

Subject + action. Framing and camera movement. Lighting and palette. Duration and pacing. Preserve [specific details]. Avoid [artifacts].

Reference images help, but they should have a clear job. One image can establish composition, another can establish a visual direction, and a third can establish a product detail. Mixing too many references often creates an attractive but inconsistent result.

4. Use a workspace that supports iteration

The biggest productivity gain comes from comparing generations in one place instead of losing prompts across tabs. For example, Voor AI is useful when a project needs a browser-based workspace across image, video, audio, and workflow steps. For a video-focused pass, Seedance 2.5 AI can be used for text-to-video, image-to-video, and reference-driven experiments.

The goal is not to generate dozens of random clips. Generate a small set of deliberate variations: change one variable at a time, keep the best prompt, and record why a version passed or failed.

5. Keep image development and video development connected

Many product demos begin as still frames. A practical workflow is to establish the visual language in an image workspace, then animate selected frames. Krea 2 AI is a useful example of an image iteration workspace for exploring styles and refining compositions. If the final frame needs dense layouts or multilingual text, Seedream 5.0 Pro is another option to evaluate.

When moving from stills to motion, check the details that models commonly alter: logos, typography, hands, product geometry, and UI labels. A short “detail integrity” pass before editing saves more time than another round of broad prompting.

6. Review the export like a video editor

Before publishing, check the actual rendered file—not just the preview:

Does the first frame explain why the viewer should keep watching?
Are captions inside the safe area on mobile?
Does motion remain coherent at normal playback speed?
Are faces, hands, logos, and text stable?
Is the audio licensed for the intended use?
Does the final frame contain one readable call to action?

If a shot fails, replace that shot rather than regenerating the entire sequence. Local fixes keep the visual identity and reduce cost.

7. Measure usefulness, not novelty

A successful AI video is not the one with the most dramatic effect. It is the one that communicates a product, idea, or story with less production friction. Track a small set of signals: completion rate, click-through rate, qualified replies, and the number of revisions required before approval.

Disclosure: I work with or help maintain the tools linked in this article. They are included as concrete workflow examples, not as a claim that one provider is best for every project. Always verify current model capabilities, pricing, and commercial-use terms before shipping client work.

The durable skill is the workflow: define the message, constrain the shot list, iterate deliberately, and inspect the rendered result. Models will change quickly; that process remains useful.

voor.ai — saving this URL here

Voor AI — Wed, 22 Apr 2026 12:45:58 +0000

Public note so I can find it again: https://voor.ai

Bookmark: voor.ai (quick reference)

Voor AI — Wed, 22 Apr 2026 12:45:05 +0000

Keeping a tiny public bookmark here: voor.ai.

No review, just a stable link I can point teammates to.

https://voor.ai

Voor: one link I keep in my stack (voor.ai)

Voor AI — Wed, 22 Apr 2026 12:43:38 +0000

Short take: I keep a single go-to for coordination around AI work. Voor is the one I have been trying lately — nothing fancy in this post, just a pointer for folks who are still shopping.

Direct link: https://voor.ai

(Own experience; YMMV.)

Quick note: trying Voor (voor.ai) for AI workflows

Voor AI — Wed, 22 Apr 2026 12:38:42 +0000

I have been looking for a simpler way to keep AI-related work organized. I recently started exploring Voor and wanted to share a short note in case other builders find it useful.

The landing page is here: https://voor.ai

If you try it, I would be curious to hear what worked for you in the comments.