# Frameworki z audytem i standardami: AI-DLC, Agent OS, Tessl i specyfikacje w stylu Kiro

URL: https://developertoolkit.ai/pl/ecosystem/frameworks/enterprise-frameworks/
Description: AWS AI-DLC z bramkami akceptacji i commitowanym śladem audytowym oraz wybór między Agent OS, Tessl, cc-sdd i Conductorem dla standardów i specyfikacji.

AI-DLC (AI-Driven Development Life Cycle od AWS Labs) to jedyny framework w tej grupie, który łączy ludzkie bramki akceptacji z commitowanym śladem audytowym typu append-only obejmującym 118 typów zdarzeń (README v2.11.0, 2026-10-10). Działa w Claude Code, Codex i Cursorze. Agent OS v3 wykrywa i wstrzykuje standardy kodowania, a Tessl, cc-sdd i Conductor dodają lżejsze bramki akceptacji specyfikacji bez dziennika zdarzeń.

Oficer compliance zadaje proste pytanie o zeszłomiesięczną zmianę w płatnościach: kto zatwierdził wymagania, kto zatwierdził projekt i czy ktoś pominął jakiś krok? Agent napisał kod w dwa dni, pull request ma jedno „LGTM”, a jedynym zapisem decyzji jest sesja czatu, której nikt nie zachował. Chcesz, żeby następna zmiana w regulowanym obszarze zostawiała dowody jako efekt uboczny samej pracy, a nie raport pisany po fakcie.

Ta strona jest dla programisty, który uruchamia agenta, i dla tech leada, który musi odpowiedzieć na to pytanie. Przeprowadza jedną zmianę przez profil `enterprise` w AI-DLC od początku do końca, a potem pokazuje, kiedy wystarczą lżejsze frameworki.

**Wersje i popularność na tej stronie**

Sprawdzone 2026-09-26 w README każdego projektu i w rejestrze npm, przy Claude Code 2.1.283 i codex-cli 0.157.1. Gwiazdki na GitHubie z 2026-09-26: [awslabs/aidlc-workflows](https://github.com/awslabs/aidlc-workflows) 4,8 tys. (v2.10.0, MIT-0), [buildermethods/agent-os](https://github.com/buildermethods/agent-os) 5,4 tys. (v3.0, 2026-01-20), [gotalab/cc-sdd](https://github.com/gotalab/cc-sdd) 3,7 tys. (npm `cc-sdd` 3.1.0), [gemini-cli-extensions/conductor](https://github.com/gemini-cli-extensions/conductor) 3,7 tys. oraz [tesslio/spec-driven-development-tile](https://github.com/tesslio/spec-driven-development-tile) 54 (npm `@tessl/cli` 0.111.0). 2026-10-10 repozytorium miało 5,1 tys. gwiazdek, a README wydania v2.11.0 podaje 5 faz, 33 etapy, 11 profili przepływu i 118 zdarzeń w śladzie audytowym (105 z 2026-09-26 to liczba z v2.10.0). Gwiazdki mierzą zainteresowanie, nie użycie. Serwisy `kiro.dev` i `docs.tessl.io` były niedostępne, więc szczegóły o Kiro i wykrywanie agentów przez Tessl pochodzą ze źródeł wtórnych (fragmentów z wyszukiwarki) i są tak oznaczone.

## Co zyskujesz, gdy agent pracuje ze śladem audytowym

- Tabelę decyzyjną: który z pięciu frameworków wytwarza dowody audytowe, a który tylko kształtuje zachowanie agenta.
- Instalację AI-DLC dla Claude Code, Codex albo Cursora, łącznie z krokiem zaufania do hooków w Codex.
- Regulowaną dostawę w profilu `enterprise`, z Guard Policy przypiętą do `strict` i bramką po każdym etapie.
- Commitowane shardy audytu, obowiązkową kontrolę CI na nich i prompt, który zamienia je w rejestr akceptacji.
- Co udowadnia zdarzenie `HUMAN_TURN`, a czego nie.

## Który framework daje ślad audytowy, a który tylko standardy?

Tylko jeden z pięciu zapisuje maszynowo czytelny dziennik decyzji; pozostałe dają bramki albo standardy, a jedynym zapisem zostaje historia gita.

| Framework | Co wymusza | Trwałe dowody | Bramki | Claude Code / Codex / Cursor | Wybierz, gdy |
| --- | --- | --- | --- | --- | --- |
| **AI-DLC** (AWS Labs) | 5 faz, 33 etapy, 11 profili przepływu | `aidlc-state.md` plus shardy `audit/` typu append-only, 118 typów zdarzeń (README v2.11.0, 2026-10-10) | Po każdym etapie poza inicjalizacją | Tak / Tak (`$aidlc`, Codex 0.145.0 lub nowszy) / Tak | Musisz pokazać audytorowi, kto co zatwierdził i w jakiej kolejności |
| **Agent OS v3** (Builder Methods) | Konwencje zespołu, wstrzykiwane na żądanie | `agent-os/standards/` i plik indeksu | Potwierdzasz każdy wykryty standard | Tak / nieudokumentowane / deklarowane w README | Agenci ignorują wasze konwencje, a proces dostawy już macie |
| **Tile spec-driven-development firmy Tessl** | „Nigdy nie zaczynaj implementacji bez zatwierdzonej specyfikacji” | `specs/*.spec.md` powiązane z testami przez `[@test]` | Akceptacja specyfikacji | Według dokumentacji Tessl (źródło wtórne) | Chcesz wersjonowanych, ewaluowanych pakietów kontekstu z rejestru |
| **cc-sdd** (gotalab) | Wymagania, projekt i zadania w stylu Kiro | `brief.md`, wymagania, projekt i `tasks.md` dla każdej specyfikacji | Między fazami specyfikacji | Stabilne / stabilne / beta | Podoba ci się kształt specyfikacji z Kiro, ale pracujesz w Claude Code, Codex albo Cursorze |
| **Conductor** (Google, organizacja `gemini-cli-extensions`) | Kontekst, potem specyfikacja i plan, potem implementacja | Pliki `conductor/` i `tracks/<id>/{spec,plan}.md` | Akceptacja planu przed kodem | Tak / nieudokumentowane / nieudokumentowane | Chcesz trwałego kontekstu projektu i cofania zmian z uwzględnieniem historii gita przy małej ceremonii |

Kiro ma ten sam przepływ wymagania–projekt–zadania wbudowany we własne IDE i CLI (źródło wtórne: fragmenty kiro.dev z wyszukiwarki); nie zainstalujesz go w innym agencie, więc ten kształt daje tam cc-sdd. Przepływ samego Kiro opisuje [strona o Kiro](/pl/comparison/kiro/).

Reguła, której trzyma się ta strona: jeśli pytanie brzmi „kto to zatwierdził”, użyj AI-DLC. Jeśli „dlaczego agent wciąż ignoruje nasze konwencje”, użyj Agent OS albo folderu wiedzy w AI-DLC. Jeśli „czy ktoś uzgodnił zachowanie przed napisaniem kodu”, wystarczy dowolny framework specyfikacji; szersze porównanie jest na stronie [porównanie frameworków spec-driven](/pl/ecosystem/frameworks/spec-driven-frameworks/).

## Zainstaluj AI-DLC w Claude Code, Codex albo Cursorze

AI-DLC to natywne polecenie `aidlc` plus środowisko uruchomieniowe dla każdego obsługiwanego agenta. Między narzędziami różnią się tylko wartość `--harness`, znak wywołania i jeden krok zaufania.

1. Zainstaluj polecenie `aidlc`. Jednolinijkowy instalator przekazuje skrypt prosto do powłoki, więc na zarządzanej maszynie pobierz `install.sh` z [najnowszego wydania](https://github.com/awslabs/aidlc-workflows/releases/latest), przeczytaj go i dopiero wtedy uruchom.

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

   W Windows PowerShell README podaje `irm https://github.com/awslabs/aidlc-workflows/releases/latest/download/install.ps1 | iex`. Nie potrzebujesz ani Buna, ani Node.js.

2. Skonfiguruj projekt dla swojego agenta i uruchom kontrolę stanu z katalogu głównego repozytorium.

   **Claude Code**

   ```bash
   cd ~/src/payments-service
   aidlc config --harness claude
   aidlc doctor
   claude
   ```
   W sesji zacznij pracę od `/aidlc`.

   **Codex**

   ```bash
   cd ~/src/payments-service
   aidlc config --harness codex
   aidlc doctor
   codex
   ```
   AI-DLC wymaga codex-cli 0.145.0 lub nowszego. Codex nigdy nie uruchamia niezaufanych hooków projektu, a bramki AI-DLC zależą od hooków: w oknie hooków wybierz **Trust all and continue** albo scal blok `[hooks.state]` z wygenerowanego `.codex/trust-seed.toml` z plikiem `$CODEX_HOME/config.toml`. W sesji zaczynasz od `$aidlc`, nie od `/aidlc`.

   **Cursor**

   ```bash
   cd ~/src/payments-service
   aidlc config --harness cursor
   aidlc doctor
   ```
   Otwórz projekt w Cursorze i zacznij pracę od `/aidlc`. Środowisko instaluje 14 person jako subagentów, skille, `.cursor/hooks.json` i sekcję w `AGENTS.md`.

   Pozostałe wartości `--harness` to `kiro`, `kiro-ide`, `opencode` i `copilot`. `aidlc config` bez flagi uruchamia konfigurację interaktywną.

3. Zacommituj to, co zapisała konfiguracja. `aidlc-state.md`, shardy `audit/*.md` i każdy artefakt etapu należą do gita; pliki lokalne dla maszyny, które wymienia zarządzany przez AI-DLC blok `.gitignore` (`.aidlc-engine/`, znacznik danego klonu, kursory aktywnej przestrzeni i aktywnej intencji), pozostają ignorowane. Dopisz też `aidlc/diagnostics/` do `.gitignore`, żeby pakiet diagnostyczny nigdy nie trafił obok dowodów.

AI-DLC nie jest pluginem Claude Code, więc `claude plugin details` nie pokaże jego kosztu kontekstu; przed wdrożeniem w zespole porównaj zużycie kontekstu w sesji przed `aidlc config` i po nim na własnym repozytorium.

## Przeprowadź regulowaną zmianę przez bramki akceptacji i eksport audytu

Przykład prowadzi zmianę „dodaj drugi krok akceptacji dla zwrotów powyżej 10 000 EUR” przez profil `enterprise`: wszystkie 33 etapy z głębokością i strategią testów Comprehensive oraz Guard Policy domyślnie `strict` (tak jak w `security-patch` i `infra`; siedem profili ma domyślnie `relaxed`, a `express` ma `off`).

1. **Wczytaj standardy przed pierwszym etapem.** Każdy agent wczytuje Markdown z `aidlc/spaces/default/knowledge/aidlc-shared/`: umieść tam standardy kodowania, zasady architektury i reguły compliance, a nie w `.claude/knowledge/`, które nadpisuje każda aktualizacja. Konwencje istniejące tylko w kodzie wyciągniesz przez [Agent OS](#dodaj-standardy-zespołu-bez-całego-pipelineu-agent-os-v3).

2. **Przypnij Guard Policy do `strict` dla całego repozytorium.** Inaczej każdy może wpisać `/aidlc --guard-policy relaxed`, co pozwala zabezpieczeniom Plan Approval i review-freeze ustąpić. Dodaj sekcję `## Guard Policy` (albo użyj istniejącej) w `aidlc/spaces/default/memory/org.md` i wpisz w niej jedną linię:

   ```markdown
   ## Guard Policy

   Mode: strict
   ```

   `strict` w pamięci wygrywa z domyślną wartością każdego profilu i odrzuca `--guard-policy relaxed`, `--guard-policy off` oraz `/aidlc config set guard.<fence> off`. Obejmij ten plik CODEOWNERS. Wyłącznik w zmiennej środowiskowej nadal ma pierwszeństwo i nadal zapisuje wiersze `GUARD_STOOD_ASIDE`, które wyłapuje kontrola CI poniżej.

3. **Uruchom przepływ w profilu enterprise.** Nazwij profil wprost. Przy samym opisie AI-DLC dopasuje profil po słowach kluczowych i poprosi o potwierdzenie; chcesz mieć `enterprise` w zapisie od pierwszego zdarzenia, a nie późniejszy wiersz `SCOPE_CHANGED`.

   **Prompt do skopiowania: uruchom regulowaną zmianę w 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.
   ```
   W Codex zacznij linię od `$aidlc enterprise`.

4. **Traktuj każdą bramkę jak podpis, a nie formalność.** Każdy etap kończy się opcją **Approve** albo **Request Changes**. Approve zapisuje `GATE_APPROVED` i przesuwa przepływ dalej; Request Changes zapisuje `GATE_REJECTED`, przełącza etap w stan `[R]` i ponownie otwiera bramkę po poprawkach. Ustal z góry, kto co zatwierdza (product owner: wymagania; tech lead: projekt; bezpieczeństwo: artefakty zagrożeń i compliance), i czytaj artefakt, a nie jego streszczenie w czacie.

   **Prompt do skopiowania: kontrola przed zatwierdzeniem bramki**

   ```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. **Zatwierdź polecenie weryfikacji raz i zostaw punkty kontrolne pod bramką.** W fazie Construction zatwierdzasz kontrolę, którą AI-DLC powtarza przy każdym punkcie kontrolnym jednostki, na przykład `npm test && npm run typecheck`; nieudana kontrola zatrzymuje przebieg, więc wybierz taką, która pada przy naruszeniu zachowań z wymagań. Wybierz **Review each checkpoint** zamiast **Continue automatically**; zapisuje to `gated` w wierszu `AUTONOMY_MODE_SET`.

6. **Sprawdzaj status bez przesuwania przepływu.** `/aidlc --status` działa tylko do odczytu i pokazuje etap, Guard Policy ze źródłem tej wartości oraz linię `Fences:`. Chcesz widzieć `Guard Policy: strict (from org.md)`.

7. **Eksportuj ślad audytowy razem z pull requestem.** Ślad leży w `aidlc/spaces/<space>/intents/<YYMMDD>-<label>/audit/`, po jednym shardzie na klon (`<host>-<clone>.md`), więc równoległe worktree nie wchodzą w konflikt. Każdy wpis ma nadany przez narzędzie znacznik czasu ISO 8601 i linię `**Event**:`; agenci nie mogą pisać do shardu bezpośrednio. Eksportem jest commit, który dostarcza kod razem z plikiem stanu, artefaktami i shardami. `aidlc engine audit history` wypisuje te same zdarzenia jako JSON, ale AI-DLC nazywa trasy `aidlc engine` mechaniką harnessu, a nie stabilnym interfejsem, więc CI opieraj na zacommitowanych shardach.

   **Prompt do skopiowania: rejestr akceptacji dla audytora**

   ```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` to coś innego: zapisuje zredagowane archiwum `.tar.gz` w `aidlc/diagnostics/` zawierające `report.md` i `report.json` z osią czasu przepływu (czasy etapów, bramki, poprawki, luki). Hashuje identyfikatory intencji, redaguje ścieżki i pomija surowe pliki audytu oraz treść artefaktów, więc służy opiekunom AI-DLC, nie audytorowi.

## Odrzuć pull request, gdy obniżono strażnika

To zadanie czyta wyłącznie zacommitowane pliki i nie potrzebuje sekretów, więc jest bezpieczne dla pull requestów z forków. Działa przy każdym pull requeście, nie tylko przy tych, które dotykają `aidlc/`, bo najbardziej trzeba wyłapać regulowany kod bez żadnego śladu. Ustaw `REGULATED_PATHS` na własne katalogi i oznacz `audit-gate` jako wymaganą kontrolę statusu w ochronie gałęzi; kontrola, która nie jest wymagana, tylko raportuje.

```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
```

Wzorce pasują do linii `**Event**: <NAZWA>` z formatu audytu AI-DLC (`audit-format.md`, v2.10.0). Przeszukiwane są tylko dodane lub zmienione shardy; usunięty shard powoduje osobny błąd, bo usunięcie dowodów to dokładnie to, co recenzent musi zobaczyć.

Wierszy o ustąpieniu zabezpieczenia nie da się usunąć z shardu, więc krok o obniżonym strażniku ma furtkę, która sama zostawia dowód: etykietę `aidlc-guard-justified` **oraz** plik `docs/compliance/<intent>-justification.md` zacommitowany w tym samym pull requeście. Obejmij `docs/compliance/`, `aidlc/**` i `.github/workflows/aidlc-audit-gate.yml` regułą CODEOWNERS z wymaganą recenzją: przy `pull_request` GitHub uruchamia ten workflow z merge refa pull requesta, więc bez tej recenzji pull request mógłby przepisać samą bramkę. Typy zdarzeń `labeled` i `unlabeled` uruchamiają zadanie ponownie po zmianie etykiety.

## Jak udowodnić wynik AI-DLC bez czytania każdej linii?

Pełna nazwa AI-DLC zawiera ogólne określenie AI-driven development ([programowanie sterowane przez AI](/pl/glossary/ai-driven-development/)), które wskazuje, kto prowadzi pracę, a sprawdzają ją bramki zatwierdzeń i ślad audytowy. Bramki dowodzą, że człowiek obejrzał każdy artefakt, a nie że kod jest poprawny. Taki dowód pochodzi z czterech miejsc i żadne z nich nie polega na czytaniu diffu:

| Dowód | Skąd pochodzi | Kto się podpisuje |
| --- | --- | --- |
| Wymagania i projekt zatwierdzono przed kodem | Wiersze `GATE_APPROVED` dla każdego etapu fazy Inception | Product owner, tech lead |
| Testy kodują zatwierdzone zachowanie | Strategia testów Comprehensive plus zarejestrowane polecenie weryfikacji przy każdym punkcie kontrolnym jednostki | Inżynier, który zatwierdził polecenie |
| Zrecenzowany kod to kod wdrożony | Pokwitowania recenzji powiązane ze źródłem: `source-manifest.json` i odcisk dla każdej jednostki; zakończenie jest odrzucane, jeśli źródło zmieniło się po recenzji | Dwaj agenci-recenzenci AI-DLC, potem CI |
| Nikt po cichu nie obniżył strażnika | `Mode: strict` w pamięci i wymagana kontrola CI powyżej | Tech lead, przez CODEOWNERS dla `aidlc/**` |

Zachowaj na wierzchu zwykłe bramki: sprawdzanie typów, lint, zestaw testów i [pakiet dowodów](/pl/workflows/ship/evidence-bundle/) w pull requeście. AI-DLC zapisuje, że decyzje zapadły w odpowiedniej kolejności; testy i CI dowodzą, że wynik działa.

## Dodaj standardy zespołu bez całego pipeline’u: Agent OS v3

Agent OS v3 (2026-01-20) porzucił własne fazy implementacji („Spec creation now defers to Plan Mode”) i zachował pięć poleceń: wykrywanie, indeksowanie i wstrzykiwanie standardów, kształtowanie specyfikacji w trybie planowania oraz `plan-product` do opisu misji produktu. Używaj go, gdy problemem są konwencje, a nie audyt.

Skrypt projektowy `scripts/project-install.sh` jest zweryfikowany w repozytorium i kopiuje polecenia do `.claude/commands/agent-os/`. Linia instalacji bazowej pochodzi z fragmentu oficjalnej strony instalacji w wyszukiwarce, więc najpierw sprawdź ją u źródła:

```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
```

W Claude Code polecenia pojawiają się w przestrzeni nazw `agent-os`:

```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
```

README nie dokumentuje instalacji dla Codex. W Codex i Cursorze odwołaj się do folderu standardów z `AGENTS.md` albo z reguł Cursora lub skopiuj go do `aidlc-shared/` w AI-DLC; zobacz [synchronizację reguł](/pl/ecosystem/frameworks/rules-sync/).

**Prompt do skopiowania: standardy, które audytor może prześledzić**

```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 i Conductor: lżejsze bramki specyfikacji

Te trzy dają zatwierdzoną specyfikację przed kodem, przy znacznie mniejszej ceremonii i bez dziennika zdarzeń; zapisem jest historia gita.

### Tile spec-driven-development firmy Tessl

Tessl to rejestr pakietów kontekstu dla agentów („tiles”). Tile `tessl-labs/spec-driven-development` zawiera cztery skille (`requirement-gathering`, `spec-writer`, `spec-verification`, `work-review`) i dwie stale aktywne reguły, `spec-before-code` i `one-question-at-a-time`. Specyfikacje trafiają do `specs/` jako pliki `.spec.md` z odnośnikami `[@test]` do testów, które ich dowodzą.

```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
```

Potem dopisz do prośby „Use spec-driven development.”; agent przepytuje cię, pisze specyfikację i czeka na akceptację. Agenci wykrywani przez `tessl init` (Claude Code, Cursor, Gemini, Codex, Copilot) pochodzą z dokumentacji Tessl (źródło wtórne). Pakiet npm pobiera zamknięty, natywny plik binarny, więc polityka zero-vendor go wyklucza.

### cc-sdd: specyfikacje w stylu Kiro w Claude Code, Codex i Cursorze

cc-sdd instaluje 17 Agent Skills odtwarzających przepływ wymagania–projekt–zadania z Kiro, a jego README zapewnia, że istniejące specyfikacje Kiro pozostają zgodne.

**Claude Code**

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

**Codex**

```bash
npx cc-sdd@latest --codex-skills
```
Starszy tryb `--codex` jest zablokowany; użyj `--codex-skills`.

**Cursor**

```bash
npx cc-sdd@latest --cursor-skills
```
Beta. Starszy tryb `--cursor` jest przestarzały.

Nowa funkcja przechodzi `/kiro-discovery <idea>` → `/kiro-spec-init <name>` → `/kiro-spec-requirements` → `/kiro-spec-design` → `/kiro-spec-tasks` → `/kiro-impl`; w istniejącym systemie zacznij od `/kiro-steering`.

### Conductor

Obecne README Conductora dokumentuje tylko Antigravity i Claude Code. W 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` cofa track, fazę albo zadanie według granic logicznych, a nie surowych commitów.

## Ile ceremonii kosztuje każdy framework?

| Framework | Ceremonia przy zwykłej zmianie | Koszt kontekstu, który możesz zmierzyć | Warto, gdy |
| --- | --- | --- | --- |
| AI-DLC `enterprise` | 33 etapy, bramka po każdym | Porównaj kontekst przed `aidlc config` i po nim | Praca regulowana, gdzie „the cost of an undocumented decision is higher than the cost of the additional ceremony” (przewodnik po profilach); nigdy przy zmianie tekstu |
| AI-DLC `bugfix` / `refactor` / `security-patch` | 9 (`bugfix`) albo 10 (`refactor`, `security-patch`) z 33 etapów, głębokość Minimal | Ta sama instalacja | Punktowe zmiany w regulowanym repozytorium; przypięcie w pamięci utrzymuje je w trybie strict |
| Agent OS v3 | Nic poza jednorazowym potwierdzeniem standardów | Tylko polecenia, wczytywane przy wywołaniu | Konwencje, nie audyt |
| Tile Tessl | Jeden wywiad, jedna akceptacja specyfikacji | Dwie stale aktywne reguły plus cztery skille | Bramka specyfikacji z kontekstem zarządzanym przez rejestr |
| cc-sdd | Trzy akceptacje specyfikacji na funkcję | 17 skilli, wczytywanych na żądanie | Specyfikacje w kształcie Kiro poza Kiro |
| Conductor | Jedna konfiguracja, jedna akceptacja planu na ścieżkę (track) | Około 302 stale obecnych tokenów (`claude plugin details`, 2.1.283) | Trwały kontekst projektu |

**Pułapki w tej kategorii (sprawdzone 2026-09-26)**

- **`/aidlc` w Codex nic sensownego nie robi.** Codex używa `$aidlc`, a hooki nie ruszą, dopóki im nie zaufasz.
- **`HUMAN_TURN` dowodzi obecności, nie tożsamości.** Przewodnik AI-DLC sam pisze, że kontrola bramki „proves presence and ordering, not authorship of the later caller-supplied decision text”. Tożsamość wiąż przez podpisane commity i wymagane akceptacje pull requestów.
- **Większość profili nie jest strict.** Siedem z 11 ma domyślnie `relaxed`; przypnij `Mode: strict` w pamięci.
- **Poradniki do Agent OS v2 są nieaktualne.** `scripts/base-install.sh` zwraca 404 w v3, `/write-spec` i `/implement-tasks` zniknęły, a pakietu npm `agent-os` nie ma.
- **Specyfikacje Kiro to nie pakiet npm.** Kiro trzyma je w `.kiro/specs/` (liczba mnoga), a plik binarny jego CLI to `kiro-cli` (źródło wtórne: fragmenty kiro.dev); dla innych agentów zainstaluj cc-sdd.
- **Nazwa organizacji Conductora jest historyczna.** Jego README dokumentuje Antigravity i Claude Code, nie Gemini CLI.
- **README AI-DLC rekomenduje model.** Wybór modelu należy do agenta; zacznij od jego domyślnego modelu i zajrzyj do [przeglądu modeli](/pl/ecosystem/models/), zanim go zmienisz.

## Co się psuje w przepływie pracy agenta z audytem?

**Bramki nie pojawiają się w Codex ani w Cursorze.** Hooki się nie uruchomiły: w Codex nikt nie zaufał hookom projektu. Uruchom `aidlc doctor`, zaufaj hookom i zacznij nową sesję; po aktualizacji nowa sesja wczyta też odświeżone skille.

**Po instalacji nie ma polecenia `aidlc`.** Zastosuj linię PATH wypisaną przez instalator albo otwórz nową powłokę. Przy rozjeździe wersji środowiska i CLI dokończ aktywny przepływ i ponownie uruchom `aidlc config`.

**Akceptacja zostaje odrzucona mimo wpisania „approve”.** Bramka wymaga `HUMAN_TURN` od ostatniego rozstrzygnięcia bramki; jeśli okno wyboru agenta go nie zapisuje, wpisz „approve” jako zwykły prompt.

**Przepływ nie rusza dalej.** Zacznij od `/aidlc --status`: `[?]` oznacza, że bramka czeka na ciebie, a `[R]`, że trwa poprawka. `/aidlc --doctor` wypisuje ustalenia, takie jak `gate-unresolved` i `runtime-graph-stale`. `aidlc-state.md` da się odbudować ze zdarzeń `STAGE_STARTED` i `STAGE_COMPLETED` w shardach.

**Zakończenie jest odrzucane, bo ruszałeś kod.** Ścieżka źródłowa zmieniła się po recenzji bez przypisania. Cofnij zmianę albo skorzystaj ze ścieżki odzyskiwania nieaktualnej jednostki w AI-DLC; nigdy nie ustawiaj `AIDLC_SKIP_SOURCE_FRESHNESS=1` w regulowanej intencji, bo wyłącza dokładnie tę kontrolę, na której zależy audytorowi.

**Krok CI „A guard was lowered or a plan approval overridden” pada.** Coś obniżyło zabezpieczenie, zwykle wyłącznik w zmiennej środowiskowej (`AIDLC_DISABLE_PLAN_APPROVAL_GUARD`, `AIDLC_DISABLE_REVIEW_FREEZE_HOOK`, `AIDLC_DISABLE_REVIEWER_SCOPE_HOOK`); linia `Fences:` w `/aidlc --status` podaje źródło. Usuń je na przyszłość; zapisane już wiersze zostają w śladzie. Żeby ten pull request przeszedł, zacommituj `docs/compliance/<intent>-justification.md`, uzyskaj akceptację jego CODEOWNERS i dodaj etykietę `aidlc-guard-justified`.

**Krok CI pada z komunikatem „Regulated change without an AI-DLC audit trail”.** Zmienił się kod w `REGULATED_PATHS`, a żaden shard nie. Przeprowadź zmianę przez `/aidlc` i zacommituj shardy.

**Zespół tonie w ceremonii.** 33 etapy przy małej zmianie uczą ludzi klikać **Approve** bez czytania. Zostaw `enterprise` na pracę wrażliwą audytowo.

## Dokąd dalej z dostawą objętą audytem

- Porównaj całą rodzinę frameworków spec-first, łącznie ze Spec Kit i OpenSpec, na stronie [porównanie frameworków spec-driven](/pl/ecosystem/frameworks/spec-driven-frameworks/) albo zobacz wszystkie frameworki w [przeglądzie frameworków](/pl/ecosystem/frameworks/).
- Napisz specyfikację, którą zatwierdzają bramki, według strony [spec-driven development](/pl/workflows/plan/spec-driven-development/) i sprawdź, jaki plik powinien zostawić każdy etap, w [łańcuchu artefaktów](/pl/method/lifecycle/artifact-chain/).
- Dołączaj dowody do każdego pull requesta dzięki [pakietowi dowodów](/pl/workflows/ship/evidence-bundle/).
- Kontrole na poziomie organizacji wokół tego przepływu opisują strony [AI w branżach regulowanych](/pl/org/regulated-industries/) i [governance i autonomia agentów](/pl/org/governance-autonomy/).
