Product IDEA Loop

Product IDEA Loop

A living system for building, learning, and shipping faster in the AI era.

The sprint was built for scarce builders. The loop is built for abundant attempts.

Why this exists

Most teams do not run out of ideas. They run out of affordable attempts.

With AI, building speed is no longer the main bottleneck. Decision quality is.

The IDEA Loop helps teams run focused build-and-learn loops where insight, design, engineering, and analysis happen together in one working session.

Start here

How this page relates to the manifesto

What IDEA means

IDEA = Insight, Design, Engineering, Analysis

In IDEA loops, these functions improve each other in real time instead of waiting on long handoffs.

IDEA loops can be run in single-player mode (one owner) or multi-player mode (usually 2-3 collaborators). Both modes are concurrent: insight, design, engineering, and analysis stay active together in-session.

Concurrent, not phased

Do not run IDEA as four sequential stages.

Not this: Insight -> Design -> Engineering -> Analysis (separate handoffs across days)

Do this: Keep all four active in the same working session. A new user insight can change the design in minutes. A design constraint can change engineering scope immediately. Early instrumentation can change what you build next in the same loop.

Where the discipline lives

Sequential methods put discipline in the process: gates, handoffs, approvals, tickets. The system prevents bad decisions by making you wait. It works, but the cost is time and the risk is that the gates become theater.

Cowboy coding has no discipline anywhere. Build fast, ship, hope for the best.

Vibe coding has discipline in intuition only. It follows the feeling without verifying it. When it fails, there is no diagnostic.

IDEA loops move discipline from process to judgment. All four functions run concurrently, but:

Concurrency does not mean unstructured. It means all feedback channels stay open so that a design insight can change engineering in minutes instead of weeks. A jazz ensemble, not a noise jam — the musicians play concurrently, but they know the key, the tempo, the form, and when to listen.

What a loop is

A loop is one focused round of building and learning.

Setup options

Sandboxes (non-technical loopers should try these first)

Power User Setup A - Claude Code

Choose this if you prefer terminal-native workflows

Power User Setup B - Cursor

Choose this if you prefer IDE-native workflows

Tooling note:

Design through code is valid

Designing directly in code is perfectly acceptable in IDEA loops.

Great software requires more than working code. Loopers should think beyond vibe coding and evaluate the whole product.

Condition: the looper/pilot must run an explicit quality pass on user experience and product feel before shipping.

Patterns that only emerge in loops

Some design patterns are structurally impossible in a traditional pipeline because the handoff process flattens them.

Example: a fluid, content-driven container — a single animated surface that measures its children and resizes to fit, guiding users through a multi-step flow without page navigation. This pattern requires design and engineering to be the same conversation. In a Figma-to-ticket pipeline, it would require 10+ static artboards with transition annotations. Most teams would look at that spec and simplify to fixed-size modals. The fluid idea gets lost in translation.

In a loop, the container is built, fails, gets rebuilt, and is tuned — all in one session with taste guiding every iteration. There is no handoff where the idea gets flattened into rectangles.

This is not limited to animated containers. Any pattern where the design depends on runtime behavior — content-driven sizing, scroll-aware effects, preloaded transitions, animation timing tuned to emotional context — benefits from the same loop dynamic. The design cannot be fully specified in a static medium. It has to be felt in the real medium and adjusted in real time.

Look for these patterns in your loops. They are a signal that the concurrent model is producing something a sequential process could not.

Flexing the Cross-Discipline Muscle

If this feels hard at first, that is normal.

Each loop is highly sensitive to model choice, clarity of thought, prompting quality, taste, and critical thinking.

Loop speed and outcomes are extremely variable. Sometimes months of work collapse into a single prompt. Sometimes a simple task gets stuck for hours.

When progress stalls, do not rely on memory or vibes alone. Collect evidence.

The looper/pilot should train outside active work sessions: practice prompting, study what is happening behind the curtain, refine taste, and keep building cross-discipline muscle.

Be kind to yourself during your initial loops. This technique itself is brand new, and AI agents are improving at a blistering pace.

Context management and continuity

Context quality degrades before output quality visibly degrades. Treat context resets as a normal operating move. [R1][R2][R3]

Minimum handoff contract:

What this is

What this is not

Guardrails

How to judge loop success

A loop succeeds when it improves decision quality, even if it does not ship.

Additional strong signals:

Evidence structure, not process structure

The highest-fidelity artifact is the product itself. Everything else — tickets, decks, 100-screen Figma files — is a lossy compression of intent.

IDEA loops replace process artifacts with evidence artifacts:

The loop capture is the accountability mechanism. When it documents what was built, what was learned, and what was killed, it is more transparent than any ticket marked "Done."

Strengths of this framework

What this repo is

This repository is both:

Core principle

A loop is successful when it improves the starting conditions of the next loop.
There is always another loop tomorrow.

Appendix: References

These links support the context-management guidance above, especially for Cursor indexing and long-range retrieval behavior.