> ## Documentation Index
> Fetch the complete documentation index at: https://docs.fabriqa.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# AI-DLC user flow
> Follow the AI-DLC experience from the user's perspective across inception, construction, and operations.
# AI-DLC user flow
AI-DLC is designed so that planning, execution, and handoff happen through visible artifacts instead of hidden chat context.
## Typical journey
You start with a workspace-level request such as a new capability, a major enhancement, or a cross-project change.
The Inception agent creates an `intent`, decomposes it into `unit` artifacts, writes `story` artifacts, and groups related stories into `bolt` artifacts.
You review the plan as documents: intent summary, unit boundaries, user stories, and bolt groupings.
Construction works against one planned bolt. It can refine the execution plan, but it stays grounded in the bolt and its associated stories.
As Construction works, it creates or refines design and execution artifacts such as `domain_design`, `logical_design`, `system_context`, `implementation_plan`, `test_report`, and `walkthrough`.
You read the design docs, the execution walkthrough, and the verification report as document-style artifacts, not raw arrays.
If the bolt changes deployment-relevant behavior, AI-DLC emits or updates a `deployment_unit` so Operations has a structured handoff artifact.
## What you should expect in each phase
### Inception
Inception is where AI-DLC turns a broad request into an executable plan.
You should expect:
* one root `intent`
* one or more `unit` artifacts
* one or more `story` artifacts under each unit
* one or more `bolt` artifacts that group related stories into planned execution batches
### Construction
Construction works against a planned bolt.
You should expect:
* code changes tied to the selected bolt
* design outputs such as `domain_design` and `logical_design`
* execution outputs such as `walkthrough` and `test_report`
* an explicit record of touched workspace projects
### Operations
Operations works from a structured handoff rather than reconstructing intent from chat history.
You should expect:
* a `deployment_unit`
* deployment notes
* rollout stage tracking
* verification state
* incidents or mitigation notes when relevant
## What the UI should feel like
AI-DLC should feel like three coordinated surfaces, not a pile of disconnected artifact tabs.
```text theme={null}
+----------------------+--------------------------------------------------------------+
| Sidebar | Main workspace area |
| | |
| [AI-DLC] [Agents] | [Dashboard] [Artifact Viewer tabs...] |
| Group by: Status | |
| | Dashboard |
| Draft | +-------------+-------------+-------------+ |
| INT-001 | | Draft | In review | Approved | |
| STORY-014 | | cards... | cards... | cards... | |
| In review | +-------------+-------------+-------------+ |
| BOLT-004 | |
| Approved | Artifact viewer |
| TEST-002 | +--------------------------------+ +----------------------+ |
| | | Selected artifact document | | Context rail | |
| | | markdown page + meta row | | tree, relations, | |
| | | read-only document body | | chats, activity | |
| | +--------------------------------+ +----------------------+ |
+----------------------+--------------------------------------------------------------+
```
Use the surfaces like this:
* sidebar for global find, grouping, and quick opening
* dashboard for status-oriented overview across the workflow instance
* artifact viewer for deep work in one root context
### What the artifact viewer should feel like
When AI-DLC opens an artifact in context, the reading experience should stay very plain:
* title first
* a minimal metadata row under the title
* markdown sections rendered like a document preview
* a slim right rail for context, not a second document
The right rail is where AI-DLC keeps:
* the root tree
* relations for the selected artifact
* linked chats
* activity, collapsed by default
This keeps the document body focused on the artifact itself instead of mixing narrative content with workflow chrome.
## How navigation should resolve context
The important behavior is not “open the clicked artifact in isolation.” It is “open the clicked artifact in context.”
Fabriqa should resolve a root viewer context like this:
1. Start from the clicked artifact.
2. Walk up its parent chain.
3. Stop at the first ancestor whose parent is in a different phase, or at the top root if there is no phase boundary.
4. Open or focus the viewer tab for that root artifact instance.
5. Highlight the clicked artifact inside the tree and show its document on the left.
In AI-DLC that gives intuitive results:
* click a `story` from the sidebar: open the surrounding `intent` context and select the `story`
* click a `walkthrough`: open the surrounding `bolt` context and select the `walkthrough`
* click a `test_report`: stay inside the same `bolt` execution context rather than opening a disconnected tab
```text theme={null}
Sidebar click: STORY-014
-> viewer root: INT-001
-> open/focus INT-001 tab
-> tree selects STORY-014
Dashboard click: WALKTHROUGH-003
-> viewer root: BOLT-004
-> open/focus BOLT-004 tab
-> tree selects WALKTHROUGH-003
```
## How AI-DLC handles change requests
AI-DLC is not a one-way conveyor belt.
If you change your mind during construction:
* Construction can refine the current bolt if the change still belongs in that scope.
* Construction can create follow-up planning artifacts if the change expands scope.
* Construction can effectively re-enter planning behavior, but it should do so through workflow artifacts instead of hidden reasoning.
The important rule is that the new scope still becomes explicit artifacts. It does not live only inside the chat transcript.
## Prompt-driven, not automatic
AI-DLC still relies on agent prompts to decide:
* when a bolt is ready to execute
* when a design document is necessary
* when an implementation plan should be written
* when a `walkthrough` or `test_report` must be created
The workflow definition makes those artifact contracts explicit, but it does not auto-run the flow.
## Continue reading
Go back to the AI-DLC overview page.
Continue into the artifact model and execution artifact structure.
See the same flow expressed as a Workflow DSL definition.
Review the shared terms used across AI-DLC and the Workflow DSL.