Your SDLC,
on autopilot

Turns a rough idea into a crisp, buildable spec.

Specify reads the raw issue and works it into a clear specification, asking clarifying questions when the request is ambiguous. It runs read-only — the worktree is stashed clean and no code is written.

• The only stage that rewrites the issue body itself, via FABRIK_ISSUE_UPDATE markers.
• Can pause with FABRIK_BLOCKED_ON_INPUT to ask you a question, then resumes automatically the moment you comment.
• Output is posted as a stage comment on the issue — no PR exists yet.

Maps the codebase before a line is changed.

Research explores the repository, locates the files the change will touch, and pins down the scope and constraints. Like Specify it reads and greps but writes nothing.

• Its findings are saved to .fabrik-context/stage-Research.md and handed to every later stage as context.
• Surfaces unknowns early, so Plan and Implement aren't guessing.
• Output is posted on the issue.

Designs the approach and breaks it into tasks.

Plan decides how the work will be done — the approach, the sequence, the tasks — and produces the contract that Implement builds against. Still read-only.

• Can declare child issues with FABRIK_SPAWN_CHILD blocks; the engine creates them, links blockedBy edges, and runs them as a parallel formation.
• Decomposition is recursive — a child's own Plan can spawn grandchildren, with no depth limit.
• Output is posted on the issue.

Writes the code, the tests, and opens the PR.

Implement is the first stage to write files. It implements the plan, adds tests, and commits to the issue's branch — with edits path-scoped to that issue's isolated worktree so nothing leaks across issues.

• Opens a draft PR with Closes #N, linking the PR back to the issue.
• Marks the PR ready on completion, which triggers external review bots.
• Commits frequently so progress survives an interrupted session; detailed output goes to the PR, a short summary to the issue.

Rebases, self-reviews, and resolves the PR.

Review rebases the branch onto its base, reviews its own diff, and fixes what it finds — resolving PR review threads as it goes.

• The engine tracks the PR's resolved-thread count to detect real progress and grant extra turns when needed.
• The pending-reviewer gate waits for every requested reviewer, then re-invokes the stage to address their comments.
• Output is posted on the PR.

Proves it works, then clears the PR to merge.

Validate runs the test suite and verifies the issue's requirements are actually met — the last gate before merge.

• The CI gate blocks merge until checks pass, auto-fixing failing checks each cycle.
• With fabrik:yolo, completion enables auto-merge; the PR merges once branch protection is satisfied.
• Records the validated SHA, so a later force-push or external commit automatically re-enters Validate.