dream-loop Review 2026 — The Agent Skill That Builds 3D Scenes by Dreaming a Target Screenshot and Iterating Against a Subagent Judge
✅ Pros
- • Closes the feedback loop that makes 'make it look good' meaningless to an agent: the skill generates a concrete target image first, then a fresh-context subagent judge compares a real live screenshot of the build against that target and returns a score plus blocking directives — the builder is never guessing what 'better' means, it is working a named gap with named magnitudes
- • The judge is engineered against its own failure modes: a gated ladder means a frame cannot score above a tier's cap until every lower gate is fully met (shape, then light and color, then materials, then fine detail), directives must be actionable ('replace the stacked ovoid boulders with one continuous fractured slab, cracks 2-5cm wide' rather than 'the rocks look artificial'), at most four directives per round beyond the blockers, and previous directives are tracked as LANDED / PARTIAL / NOT DONE so the judge cannot contradict itself between rounds
- • Anti-tunnel-vision exit logic: if the best score hasn't improved by a full point in two rounds or the judge names the same gap three times, the skill tells the builder to stop tweaking and make one big structural change — swap the asset strategy, rewrite the lighting model, rebuild the composition — rather than grinding parameters that are capped by an approach-level flaw
- • The concept-art phase encodes hard-won visual taste as rules: prompt for an 'in-engine screenshot' not concept art, forbid both overbaked noise (photographic clutter, film grain, hundreds of unique small objects) and oversimplified cartoon looks, and feed a failure-mode image back to the model to fix it before building starts
- • Follow-up loops upgrade real products: when invoked on an existing build, dream-loop captures a live screenshot of the current product and prompts the image model to render the best possible version of that exact screenshot — so refinements stay anchored to what exists instead of drifting toward a dream
- • Multiple screens can iterate in parallel with separate judge loops, and the skill is honest about cost: it warns up front that without a time budget it may consume a lot of tokens
⚠️ Cons
- • Hard prerequisites that narrow who can run it: the skill needs an agent with image generation (built-in like Codex or Grok, or a Gemini API key), vision input, and subagents (strongly preferred), and the author states it is currently only tested with GPT-6 Astra in Codex — 'other strong models like Claude Fable 5.1 can likely work too' is a hope, not a test run
- • Token-hungry by design: every round means concept art, a build pass, a fresh judge subagent and a self-audit, and without a time budget the loop runs until an exit criterion or a stall — the skill explicitly warns it may consume a lot of tokens and that rounds are expensive, so each one should address most heavy-hitting gaps
- • One day old at review time (created September 7, 2026, single initial commit): there is no versioning, no issue tracker history, and the only evidence of results is the author's demo — impressive, but a single data point from the person who wrote the skill
- • Depends on harness capabilities that vary widely: the skill prefers Blender installed locally for 3D assets and says to delegate complex assets to subagents, but if the harness lacks subagents it falls back to self-judging with degraded results, and if Blender or image generation is missing the skill tells you to stop and ask rather than improvise
- • The judge is only as good as the model: the whole loop leans on a fresh-context critic doing honest, consistent visual comparison, and the skill's own rules admit judges can be 'extremely nitpicky' or ask for intractable things (it cites a judge demanding ray tracing on a GPU-less laptop) — the exit logic handles it, but a weak judge makes the loop expensive noise
Developers and tinkerers with a strong multimodal agent (Codex with GPT-6 Astra today), image generation access, vision and subagents who want to build browser games, Three.js scenes or Blender-assisted 3D demos to a genuinely high graphical standard — and who would rather let an art-director judge with a gated score ladder push the quality than iterate blind
Free and open source (MIT). Install with npx skills add achimala/dream-loop or clone into your agent's skills directory. Runtime costs are whatever your agent stack costs: image generation (built-in to Codex/Grok, or a Gemini API key), vision, and subagents; Blender is optional but preferred for custom 3D modeling. No subscription, no API key of its own, no cloud dependency — the skill is a process, not a service.
The Problem: Agents Can’t See What ‘Impressive’ Means
Ask a coding agent to build a game or a scene with “impressive visuals” and you get a lottery ticket. Without a concrete target and a way to check progress against it, the agent produces something — usually a flat-shaded box with a gradient sky — and declares victory, because nothing in its loop ever tells it the result is ugly. Anshu Chimala’s dream-loop, an Agent Skill created September 7, 2026, treats that as a process bug and fixes it with the oldest trick in creative work: a reference image, and someone strict to compare against. In its first day the repo passed 130 stars on an MIT license.
The loop has four moves: the agent dreams a high-quality target screenshot using image generation; it builds with that target in mind; a separate AI critic (a subagent with a clean context) compares a live screenshot of the build to the target and gives scored, specific feedback; and the agent loops back to building until the critic is satisfied — or, optionally, dreams an even better target based on the current state and starts again.
Dreaming the Target: Concept Art With Guardrails
The concept is meant to be “the look of a current AAA game running in real time”: physically plausible materials (wet stone, brushed metal, cloth, glass) with real roughness and normal detail, correct proportions, atmosphere (fog, haze, rain, dust, volumetric light), cinematic lighting with a clear key and rich shadows. It should not be stylized — it should look like a true screenshot of the ideal result.
The skill encodes two failure modes to avoid when generating that concept. Overbaked: photographic clutter, film grain, hundreds of unique small objects, excessive detail on every surface that starts to look like noise — a real-time build with modeled assets won’t match it, and it won’t look good to the user either. Oversimplified: cartoon or toy looks, flat shading, blobby primitive shapes, empty surfaces. The target is the middle ground: beautiful surfaces and materials that shaders render well, strong atmosphere, a visually interesting palette, and focused hero elements. The skill tells the agent to prompt for “in-engine screenshot” rather than “concept art,” to review the image carefully, and to feed it back to the model for a fix if it hits a failure mode — before any building starts. If the agent generated the art itself, it pauses to confirm the vision matches the user’s before kicking off the build loop.
Building: Make the First Pass Count
The build phase has its own discipline. The agent implements the concept in one go “across every tier of the score ladder,” writes intermediate plans to a .dream-loop folder to stay on track, and — critically — prefers Blender for 3D assets when it’s installed locally, delegating complex assets to subagents. The skill is blunt about the shortcut it forbids: “Do not be lazy and resort to simple shapes or procedural assets for key environmental details like scenery, flooring, buildings, etc. These will look blocky, shiny, flat, and fake.” Image generation is encouraged for textures, normal maps and skyboxes — “this looks better and is faster than procedurally generated ones.”
Before anything goes to the judge, the builder must self-review: look at the candidate screenshot and concept side by side, audit surface by surface, and log an honest assessment of whether the work is judge-ready. “Do not submit half-baked work to the judge.” The screenshot submitted must match the concept’s resolution and aspect ratio so the comparison is fair.
The Judge: A Gated Ladder and Anti-Nagging Rules
Judging is done by a fresh subagent with a clean context each round — “to keep it objective and cheap” — given the latest live screenshot, the concept image and, from round two on, the previous round’s screenshot and verdict. The scoring prompt is the heart of the skill: a 0–10 ladder that is gated, meaning a frame cannot score above a tier’s cap until every requirement of the tiers below it is fully met:
- Tier 1, shape (0–3): camera, framing, composition, position and rough scale of every major object — layout, not finish.
- Tier 2, light and color (3–5): key light direction and color, exposure, shadow depth, palette, contrast, atmosphere, reflections and glows — judged at the level of the whole frame.
- Tier 3, materials and surfaces (5–7): every surface reads as the right material at a glance — texture, roughness, translucency, wetness — and dominant elements must be properly sculpted, not obviously procedural.
- Tier 4, fine detail (7–9): the small things, nitpicked relentlessly, layout near-perfectly aligned with the concept.
- Tier 5, indistinguishable (9–10): holds up side by side and zoomed in.
The judge’s output format is strict: the score on the first line and the tier on the second; then Blocking — the specific things that fail the gate of the next tier, named with magnitudes (“replace the stacked ovoid boulders with one continuous fractured slab; cracks 2–5cm wide, dark interiors, add more texture so they don’t look flat/plastic” — not “the rocks look artificial”); then at most four further directives from higher tiers, ordered by points recoverable. Every directive must be something a developer can act on this round. When a previous verdict exists, the judge is “one reviewer in a sequence, not the first”: it goes through prior directives one by one, marks each LANDED, PARTIAL or NOT DONE, carries forward anything unfinished, and cannot reverse a prior directive unless the result is clearly worse — and then must say so explicitly.
Exit Criteria: When to Stop, and When to Blow Up the Approach
The loop terminates on a score of 8+ with acceptable frame rate. If the score is 8+ but frame rate is unacceptable, the agent optimizes — lossless wins first, then minimal-visual-impact optimizations — and re-judges to confirm it didn’t regress. The interesting cases are the stall rules. If the best score hasn’t improved by a full point in two rounds, or the judge has named the same gap three times, the agent must stop incremental tweaks and make one big structural change in a single round: swap the asset strategy, pull real models or HDRIs from an asset library, rewrite the lighting model, rebuild the composition, change the camera. If a big structural change has already been tried and the score still hasn’t improved in three rounds while the judge blocks on intractable asks, the agent stops and tells the user why it’s blocked, with options. Small score dips are judge noise; the agent only reverts on a full-point drop.
Follow-up Loops and the Honest Bottom Line
The skill also handles the case where you invoke it on an existing product: rather than dreaming concept art in a vacuum, it captures a live screenshot of the current build and prompts the image model to render “the best possible version of this” — a current screenshot re-imagined at AAA quality — then uses that as the new target. Multiple screens can iterate in parallel with separate judge loops, at the cost of tokens.
dream-loop is honest about what it needs and where it’s been tested. It requires image generation, vision and subagents, prefers local Blender, and the author states plainly: “At the moment this is only tested with GPT-6 Astra in Codex.” For anyone with that stack, it’s the most rigorous open-source attempt yet at giving an agent real visual taste — not by making the model judge beauty, but by making the loop structure force honesty, concreteness and iteration until the pixels match the dream.