Confirmation Gates: See It Before It Happens

Your agent just finished analyzing the codebase. It understands the project structure, found the relevant components, and has a clear plan. Now it wants to write a new file.

In a typical IDE chat box, that write happens silently — the file appears on disk without warning. In Fabriq, the system pauses.

What a confirmation gate looks like

┌──────────────────────────────────────────────────────────┐
│  ⚠️  Action requires your confirmation                   │
│                                                          │
│  Action:   Write file                                    │
│  Target:   repos/my-app/src/components/SearchBar.tsx     │
│  Dimension: Feature (add-search-filter)                  │
│  Lines:    +120 lines (new file)                         │
│                                                          │
│  ┌─ Preview ────────────────────────────────────────┐   │
│  │  import { useState } from 'react';               │   │
│  │  ...                                             │   │
│  └──────────────────────────────────────────────────┘   │
│                                                          │
│  [Approve]  [Reject]  [Skip]                             │
└──────────────────────────────────────────────────────────┘

This is a confirmation gate. Every state-changing capability call — write a file, edit code, run a command, commit — surfaces as one of these prompts before anything hits disk.

The three buttons

Button	What it does	When to use
Approve	Let the action proceed. The result appears in the activity log.	You've reviewed the payload and it looks correct.
Reject	Block the action. Optionally tell the agent why — it will adjust and try a different approach.	The approach is wrong, the wrong file is targeted, or you want a different solution.
Skip	Defer the decision. The action stays in a pending queue for later review.	You want to see more of the agent's work before deciding, or you need to check something first.

What triggers a confirmation

Action	Example prompt
Writing a new file	"Write 120 lines to src/components/SearchBar.tsx"
Modifying an existing file	"Edit src/pages/Products.tsx (+12 lines, -3 lines)"
Running a terminal command	"Run npm install lodash"
Git operations	"Commit 3 files: 'Add search bar component'"
Creating or modifying a directory	"Create src/utils/ directory"

How to read a confirmation prompt

Before you click Approve, check:

1. Target — Is this the right file? Is it in the right dimension (feature worktree, not workspace assets)?
2. Change scope — Does the line count match expectations? A 500-line "small fix" might warrant a closer look.
3. Preview — Read the diff preview. Does the logic look right? Are there any hardcoded values that should be configurable?
4. Intent — Does the action match what you asked for? If you said "add a dark mode toggle" and the agent is rewriting your entire CSS file, that's worth questioning.

What happens after approval

The action executes. The result appears in the activity log:

✓ Wrote src/components/SearchBar.tsx (120 lines)

If the action fails (e.g., a terminal command exits with an error), the gate shows a failure state with the error output. The agent can see this and adjust.

What happens after rejection

The agent receives your feedback. Depending on what you say:

• "Wrong approach — use a dropdown instead of a modal" → agent redesigns
• "Wrong file — the form is in Settings.tsx, not Profile.tsx" → agent targets the correct file
• "Don't install a new library — use what's already in the project" → agent finds an alternative

Rejecting one action doesn't stop the whole feature. The agent continues working on other tasks while incorporating your feedback.

The pending queue (skipped actions)

When you Skip, the action moves to a pending queue. You can:

• Return to it later from the confirmation panel
• Approve or reject in bulk at review time
• Clear the queue if the action is no longer relevant

Why confirmation gates exist

This is the core difference between Fabriq and a standard IDE chat:

• Standard chat: agent writes → you discover what happened when you run the code
• Fabriq: agent proposes → you review → you approve → agent writes → you verify

Confirmation gates make agent actions legible, reviewable, and reversible by default. Nothing is invisible. Nothing happens without your knowledge.

"The agent proposes. The shell surfaces. You confirm."

Next steps

• Workspace vs Feature: Two Surfaces — understanding the dimension context
• Working with the Agent — guide the agent, inject context, intervene
• Your First 15 Minutes — see confirmation gates in action