The loop

Development in Stella Loop is a loop, not a line. Every stage can feed back into an earlier one, and the output of finished work is the input of the next cycle. This page walks the lifecycle end to end; each stage links to its own page for depth.

The shape

(Signals — the front door: outside world → captured, triaged input)
North Star constellation           (the aim everything is pulled toward)
  Intent                           (directed or North Star-driven)
    └─► Analyse                    (analyzer runs → reports + scores)
          └─► Propose              (derive candidate solutions from reports)
                └─► Proposal pool  (prune · prioritize · sibling sets · deps)
                      └─ promote ══► EPIC created     (the commitment point)
                                      └─► Plan        (spec → tasks)
                                            └─► Implement ◄──────────┐
                                                  └─► Review ── fix ──┘
                                                        ├─ re-spec ─► Plan
                                                        └─► Done (merge;
                                                            learnings seed
                                                            the next intent)

The lifecycle chains strictly: intents give rise to analysis, analysis gives rise to proposals, promoted proposals give rise to epics, and epics give rise to tasks. The intent is the container for the discovery half; the epic is the container for the delivery half; the proposal pool is the junction between them.

Stage by stage

North Star — not a stage but the loop’s fixed point: a versioned, weighted, typed set of documents describing what the product should become. Analyzers cite the exact document version they scored against.
Signals — upstream of the loop. A signal is an uninterpreted observation — a GitHub issue, a Slack message, a Sentry alert, an email, a ten-second thought — captured with zero required structure and triaged into the loop’s existing doors. Nothing signal-shaped becomes an epic or task directly.
Intents — every loop turn starts with an intent: a statement of aim that selects and scopes analyzers. Standing intents re-fire on triggers (manual, schedule, post-merge, score-drop), which is what makes the loop continuous.
Analysis — analyzers examine the codebase and produce reports (RPT-n) with findings and 0–100 scores. Runs fan out in parallel; comparability is structural.
Proposals and the pool — candidate solutions derived from reports, grouped into sibling sets (competing approaches to one problem), prioritized before the expensive stage.
Promotion — the commitment point. Promoting out of the pool creates the epic, atomically, through the epic.promote gate. Two modes: prune-first (promote one chosen approach) or tournament (race them all).
Epics and tasks — the delivery container. The epic’s stage machine is Plan → Implement → Review → Done with explicit loop-back edges, enforced server-side.
Plan — each candidate becomes a spec (OpenSpec by default, pluggable) which is decomposed into tasks. The stage that warrants the strongest models.
Implement — tasks are executed by coding agents and humans, with race-safe claiming and full context available to every implementer.
Review — a reviewer panel evaluates the work. Three verdict directions: a fix loop back to Implement, a re-spec escalation back to Plan, or acceptance. In a tournament, review selects the winner. Review drives the coordinated merge.
Done — and the next turn — merged work lands, learnings seed draft intents, standing intents re-fire on the merge, and the completed cycle is counted as a numbered loop iteration with a closing summary: score delta, epics shipped, learnings seeded, spend.

The edges that make it a loop

Fix loop (Review → Implement): review findings send work back without reopening the spec.
Re-spec loop (Review → Plan): findings escalate past a fix and reopen the candidate’s spec as a new revision.
Seed edges (Review/Done → Intent): learnings and observations from finished work arrive in the intents list as seeded drafts — “Seeded from EPC-12 review learnings” — and enter the normal approval gate.

A one-way pipeline treats rework as failure. The loop treats it as the normal mechanics of getting something right, and models every edge explicitly so state stays honest.

Provenance

Every stage’s artifact carries immutable references to the artifact that motivated it:

epic → proposal → report → intent [→ signal → external source]

Display IDs make the chain legible everywhere: SIG (signal), INT (intent), RPT (report), PRP (proposal), EPC (epic), TSK (task). See Provenance.

Governance

The loop engine makes the stages one governed loop: a canonical stage-transition table every surface enforces, checkpoint gates on every consequential transition with a project-level autonomy dial, and model tiers and budgets that keep spend deliberate and visible. See The loop engine.