Skill

Tune visual parameters with vision-model feedback loops

A vision-model optimization loop that tunes parameters when success is subjective appearance or feel, not a numeric metric, using labeled variants and

Works with claude

Maintainer of this project? Claim this page to edit the listing.


78
Spark score
out of 100
Updated last month
Version 1.0.0
Models
universal

Add to Favorites

Why it matters

Automate the trial-and-error tuning of visual parameters-color grades, easing curves, spacing, motion timing-by having a vision or video model judge rendered variants in a tight loop, rate them against a rubric, and suggest better values until the output looks or feels right.

Outcomes

What it gets done

01

Render multiple parameter variants into a single labeled contact sheet or video sequence

02

Send one artifact to a vision model that scores each variant and returns structured JSON suggestions

03

Iterate coarse-to-fine over ~2 rounds with calibration anchors to catch bad recommendations

04

Converge on the best parameter set when the top-rated variant meets the quality threshold

Install

Add it to your toolbox

Run in your project directory:

curl -fsSL https://spark.entire.vc/get/ag-lookdev-auto | bash

Overview

Visual eval loop - let a vision/video model tune what only an eye can judge

Method for vision/video-model-judged parameter optimization when success is perceptual rather than measurable When 'looks/feels right' is the criterion, no numeric metric exists, and you need automated lookdev without a human in the loop

What it does

This skill provides a method for parameter tuning when "looks/feels right" is the success criterion and there's no cheap numeric metric. A vision model (for images) or video-understanding model (for motion/timing) acts as the judge in an optimization loop. The process renders labeled variants into a single artifact, sends it to the model with an explicit rubric, and receives structured JSON output with per-variant ratings and concrete suggested new parameter values. The approach typically converges in 2 rounds: round 1 uses a wide spread to locate the region, round 2 renders the model's suggestions plus the current best to pick the single best.

When to use - and when NOT to

Use this approach whenever "looks/feels right" is the success criterion and there's no cheap numeric metric. Example scenarios include animation easing/timing, zoom/camera feel, color grade, layout/spacing, design params, render/encoder settings, and prompt params. Use it as the automated counterpart to lookdev when there's no human to sit in the loop.

Do NOT use when a real numeric metric exists and correlates with quality - optimize that directly instead of paying a model per step. Skip it when judgment is subjective to the user (their taste, brand) - show them the variants and let them pick, since a model's "best" isn't their best. The source notes that the screen-studio spring auto-tune was dropped because the model's pick didn't match the owner's eye. For one or two variants, just look yourself.

The process

You render N labeled variants into ONE artifact, varying the parameter(s) across a small spread. Parameters are annotated ON the artifact (burn the label in: "A · 2.2Hz · ζ0.5"). Images become a labeled grid/contact sheet; video/motion becomes a labeled sequence with label cards or burned-in overlays so the model can compare temporally.

You send the single artifact with an explicit rubric (define what "good" means and what "too much"/"too little" look like). Ask for per-variant ratings plus concrete suggested new values as JSON: {"ratings":{"A":n,...},"best_so_far":"X","suggest":[[p1,p2],...]}. Round 1 uses a wide spread to locate the region. Round 2 renders the model's suggestions (plus carry the current best) into one artifact and asks it to pick the single best. The loop usually converges in 2 rounds. Stop when sufficient - best rates high and suggestions cluster, then apply the winner.

Worked reference

The source references the screenstudio-alternative skill (iteration.py) which tuned zoom-animation feel via fal-ai/video-understanding.

Who it's for

This approach suits creators and developers who need to optimize subjective visual or motion qualities without manual iteration. The model's pick is an opinion, not ground truth - anchor it and sanity-check the winner against the safe default yourself before committing. Vision/video models perceive gross differences well, fine ones poorly - keep variant spacing perceptible; near-identical variants get noise-rated.

Optimizations and caveats

Use one artifact per round, not one call per variant - a 6-variant round is 1 upload plus 1 inference, not 6. Burn params onto the artifact so the model sees label plus result together. Use structured JSON output and parse it. Tune on a short representative sample (3-5s clip, one frame, one component), not the whole asset. Cap variants at approximately 5-6. Include one deliberately-bad and one safe-default variant as fixed calibration anchors each round. Define "good" concretely in the prompt with an independent rubric. Reuse renders across rounds. Consider early-exit if round-1 top is 9/10 or higher and suggestions are within a small delta. Use the cheapest judge that can see the failure: frames through an image VLM can judge spatial things (layout, color, crop); only reach for a true video model when the thing being judged is temporal (easing, timing, motion smoothness) - those are invisible in stills.

Model ratings are probabilistic aesthetic judgments, not objective truth - keep a human review step for brand-critical or subjective work. Automated rounds can become expensive or slow when renders are heavy or many variants are explored. This approach needs screenshots, frames, or clips that expose the quality difference; it is weak for subtle motion, audio, copy nuance, or user-preference calls.

Source README

When to Use

Use whenever "looks/feels right" is the success criterion and there's no cheap numeric metric - animation easing/timing, zoom/camera feel, color grade, layout/spacing, design params, render/encoder settings, prompt params. Use the automated counterpart to lookdev when there's no human to sit the loop.

Source: connerkward/lookdev-auto-skill (MIT).

Visual eval loop - let a vision/video model tune what only an eye can judge

When the target is "does this LOOK/FEEL right" (not a number you can minimize), a
vision model (image) or video-understanding model (motion/timing) can be the judge in
a tight optimize loop. Worked reference: the screenstudio-alternative skill (iteration.py)
(tuned zoom-animation feel via fal-ai/video-understanding).

The loop

  1. Render N labeled variants into ONE artifact. Vary the parameter(s) across a
    small spread. Annotate each variant's params ON the artifact (burn the label in:
    "A · 2.2Hz · ζ0.5"). Images → a labeled grid/contact sheet. Video/motion → a
    labeled sequence (label card or burned-in overlay before/over each clip) so the
    model can compare temporally.
  2. One model call, structured output. Send the single artifact with an explicit
    rubric (define what "good" means - and what "too much"/"too little" look like).
    Ask for per-variant ratings + concrete suggested new values as JSON:
    {"ratings":{"A":n,...},"best_so_far":"X","suggest":[[p1,p2],...]}.
  3. Coarse → fine. Round 1 = wide spread to locate the region. Round 2 = render the
    model's suggestions (+ carry the current best) into one artifact; ask it to pick
    the single best
    . Usually converges in 2 rounds.
  4. Stop when sufficient - best rates high and suggestions cluster. Apply the winner.

Token / quality / step reductions (do these)

  • One artifact per round, not one call per variant. The biggest saver - a 6-variant
    round is 1 upload + 1 inference, not 6. Montage/grid beats a loop of single calls.
  • Burn params onto the artifact. The model sees label+result together → no separate
    "variant A used X" context to carry → fewer tokens, fewer mistakes.
  • Structured JSON out + parse. No re-asking, no free-text wrangling. Prompt "return
    ONLY JSON"; regex the first {...}.
  • Short representative sample. Tune on a 3-5s clip / one frame / one component, not
    the whole asset. Cheaper render, smaller upload, faster inference. Apply the found
    params to the full render once.
  • Cap variants at ~5-6. More doesn't improve the model's discrimination and multiplies
    render + token cost. Wide-but-sparse round 1, narrow round 2.
  • Calibration anchors. Include one deliberately-bad and one safe-default variant as
    fixed anchors each round - gives the model a reference scale and exposes when its
    "best" is worse than the safe default (catch a bad recommendation early).
  • Independent rubric, stated up front. Define "good" concretely in the prompt
    (smooth, subtle settle, not bouncy, not sluggish). Don't ask "which do you like" -
    that lets it echo your framing. A held-out criterion keeps the judge honest
    (see verify-outputs-rule: the check must be independent of what you tuned).
  • Reuse renders across rounds. Carry the round-1 winner's clip into round 2 instead
    of re-rendering it.
  • Early-exit. If round-1 top ≥9/10 and the three suggestions are within a small delta,
    skip round 2.
  • Cheapest judge that can see the failure. Frames-through an image VLM can judge
    spatial things (layout, color, crop); only reach for a true video model when the
    thing being judged is temporal (easing, timing, motion smoothness) - those are
    invisible in stills.

When NOT to use it

  • A real numeric metric exists and correlates with quality → optimize that directly;
    don't pay a model per step.
  • The judgment is subjective-to-the-user (their taste, brand) → show them the variants
    and let them pick; a model's "best" isn't their best. (This is why the screen-studio
    spring auto-tune was dropped - the model's pick didn't match the owner's eye.)
  • One or two variants → just look yourself.

Caveats (learned)

  • The model's pick is an opinion, not ground truth - anchor it, and sanity-check the
    winner against the safe default yourself before committing.
  • Vision/video models perceive gross differences well, fine ones poorly - keep variant
    spacing perceptible; near-identical variants get noise-rated.

Limitations

  • Model ratings are probabilistic aesthetic judgments, not objective truth; keep a human review step for brand-critical or subjective work.
  • Automated rounds can become expensive or slow when renders are heavy or many variants are explored.
  • This skill needs screenshots, frames, or clips that expose the quality difference; it is weak for subtle motion, audio, copy nuance, or user-preference calls.

FAQ

Common questions

Discussion

Questions & comments · 0

Sign In Sign in to leave a comment.