dream-loop: A Critique-Driven Agent Skill for Visual Prototyping

The Problem dream-loop Addresses

Generating a compelling visual with a coding agent typically fails for a predictable reason: the agent has no stable reference for what success looks like. It produces a first version, the human gives feedback, the agent revises, and the conversation drifts away from the original intent with each round. The quality ceiling is the quality of the human's real-time critique.

dream-loop replaces the human in that feedback loop with an automated critic. Before writing any code, the agent generates a target screenshot using image generation, giving itself a concrete visual goal. It then builds, takes a screenshot of what it has built, and hands both images to a separate AI critic subagent. The critic compares the two and returns specific feedback. The build loop repeats until the critic is satisfied. An optional outer loop can then regenerate the target itself, raising the visual bar based on what the agent has already achieved.

The Five-Step Loop in Detail

The README describes the loop in five discrete steps. First, the AI generates a high-quality target screenshot using image generation. This is not a rough sketch; it is a fully rendered image that represents the desired output. Second, the AI builds the game, app, or scene with that target image as its reference. Third, a separate AI critic subagent compares a live screenshot of the current build against the target and produces specific feedback about what is wrong or missing. Fourth, the AI loops back to step two with the critic's feedback and revises the build. Fifth, once the critic is satisfied, an optional step allows the AI to loop back to step one and dream up an even more ambitious target based on the current state.

The separation between the builder and the critic matters. A single agent evaluating its own output is prone to satisficing: it declares the work done because the task told it to finish. A separate critic subagent has no such pressure. The README describes subagents as optional but strongly preferred, because without a subagent the critic role collapses back into the builder.

Installing dream-loop and What You Need First

dream-loop installs as a skill, which is a file that defines how an agent should behave when it activates the skill. The simplest installation uses npx:

npx skills add achimala/dream-loop

Alternatively, clone the repository into your agent's skills directory, or paste the GitHub link into your agent and tell it to handle installation.

Before installation, verify that your agent runtime meets three requirements. It must have access to image generation, either built into the agent (as in Codex or Grok) or available through an API key such as a Gemini API key. It must accept vision input, because the critic step requires comparing two images. Subagent support is optional but strongly preferred: the README is explicit that the skill produces better results when the critic runs as a separate subagent rather than as a secondary prompt within the same agent session.

The README states that the skill is only tested with GPT-6 Astra in Codex, though it notes that Claude Fable 5.1 and other capable models can likely work. There is no test suite or compatibility matrix for other runtimes.

Blender for Custom 3D Scenes

dream-loop supports Blender for 3D modeling tasks. Installing Blender separately and using it via the Blender MCP or Blender's scripting interface is the recommended path when the target scene requires custom 3D geometry. The README notes that this approach produces better results than computer use automation of the Blender UI, which is the slower alternative.

The Blender integration is not bundled with dream-loop. You install Blender independently, and the skill's SKILL.md definition instructs the agent on how to invoke it. The README does not document which Blender version is required or whether there are known compatibility issues with specific MCP implementations. If you run into issues with the Blender path, the README suggests the Blender scripting interface as a fallback.

The Three.js Demo: A Concrete Build Example

The README includes a detailed example prompt that GPT-6 Astra on high effort in Codex completed with dream-loop. The prompt asked for a Three.js browser demo with an isometric voxel-ish art style, realistic shading, reflective wet floors, a character in a fantasy scene reminiscent of Elden Ring or Diablo, performance above 60 frames per second, no downloaded assets, and interactive controls including click-to-move, drag-to-rotate, and scroll-to-zoom. The world should feel alive with motion and environmental behaviors, but movement should be confined to a limited area. No gameplay and no confirmation steps were requested.

The live demo is available at dream-loop-demo.anshu.dev. This example illustrates what the skill is optimized for: complex visual scenes with multiple interacting systems, where a single agent pass without a critic loop would likely produce a flat, incomplete result. It is not a general-purpose coding assistant; it is a specialized feedback mechanism for visually demanding tasks.

Where dream-loop Falls Short

The skill's dependency on external capabilities is also its main limitation. If your agent runtime does not support image generation natively, you need to supply an API key for a capable image generation service. If vision input is unavailable, the critic step cannot compare screenshots and the loop collapses. If subagents are not supported, the critic and builder share context, which the README identifies as a weaker configuration.

The skill is tested on one runtime. The README is explicit: GPT-6 Astra in Codex is the only verified environment. Claude Fable 5.1 is mentioned as likely to work, but no test results are documented. Using dream-loop with a weaker model or an unsupported runtime may produce a loop that never converges, a critic that always approves mediocre output, or installation failures.

There is also no documented mechanism for setting a maximum iteration count. The README does not say what happens if the critic never reaches a satisfied state, which means a runaway loop is a real possibility depending on how the agent runtime handles skill termination.

A capable alternative for generating visual output without the critic loop is to use image generation directly as a step in a hand-written agent workflow. Tools like LangGraph allow building custom multi-agent pipelines where you control each node, including when to stop. dream-loop is more opinionated: it enforces the generate-build-critique structure by design, which is a benefit if that structure fits your use case and a constraint if it does not.

Maintenance and Repository Structure

The last push to dream-loop was on 2026-09-09, which is recent. The repository has no GitHub releases, meaning there is no versioned tag to pin to. Installation via npx skills add pulls from the default branch directly.

The repository is small: a README, a SKILL.md file that defines the actual skill behavior the agent reads, an assets directory, a references directory, and a scripts directory. The SKILL.md is the core artifact that agents use when the skill is active, but its contents are not included in the README. Contributing guidelines ask that pull requests include example results produced by the skill, to prevent regressions in visual quality.

The license is MIT. There are no explicit runtime dependencies tracked in a package file, because the skill itself is a set of instructions for an agent rather than a compiled library.

Editorial conclusion

dream-loop is the right choice for an engineer or creative developer who already has a capable coding agent with image generation and vision, and wants a structured feedback mechanism that pushes visual quality past what a single-pass prompt can achieve. It is the wrong choice if you need a battle-tested production tool: the README states it is tested only on GPT-6 Astra in Codex, and the skill relies heavily on optional subagent support that not every agent runtime provides. Before installing, confirm that your agent runtime supports image generation natively or via an API key, and that vision input is available for the critic step.

Frequently asked questions

Official sources

1. achimala/dream-loop on GitHub
2. Issues
3. License: MIT
4. README