# Frameworks with audit trails and standards: AI-DLC, Agent OS, Tessl and Kiro-style specs

URL: https://developertoolkit.ai/en/ecosystem/frameworks/enterprise-frameworks/
Description: Run AWS AI-DLC with approval gates and a committed audit trail, and choose between Agent OS, Tessl, cc-sdd and Conductor for standards and spec gates.

AI-DLC, AWS Labs' AI-Driven Development Life Cycle, is the only framework in this group that pairs human approval gates with a committed, append-only audit trail of 118 event types (v2.11.0 README, read on 2026-10-10), and it runs in Claude Code, Codex and Cursor. Agent OS v3 discovers and injects coding standards; Tessl, cc-sdd and Conductor add lighter spec-approval gates without an event log.

Your compliance officer asks a simple question about last month's payments change: who approved the requirements, who approved the design, and did anyone skip a step? The agent wrote the code in two days, the pull request has one "LGTM", and the only record of the decisions is a chat session that nobody saved. You need the next regulated change to leave evidence behind as a side effect of doing the work, not as a report someone writes afterwards.

This page is for the developer who runs the agent and the tech lead who has to answer that question. It runs one change through AI-DLC's enterprise profile end to end, then shows where the lighter frameworks are enough.

**Versions and popularity on this page**

Checked on 2026-09-26 against each project's README and the npm registry, with Claude Code 2.1.283 and codex-cli 0.157.1. GitHub stars on 2026-09-26: [awslabs/aidlc-workflows](https://github.com/awslabs/aidlc-workflows) 4.8k (v2.10.0, MIT-0), [buildermethods/agent-os](https://github.com/buildermethods/agent-os) 5.4k (v3.0, 2026-01-20), [gotalab/cc-sdd](https://github.com/gotalab/cc-sdd) 3.7k (npm `cc-sdd` 3.1.0), [gemini-cli-extensions/conductor](https://github.com/gemini-cli-extensions/conductor) 3.7k, and [tesslio/spec-driven-development-tile](https://github.com/tesslio/spec-driven-development-tile) 54 (npm `@tessl/cli` 0.111.0). On 2026-10-10 the repository showed 5.1k stars, and the README of its v2.11.0 release lists 5 phases, 33 stages, 11 workflow profiles and a 118-event audit trail (the 105 recorded on 2026-09-26 was the v2.10.0 count). Stars measure attention, not usage. `kiro.dev` and `docs.tessl.io` were unreachable, so Kiro details and Tessl's agent detection are secondary (search snippets) and labelled.

## What an audited agent workflow gives you

- A decision table: which of the five frameworks produces audit evidence and which only shapes behaviour.
- An AI-DLC install for Claude Code, Codex or Cursor, including the Codex hook-trust step.
- A regulated run in the `enterprise` profile, with the Guard Policy pinned to `strict` and a gate after every stage.
- Committed audit shards, a required CI check on them, and a prompt that turns them into an approval ledger.
- What a `HUMAN_TURN` event proves and what it does not.

## Which framework gives you an audit trail, and which only gives you standards?

Only one of the five writes a machine-readable log of decisions; the rest give you gates or standards, and git history is your only record.

| Framework | What it enforces | Durable evidence | Gates | Claude Code / Codex / Cursor | Pick it when |
| --- | --- | --- | --- | --- | --- |
| **AI-DLC** (AWS Labs) | 5 phases, 33 stages, 11 workflow profiles | `aidlc-state.md` plus append-only `audit/` shards, 118 event types (v2.11.0 README, 2026-10-10) | After every stage except initialization | Yes / Yes (`$aidlc`, Codex 0.145.0 or later) / Yes | You must show an auditor who approved what, in order |
| **Agent OS v3** (Builder Methods) | Your house conventions, injected on demand | `agent-os/standards/` and an index file | You confirm each discovered standard | Yes / not documented / claimed in the README | Agents ignore your conventions, and you already have a delivery process |
| **Tessl spec-driven-development tile** | "Never begin implementation without an approved spec" | `specs/*.spec.md` linked to tests with `[@test]` | Spec approval | Per Tessl's docs (secondary) | You want versioned, evaluated context packages from a registry |
| **cc-sdd** (gotalab) | Kiro-style requirements, design and tasks | `brief.md`, requirements, design and `tasks.md` per spec | Between spec phases | Stable / stable / beta | You like Kiro's spec shape but work in Claude Code, Codex or Cursor |
| **Conductor** (Google, `gemini-cli-extensions` org) | Context, then spec and plan, then implement | `conductor/` files and `tracks/<id>/{spec,plan}.md` | Plan approval before code | Yes / not documented / not documented | You want durable project context and git-aware revert with little ceremony |

Kiro builds the same requirements, design and tasks flow into its own IDE and CLI (secondary: kiro.dev search snippets); it is not something you install into another agent, so cc-sdd is how you get that shape elsewhere. Kiro's own flow is on [the Kiro page](/en/comparison/kiro/).

The rule this page follows: if the question is "who approved it", use AI-DLC. If it is "why does the agent keep ignoring our conventions", use Agent OS or AI-DLC's knowledge folder. If it is "did anyone agree on the behaviour before the code", any spec framework is enough; the wider comparison is on [spec-driven frameworks compared](/en/ecosystem/frameworks/spec-driven-frameworks/).

## Install AI-DLC in Claude Code, Codex or Cursor

AI-DLC ships as a native `aidlc` command plus a runtime for each supported agent. Only the `--harness` value, the invocation character and one trust step differ between tools.

1. Install the `aidlc` command. The one-line installer pipes a script into your shell, so on a managed machine download `install.sh` from the [latest release](https://github.com/awslabs/aidlc-workflows/releases/latest), read it, then run it.

   ```bash
   # terminal, macOS / Linux / WSL
   curl -fsSL https://github.com/awslabs/aidlc-workflows/releases/latest/download/install.sh | sh
   ```

   On Windows PowerShell the README uses `irm https://github.com/awslabs/aidlc-workflows/releases/latest/download/install.ps1 | iex`. Neither Bun nor Node.js is required.

2. Configure the project for your agent and run the health check from the repository root.

   **Claude Code**

   ```bash
   cd ~/src/payments-service
   aidlc config --harness claude
   aidlc doctor
   claude
   ```
   In the session, start work with `/aidlc`.

   **Codex**

   ```bash
   cd ~/src/payments-service
   aidlc config --harness codex
   aidlc doctor
   codex
   ```
   AI-DLC needs codex-cli 0.145.0 or later. Codex never runs untrusted project hooks, and AI-DLC's gates depend on hooks: at the hooks dialog choose **Trust all and continue**, or merge the `[hooks.state]` block from the generated `.codex/trust-seed.toml` into `$CODEX_HOME/config.toml`. In the session, start work with `$aidlc`, not `/aidlc`.

   **Cursor**

   ```bash
   cd ~/src/payments-service
   aidlc config --harness cursor
   aidlc doctor
   ```
   Open the project in Cursor and start work with `/aidlc`. The runtime installs 14 personas as subagents, skills, `.cursor/hooks.json` and an `AGENTS.md` section.

   Other `--harness` values are `kiro`, `kiro-ide`, `opencode` and `copilot`. `aidlc config` with no flag starts an interactive setup.

3. Commit what the configuration wrote. `aidlc-state.md`, the `audit/*.md` shards and every stage artifact belong in git; the per-machine files that AI-DLC's managed `.gitignore` block lists (`.aidlc-engine/`, the per-clone marker, the active-space and active-intent cursors) stay ignored. Add `aidlc/diagnostics/` to `.gitignore` too, so a debugging bundle never lands next to the evidence.

AI-DLC is not a Claude Code plugin, so `claude plugin details` does not report its context cost; compare a session's context usage before and after `aidlc config` on your own repository before a team rollout.

## Run a regulated change with approval gates and an audit export

The example takes "add an approval step for refunds above EUR 10,000" through the `enterprise` profile: all 33 stages at Comprehensive depth and test strategy, with the Guard Policy defaulting to `strict` (as in `security-patch` and `infra`; seven profiles default to `relaxed`, `express` to `off`).

1. **Load your standards before the first stage.** Every agent loads the Markdown under `aidlc/spaces/default/knowledge/aidlc-shared/`: put coding standards, architecture principles and compliance rules there, not in `.claude/knowledge/`, which upgrades overwrite. Conventions that exist only in code can be extracted with [Agent OS](#add-house-standards-without-a-pipeline-agent-os-v3).

2. **Pin the Guard Policy to `strict` for the whole repository.** Otherwise anyone can type `/aidlc --guard-policy relaxed`, which lets the Plan Approval and review-freeze fences stand aside. Add a `## Guard Policy` section (or use the one already there) to `aidlc/spaces/default/memory/org.md`, with one line:

   ```markdown
   ## Guard Policy

   Mode: strict
   ```

   A memory `strict` wins over every profile default and refuses `--guard-policy relaxed`, `--guard-policy off` and `/aidlc config set guard.<fence> off`. Protect the file with CODEOWNERS. An environment kill switch still overrides it and still writes `GUARD_STOOD_ASIDE` rows, which the CI check below catches.

3. **Start the workflow in the enterprise profile.** Name the profile explicitly. With only a description, AI-DLC matches keywords to a profile and asks you to confirm; you want `enterprise` on record from the first event, not a later `SCOPE_CHANGED` row.

   **Copy-paste prompt: start a regulated change in AI-DLC**

   ```text
   /aidlc enterprise Add a second-approver step for refunds above EUR 10,000 in the payments service. A refund above the threshold stays in PENDING_APPROVAL until a user with the finance-approver role, who is not the requester, approves it. Rejected refunds are cancelled with a reason code. Every approval and rejection must be written to the existing refund_events table. Constraints: no change to the public refund API response shape; PCI scope must not grow; follow the standards in aidlc-shared/. Ask me about anything you would otherwise assume, one question at a time.
   ```
   In Codex, start the line with `$aidlc enterprise` instead.

4. **Treat every gate as a sign-off, not a formality.** Each stage ends with **Approve** or **Request Changes**. Approve records `GATE_APPROVED` and advances; Request Changes records `GATE_REJECTED`, moves the stage to `[R]` and re-opens the gate after the revision. Decide in advance who approves what (product owner: requirements; tech lead: design; security: threat and compliance artifacts), and read the artifact, not the chat summary.

   **Copy-paste prompt: adversarial check before you approve a gate**

   ```text
   Before I answer this approval gate, act as the second reviewer for a regulated payments change. Compare the artifact this stage just wrote with the requirements approved earlier in this intent and with every file in aidlc-shared/. List, with file and section references: (1) any requirement that has no corresponding design element or test, (2) any statement that contradicts a standard, (3) any assumption that was never confirmed by me in a recorded answer. Do not edit anything. If the list is empty, say so in one line.
   ```

5. **Approve the verification command once, and keep checkpoints gated.** In Construction you approve the check AI-DLC reruns at every unit checkpoint, for example `npm test && npm run typecheck`; a failing check halts the run, so pick one that fails for the behaviours in your requirements. Choose **Review each checkpoint** over **Continue automatically**; it records `gated` in an `AUTONOMY_MODE_SET` row.

6. **Check status without advancing anything.** Read-only `/aidlc --status` shows the stage, the Guard Policy with its source, and a `Fences:` line. You want `Guard Policy: strict (from org.md)`.

7. **Export the audit trail with the pull request.** The trail lives in `aidlc/spaces/<space>/intents/<YYMMDD>-<label>/audit/`, one shard per clone (`<host>-<clone>.md`), so parallel worktrees never conflict. Each entry has a tool-stamped ISO 8601 timestamp and an `**Event**:` line; agents cannot write a shard directly. The export is the commit that ships the code with its state file, artifacts and shards. `aidlc engine audit history` prints the same events as JSON, but AI-DLC calls the `aidlc engine` routes harness machinery rather than a stable interface, so build CI on the committed shards.

   **Copy-paste prompt: build the approval ledger for an auditor**

   ```text
   Read every file in the audit/ folder of the active AI-DLC intent, merge the entries by ISO timestamp, and write docs/compliance/refund-second-approver-ledger.md. It must contain: (1) a table of every GATE_APPROVED and GATE_REJECTED event with timestamp, stage and the artifact path the stage produced; (2) every VERIFICATION_COMMAND_RECORDED and CHECKPOINT_VERIFICATION_RECORDED event; (3) every GUARD_STOOD_ASIDE, GUARD_DISABLED, CHANGE_ACCEPTED and PLAN_APPROVAL_OVERRIDDEN event, each flagged as needing a written justification; (4) the scope, depth and test strategy recorded in aidlc-state.md. Quote event names exactly as they appear in the shards. Do not summarise or omit rows, and do not modify any file under aidlc/.
   ```

`/aidlc --doctor --export` is a different thing: it writes a redacted `.tar.gz` to `aidlc/diagnostics/` containing `report.md` and `report.json` with a workflow timeline (stage durations, gates, revisions, gaps). It hashes intent IDs, redacts paths and excludes raw audit files and artifact bodies, so it is for the AI-DLC maintainers, not your auditor.

## Fail the pull request when a guard was lowered

This job reads only committed files and needs no secrets, so it is safe on pull requests from forks. It runs on every pull request, not only those touching `aidlc/`, because the change most worth catching is regulated code with no trail at all. Set `REGULATED_PATHS` to your own directories and make `audit-gate` a required status check in branch protection; a check that is not required only reports.

```yaml
# .github/workflows/aidlc-audit-gate.yml
name: aidlc-audit-gate
on:
  pull_request:
    types: [opened, synchronize, reopened, labeled, unlabeled]
permissions:
  contents: read
jobs:
  audit-gate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
        with:
          fetch-depth: 0
          persist-credentials: false
      - name: Check the AI-DLC audit trail
        env:
          BASE_REF: ${{ github.base_ref }}
          REGULATED_PATHS: src/payments src/refunds
          GUARD_JUSTIFIED: ${{ contains(github.event.pull_request.labels.*.name, 'aidlc-guard-justified') }}
        run: |
          range="origin/$BASE_REF...HEAD"
          grep -q -x 'Mode: strict' aidlc/spaces/default/memory/org.md || {
            echo "Guard Policy pin missing from aidlc/spaces/default/memory/org.md"; exit 1; }
          deleted=$(git diff --diff-filter=D --name-only "$range" -- 'aidlc/**/audit/*.md')
          if [ -n "$deleted" ]; then echo "Audit shard deleted: $deleted"; exit 1; fi
          regulated=$(git diff --name-only "$range" -- $REGULATED_PATHS)
          shards=$(git diff --diff-filter=AM --name-only "$range" -- 'aidlc/spaces/*/intents/*/audit/*.md')
          if [ -z "$shards" ]; then
            if [ -n "$regulated" ]; then echo "Regulated change without an AI-DLC audit trail"; exit 1; fi
            exit 0
          fi
          grep -q -h -E '\*\*Event\*\*: GATE_APPROVED' $shards || { echo "No approved gate on record"; exit 1; }
          if grep -H -E '\*\*Event\*\*: (GUARD_STOOD_ASIDE|GUARD_DISABLED|CHANGE_ACCEPTED|PLAN_APPROVAL_OVERRIDDEN)' $shards; then
            justification=$(git diff --diff-filter=AM --name-only "$range" -- 'docs/compliance/*-justification.md')
            if [ "$GUARD_JUSTIFIED" = "true" ] && [ -n "$justification" ]; then
              echo "Lowered guard accepted with justification: $justification"
            else
              echo "A guard was lowered or a plan approval overridden: commit docs/compliance/<intent>-justification.md and add the aidlc-guard-justified label"; exit 1
            fi
          fi
```

The patterns match the `**Event**: <NAME>` line of AI-DLC's audit format (`audit-format.md`, v2.10.0). Only added or modified shards are grepped; a deleted shard fails on its own, because removing evidence is what a reviewer must see.

Stand-aside rows can never leave a shard, so the lowered-guard step has an escape hatch that leaves its own evidence: the `aidlc-guard-justified` label **and** a `docs/compliance/<intent>-justification.md` committed in the same pull request. Put `docs/compliance/`, `aidlc/**` and `.github/workflows/aidlc-audit-gate.yml` under CODEOWNERS with required review: on `pull_request` GitHub runs this workflow from the pull request's merge ref, so without that review a pull request could rewrite the gate itself. The `labeled` and `unlabeled` types re-run the job when the label changes.

## How do you prove AI-DLC's output without reading every line?

AI-DLC's full name holds the generic phrase [AI-driven development](/en/glossary/ai-driven-development/), which names who leads the work; the approval gates and the audit trail do the checking. The gates prove that a human looked at each artifact, not that the code is right. That evidence comes from four places, none of them a person reading the diff:

| Evidence | Where it comes from | Who signs off |
| --- | --- | --- |
| Requirements and design were approved before code | `GATE_APPROVED` rows for each Inception stage | Product owner, tech lead |
| Tests encode the approved behaviour | Comprehensive test strategy plus the recorded verification command at every unit checkpoint | The engineer who approved the command |
| The reviewed code is the shipped code | Source-bound review receipts: a `source-manifest.json` and fingerprint per unit; completion is refused if source changed after review | AI-DLC's two reviewer agents, then CI |
| Nobody quietly lowered a guard | `Mode: strict` in memory and the required CI check above | Tech lead, via CODEOWNERS on `aidlc/**` |

Keep your usual gates on top: type checks, lint, the test suite and your [evidence bundle](/en/workflows/ship/evidence-bundle/) on the pull request. AI-DLC records that decisions were made in order; your tests and CI prove that the result behaves.

## Add house standards without a pipeline: Agent OS v3

Agent OS v3 (2026-01-20) dropped its implementation phases ("Spec creation now defers to Plan Mode") and kept five commands: discover, index and inject standards, shape a spec in plan mode, and `plan-product` for the product mission. Use it when the problem is conventions, not audit.

The per-project script `scripts/project-install.sh` is verified in the repository and copies commands into `.claude/commands/agent-os/`. The base-install line comes from a search snippet of the official installation page, so check it there first:

```bash
# base install (secondary: buildermethods.com installation page)
rm -rf ~/agent-os && git clone https://github.com/buildermethods/agent-os.git ~/agent-os && rm -rf ~/agent-os/.git
# per project (script verified in the repository)
cd ~/src/payments-service && ~/agent-os/scripts/project-install.sh
```

In Claude Code the commands appear under the `agent-os` namespace:

```text
/agent-os:discover-standards api     proposes concise standards from existing API code; you confirm each one
/agent-os:index-standards            writes the index of agent-os/standards/
/agent-os:shape-spec                 run in plan mode; asks targeted questions and weighs your standards
/agent-os:inject-standards           pulls the relevant standards into the current context
```

The README documents no Codex install. For Codex and Cursor, reference the standards folder from `AGENTS.md` or your Cursor rules, or copy it into AI-DLC's `aidlc-shared/`; see [rules sync](/en/ecosystem/frameworks/rules-sync/).

**Copy-paste prompt: extract standards an auditor can trace**

```text
/agent-os:discover-standards api
Propose at most eight standards from src/api/ and src/payments/. For each one, cite two existing files that follow it and one that violates it, if any. Skip anything a linter already enforces. I will confirm each standard individually before you write it.
```

## Tessl, cc-sdd and Conductor: lighter spec gates

These three give you an approved spec before code, with far less ceremony and no event log; git history is your record.

### Tessl's spec-driven-development tile

Tessl is a registry for agent context packages ("tiles"). The tile `tessl-labs/spec-driven-development` ships four skills (`requirement-gathering`, `spec-writer`, `spec-verification`, `work-review`) and two always-on rules, `spec-before-code` and `one-question-at-a-time`. Specs land in `specs/` as `.spec.md` files with `[@test]` links to the tests that prove them.

```bash
npx @tessl/cli install tessl-labs/spec-driven-development   # no global install
# or: npm i -g @tessl/cli && tessl init && tessl install tessl-labs/spec-driven-development
```

Then add "Use spec-driven development." to the request; the agent interviews you, writes the spec and waits for approval. The agents `tessl init` detects (Claude Code, Cursor, Gemini, Codex, Copilot) come from Tessl's docs (secondary). The npm package downloads a proprietary native binary, so a zero-vendor policy rules it out.

### cc-sdd: Kiro-style specs in Claude Code, Codex and Cursor

cc-sdd installs 17 Agent Skills that reproduce Kiro's requirements, design and tasks flow, and its README states that existing Kiro specs stay compatible.

**Claude Code**

```bash
npx cc-sdd@latest
```

**Codex**

```bash
npx cc-sdd@latest --codex-skills
```
The legacy `--codex` mode is blocked; use `--codex-skills`.

**Cursor**

```bash
npx cc-sdd@latest --cursor-skills
```
Beta. The legacy `--cursor` mode is deprecated.

A new feature runs `/kiro-discovery <idea>` → `/kiro-spec-init <name>` → `/kiro-spec-requirements` → `/kiro-spec-design` → `/kiro-spec-tasks` → `/kiro-impl`; on an existing system, run `/kiro-steering` first.

### Conductor

Conductor's current README documents Antigravity and Claude Code only. In Claude Code:

```text
/plugin marketplace add gemini-cli-extensions/conductor
/plugin install conductor
/conductor:conductor-setup
/conductor:conductor-new-track "Add a second approver for refunds above EUR 10,000"
/conductor:conductor-implement
/conductor:conductor-review
```

`/conductor:conductor-revert` undoes a track, phase or task along logical boundaries rather than raw commits.

## What does each framework cost in ceremony?

| Framework | Ceremony on a normal change | Context cost you can measure | Worth it for |
| --- | --- | --- | --- |
| AI-DLC `enterprise` | 33 stages, a gate after each | Compare context before and after `aidlc config` | Regulated work, where "the cost of an undocumented decision is higher than the cost of the additional ceremony" (profile guide); never a copy change |
| AI-DLC `bugfix` / `refactor` / `security-patch` | 9 (`bugfix`) or 10 (`refactor`, `security-patch`) of 33 stages at Minimal depth | Same install | Focused changes in a regulated repository; the memory pin keeps them strict |
| Agent OS v3 | None beyond confirming standards once | Commands only, loaded when invoked | Conventions, not audit |
| Tessl tile | One interview, one spec approval | Two always-on rules plus four skills | A spec gate with registry-managed context |
| cc-sdd | Three spec approvals per feature | 17 skills, loaded on demand | Kiro-shaped specs outside Kiro |
| Conductor | One setup, one plan approval per track | About 302 always-on tokens (`claude plugin details`, 2.1.283) | Durable project context |

**Traps in this category (checked 2026-09-26)**

- **`/aidlc` in Codex does nothing useful.** Codex uses `$aidlc`, and the hooks do not run until you trust them.
- **A `HUMAN_TURN` proves presence, not identity.** AI-DLC's own guide says the gate check "proves presence and ordering, not authorship of the later caller-supplied decision text". Bind identity with signed commits and required pull request approvals.
- **Most profiles are not strict.** Seven of the 11 default to `relaxed`; pin `Mode: strict` in memory.
- **Agent OS v2 guides are stale.** `scripts/base-install.sh` returns 404 in v3, `/write-spec` and `/implement-tasks` are gone, and there is no npm package `agent-os`.
- **Kiro specs are not an npm package.** Kiro's specs live in `.kiro/specs/` (plural) and its CLI binary is `kiro-cli` (secondary: kiro.dev search snippets); for other agents, install cc-sdd.
- **Conductor's org name is historical.** Its README documents Antigravity and Claude Code, not Gemini CLI.
- **The AI-DLC README recommends a model.** Model choice belongs to your agent; start on its default and see the [model hub](/en/ecosystem/models/) before you switch.

## What breaks when you run an audited agent workflow?

**The gates never appear in Codex or Cursor.** The hooks did not run: in Codex, the project hooks were never trusted. Run `aidlc doctor`, trust the hooks and start a new session; after an upgrade, a new session also loads the refreshed skills.

**`aidlc` is not found after installing.** Apply the PATH line the installer printed or open a new shell. On runtime/CLI version skew, finish the active workflow, then rerun `aidlc config`.

**Approval is refused even though you typed "approve".** The gate needs a `HUMAN_TURN` since the last gate resolution; if the agent's question picker does not record one, type "approve" as a normal prompt.

**The workflow will not advance.** Run `/aidlc --status`: `[?]` means a gate is waiting for you, `[R]` means a revision is in progress. `/aidlc --doctor` lists findings such as `gate-unresolved` and `runtime-graph-stale`. `aidlc-state.md` can be rebuilt from the `STAGE_STARTED` and `STAGE_COMPLETED` events in the shards.

**Completion is refused after you touched the code.** A source path changed after review without a claim. Revert the change or take AI-DLC's stale-unit recovery; never set `AIDLC_SKIP_SOURCE_FRESHNESS=1` in a regulated intent, because it switches off the check your auditor cares about.

**The CI step "A guard was lowered or a plan approval overridden" fails.** Something lowered a fence, usually an environment kill switch (`AIDLC_DISABLE_PLAN_APPROVAL_GUARD`, `AIDLC_DISABLE_REVIEW_FREEZE_HOOK`, `AIDLC_DISABLE_REVIEWER_SCOPE_HOOK`); the `Fences:` line of `/aidlc --status` names the source. Remove it for future runs; the rows already written stay in the trail. To pass this pull request, commit `docs/compliance/<intent>-justification.md`, get it approved by its CODEOWNERS, and add the `aidlc-guard-justified` label.

**The CI step fails with "Regulated change without an AI-DLC audit trail".** Code under `REGULATED_PATHS` changed but no shard did. Run the change through `/aidlc` and commit the shards.

**The team drowns in ceremony.** A 33-stage run on a small change teaches people to click **Approve** without reading. Reserve `enterprise` for audit-sensitive work.

## Where to go next with audited delivery

- Compare the full spec-first family, including Spec Kit and OpenSpec, on [spec-driven frameworks compared](/en/ecosystem/frameworks/spec-driven-frameworks/), or see every framework on the [frameworks overview](/en/ecosystem/frameworks/).
- Write the spec the gates approve with [spec-driven development](/en/workflows/plan/spec-driven-development/), and see which file each stage should leave behind in the [artifact chain](/en/method/lifecycle/artifact-chain/).
- Attach proof to every pull request with the [evidence bundle](/en/workflows/ship/evidence-bundle/).
- For the organisation-level controls around this workflow, read [AI in regulated industries](/en/org/regulated-industries/) and [governance and agent autonomy](/en/org/governance-autonomy/).
