iterait

Inspiration

iterait is a visual workflow system that makes AI-assisted design more understandable, controllable, and reusable—without re-prompting.

As UX/UI designers, we’ve been increasingly using AI tools like Claude, Cursor, and Figma Make to prototype and generate interfaces. While powerful, these tools often assume technical knowledge and force designers to work through code, chat logs, and fragmented outputs.

We kept running into the same frustration: the faster we could create, the harder it became to manage what we created.

In tools like Figma, Adobe Suite, and Canva, we rely on version history, layers, undo, and the ability to reuse elements across files. With AI tools, those fundamentals are missing. We wanted to push the boundaries of what we could create with AI—while still working in a way that feels natural: visual, iterative, and controlled.

As creatives increasingly design with AI, we recognized the need for a prototype environment that protects the creative process—restoring flow, intent, and authorship.

What it does

iterait is a visual workflow system for AI-assisted design.

It allows designers to:

Track and visualize iterations across versions
Compare changes side-by-side
Restore specific edits or full versions
Save changes as reusable Actions or Action Chains

A key feature is the Actions system, which captures design changes and allows them to be reused across files and tools—reducing repetitive prompting and improving consistency. Instead of relying on chat logs or code, iterait transforms AI outputs into a clear, visual, and interactive workflow.

How we built it

We approached iterait as a design-first system, starting with a review of tools like Figma, Canva, and Adobe Suite, and comparing them to AI tools such as Claude, Stitch, Lovable, and Cursor. This helped us identify gaps in iteration, version control, and usability.

We mapped these insights into a system architecture, then translated it into wireframes and refined flows before building high-fidelity designs in Figma.

Using Claude, we brought these designs to life—supporting implementation and enabling a system that parses, compares, and structures design changes into reusable actions.

Our pipeline:

Detects and isolates changes between versions Maps changes into visual, structured representations Enables reuse through actions and chains

We also explored iterait as a plugin-based companion, designed to integrate into existing tools and support designers in real time without breaking flow.

Challenges we ran into

Translating AI-generated outputs into structured, understandable actions was a major challenge. AI often bundles multiple changes together, making it difficult to isolate individual design decisions.

We also had to balance flexibility with clarity—giving users control without overwhelming them. Designing an intuitive change log and action system required multiple iterations.

Ensuring the system could work across tools, rather than being tied to one platform, was another key challenge.

Accomplishments that we're proud of

We’re most proud of turning a fragmented, text-heavy workflow into a clear, visual system.

Key accomplishments include:

A visual version history with side-by-side comparison A reusable Actions and Action Chains system Reduced reliance on code, improving accessibility for designers A strong foundation for cross-platform workflows and collaboration

We built a prototype that is both polished and functionally meaningful.

What we learned

The biggest challenge in AI-assisted design isn’t generation—it’s usability and control.

AI can produce results quickly, but without structure, those results become difficult to manage. Designers need tools to understand, direct, and reuse what AI generates.

We also learned that effective AI tools support creativity—they don’t replace it.