# Polityka korzystania z AI, której inżynierowie będą przestrzegać

URL: https://developertoolkit.ai/pl/org/usage-policy/
Description: Szablon zasad korzystania z agentów AI: klasy danych, zatwierdzone ścieżki, ujawnianie, recenzje i zakazy; przy każdym punkcie sposób egzekwowania.

Polityka korzystania z AI dla agentów kodujących to dokument zasad dopuszczalnego użycia, obejmujący klasy danych, zatwierdzone ścieżki dostępu, ujawnianie, obowiązki recenzji i zakazane działania, w którym każdy punkt ma oznaczenie sposobu egzekwowania: ustawienia zarządzane, hook lub reguła repozytorium, wykrywanie po fakcie albo samo zaufanie. Punkty oparte na zaufaniu wymagają nazwanej kontroli.

Wiosną dział prawny rozesłał czterostronicowy PDF „Zasady korzystania z generatywnej AI”. Od tamtej pory dwóch deweloperów zalogowało się do Claude Code kontami prywatnymi, ktoś dodał niesprawdzony serwer MCP, który czyta całą instancję Jiry, a nikt nie potrafi wskazać, które scalone pull requesty napisał agent. PDF nie był błędny; był nieegzekwowalny i nieweryfikowalny.

Ta strona jest dla CTO, który podpisuje politykę, i dla tech leada, który ma sprawić, żeby obowiązywała w ośmiu repozytoriach. Korzysta z poziomów klasyfikacji danych z [prywatności danych i polityk firmowych](/pl/org/privacy-data-handling/), a dystrybucję i audyt zostawia [jednej polityce dla wszystkich agentów kodujących](/pl/org/managed-policy/).

## Co daje ci ten szablon polityki korzystania z AI

- Politykę w 28 numerowanych punktach do podręcznika zespołu, z typem egzekwowania przy każdym punkcie.
- Mapę egzekwowania, która wskazuje ustawienie Claude Code, Codex, Cursora albo repozytorium stojące za każdym punktem.
- Plik ustawień zarządzanych dla Claude Code i `requirements.toml` dla Codex.
- Hook sprawdzający prompty i kontrolę ujawniania w pull requestach.
- Procedurę weryfikacji oraz typowe awarie, które po cichu wyłączają punkty polityki.

## Dlaczego inżynierowie ignorują większość polityk AI?

Większość polityk AI opisuje wartości („korzystaj z AI odpowiedzialnie”), a nie zachowania, które recenzent mógłby sprawdzić. Inżynier albo trzyma się litery i traci narzędzia, albo kieruje się własnym osądem i liczy na szczęście. Żadne z nich nie daje „jasnego i zakomunikowanego stanowiska wobec AI” (Clear and communicated AI stance), które DORA wymienia jako pierwszą z siedmiu zdolności w swoim modelu AI (blog Google Cloud, Storer i DeBellis, 2025-09-23). Uzasadnienie DORA: „Niejasność rodzi ryzyko. Jasna polityka daje deweloperom psychologiczne bezpieczeństwo potrzebne do skutecznego eksperymentowania” (oryg. ang.: „Ambiguity creates risk. A clear policy provides the psychological safety developers need to experiment effectively”; blog Google Cloud, Harvey i Park, 2025-12-10).

Polityka, której inżynierowie przestrzegają, jest krótka i konkretna: każdy punkt nazywa działanie, klasę danych albo ustawienie narzędzia, a punkt, którego nie da się złamać konkretnym czynem, należy do preambuły. Jest egzekwowana tam, gdzie pozwala narzędzie, i uczciwa co do reszty: punkty, których nie wyegzekwuje żadne ustawienie („nie wklejaj danych klientów do czatu w przeglądarce na telefonie”), oznacza jako punkty zaufania z nazwaną kontrolą.

## Jak oznaczany jest każdy punkt?

| Oznaczenie | Znaczenie | Dowód, że punkt obowiązuje |
| --- | --- | --- |
| `[MANAGED]` | Egzekwowany przez zarządzaną konfigurację narzędzia, której użytkownik ani repozytorium nie nadpiszą | `/status` w Claude Code wskazuje źródło zarządzane; `/debug-config` w Codex pokazuje źródło wymagań |
| `[HOOK]` | Egzekwowany przez hook wdrożony przez organizację, który blokuje działanie w trakcie pracy | Zdarzenia blokad hooka w telemetrii; ćwiczenie, które wyzwala blokadę |
| `[REPO]` | Egzekwowany przez reguły repozytorium albo wymaganą kontrolę CI, niezależnie od narzędzia, które napisało kod | Konfiguracja rulesetów i wymaganych kontroli (status checks); testowy PR, który nie przechodzi |
| `[DETECT]` | Nie jest blokowany, ale wykrywany po fakcie przez telemetrię, logi audytowe lub skanowanie | Nazwany dashboard lub raport i jego właściciel |
| `[TRUST]` | Opiera się na osądzie inżyniera; żadne narzędzie nie widzi tego działania | Nazwana okresowa kontrola (próbkowanie, oświadczenie, rejestr szkoleń) |

Dąż do przewagi punktów `[MANAGED]`, `[HOOK]` i `[REPO]`; polityka złożona głównie z `[TRUST]` to PDF działu prawnego, tylko lepiej sformatowany.

## Szablon polityki korzystania z AI

Skopiuj go do podręcznika i podmień właścicieli oraz listę narzędzi. Zostaw stałe numery punktów, bo cytują je hooki, komunikaty CI i zgłoszenia wyjątków.

```markdown
# AI usage policy for software engineering (v1.0, owner: CTO, reviewed quarterly)

Purpose: let every engineer use coding agents daily, on real work, inside guardrails
the tools enforce. Where a guardrail cannot be enforced, this policy says so.

## 1. Scope
1.1 Applies to every employee and contractor who uses an AI coding tool (IDE agent,
    CLI agent, cloud agent, chat assistant) on company code, data or systems. [TRUST]
1.2 Applies to unattended agents (CI jobs, scheduled loops, review bots) through their
    owners, recorded in the agent identity register. [DETECT]

## 2. Data classes (tiers from the data privacy policy)
2.1 Public and Internal code may be used with any approved route (section 3). [MANAGED]
2.2 Confidential material (unreleased features, pricing logic, security design) may be
    used only through approved routes whose terms exclude training on company data. [MANAGED]
2.3 Credentials never appear in a prompt. [HOOK]
2.4 Customer PII, payment and health data never enter an agent's context: not in prompts,
    files the agent can read, logs or test fixtures. [TRUST]
2.5 Agents may not read secret files (.env*, cloud credential files, SSH keys). [MANAGED]
2.6 Production data reaches an agent only as an anonymized or synthetic copy. [TRUST]

## 3. Approved routes
3.1 Use only the approved tools listed in the tool register, signed in to the company
    tenant. Personal accounts on company work are not allowed. [MANAGED]
3.2 Use only the models on the approved list; new models are added through the model
    change process. [MANAGED]
3.3 MCP servers, plugins and plugin marketplaces must be on the allowlist. [MANAGED]
3.4 Browser chat assistants outside the tool register may be used for Public material
    only. [TRUST]
3.5 A tool not on the register can be trialed through an exception (section 7), never
    by installing it and asking later. [DETECT]

## 4. Disclosure
4.1 Commits an agent authored or co-authored carry the tool's attribution trailer; do not
    strip it. [MANAGED] [DETECT]
4.2 Every pull request states its AI assistance level: none, assisted or agent-authored. [REPO]
4.3 Customer-facing deliverables produced with agents follow the client contract's
    disclosure clause. [TRUST]

## 5. Review duties
5.1 A human with merge rights approves every change before it reaches the default
    branch; an agent approval never counts as the required review. [REPO]
5.2 The approver is accountable for the change as if they wrote it, and approves on
    evidence (tests, checks, acceptance criteria), not on the agent's summary. [TRUST]
5.3 Changes to paths owned by security, payments or infrastructure require a review
    from the owning team. [REPO]
5.4 CI gates (type check, lint, tests, secret scanning, dependency checks) must pass;
    no agent may disable or skip them. [REPO]

## 6. Prohibited actions
6.1 Pasting credentials into a prompt, a file or an agent configuration. [HOOK]
6.2 Running an agent with approvals and sandbox fully bypassed, outside a disposable,
    network-restricted sandbox. [MANAGED]
6.3 Letting an agent force-push, rewrite shared history or push to protected
    branches. [MANAGED] [REPO]
6.4 Letting an agent deploy to production, run migrations against production or
    change production secrets without the human gate in the governance policy. [REPO]
6.5 Adding hooks, MCP servers or plugins to a repository to widen what an agent may do
    without platform-team review. [MANAGED]
6.6 Using agent output to make decisions about people (hiring, performance). [TRUST]

## 7. Exceptions and review
7.1 Exceptions are requested by ticket, name the clause, the scope and an end date, and
    are approved by the platform owner and security. [DETECT]
7.2 This policy is reviewed quarterly and after every AI-related incident; each change
    names the clause, the reason and the enforcement change. [TRUST]
```

Szablon ma 28 punktów: 17 egzekwują ustawienia zarządzane, hooki lub reguły repozytorium (6.3 oba mechanizmy; 4.1 jest też wykrywany w CI), 3 są tylko wykrywane, a 8 opiera się na zaufaniu.

## Które punkty wyegzekwują Claude Code, Codex i Cursor?

Mapa egzekwowania to dokument roboczy zespołu platformowego: każdy wiersz nazywa ustawienie lub regułę, dzięki której punkt obowiązuje. Kolumna Cursora jest uboższa, bo jego ustawień administracyjnych nie dało się ponownie zweryfikować 2026-09-26; traktuj punkt w Cursorze jako `[REPO]` plus `[TRUST]`, dopóki administrator Cursora nie potwierdzi kontroli.

| Punkt | Claude Code (ustawienia zarządzane) | Codex (`requirements.toml`) | Cursor | Repozytorium |
| --- | --- | --- | --- | --- |
| 2.2 Poufne tylko na ścieżkach bez trenowania | Logowanie do organizacji firmowej (3.1) plus warunki przechowywania danych w tym planie | Logowanie do firmowego workspace'u (3.1) plus jego warunki | Ustawienia prywatności: potwierdź w panelu | — |
| 2.3 Poświadczenia poza promptami | Hook `UserPromptSubmit` kończący się kodem 2 | `[hooks]` `UserPromptSubmit` w `requirements.toml` | Hooki (JSON przez stdio) | Skanowanie sekretów z push protection |
| 2.5 Zakaz czytania plików z sekretami | `permissions.deny` plus `sandbox.filesystem.denyRead` | `[permissions.filesystem]` `deny_read` (ścieżki bezwzględne lub globy) | Potwierdź w ustawieniach bezpieczeństwa agenta | — |
| 3.1 Tylko organizacja firmowa | `forceLoginMethod`, `forceLoginOrgUUID` | `allowed_login_methods`, `allowed_chatgpt_workspaces` | SSO w planie zespołowym: potwierdź | — |
| 3.2 Zatwierdzone modele | `availableModels`, `enforceAvailableModels`; `deniedModels` wymaga v2.1.283 (oba kanały wydań na 2026-10-12) | Brak klucza listy dozwolonych modeli w `requirements.toml` (sprawdzone w 0.157.1); `model_provider` przypina dostawcę, a `[models.new_thread]` ustawia tylko wartości domyślne | Kontrola modeli: potwierdź | — |
| 3.3 Lista dozwolonych MCP, pluginów i marketplace'ów | `allowedMcpServers` + `allowManagedMcpServersOnly`, `strictKnownMarketplaces` | `[mcp_servers.<name>.identity]`, `plugins`, `marketplaces` | Potwierdź w panelu administracyjnym | — |
| 4.1 Trailer atrybucji | `attribution` w ustawieniach zarządzanych | Wbudowana instrukcja dodania `Co-authored-by: Codex <noreply@openai.com>`, włączana ustawieniem konta użytkownika | — | Wykrywanie trailera w CI |
| 4.2, 5.1, 5.3, 5.4, 6.4 | — | — | — | Rulesety, CODEOWNERS, wymagane kontrole, zatwierdzenia środowisk |
| 6.2 Zakaz pełnego obejścia | `permissions.disableBypassPermissionsMode: "disable"` | `allowed_sandbox_modes` bez `danger-full-access`; `allowed_approval_policies` | Potwierdź kontrolę trybów uruchamiania | — |
| 6.3 Zakaz force-push | `permissions.deny` dla `Bash(git push --force *)` | `[rules]` `prefix_rules` z `decision = "forbidden"` | Hooki | Rulesety gałęzi blokują force-push |
| 6.5 Zakaz hooków dodanych w repozytorium | `allowManagedHooksOnly`, `allowManagedPermissionRulesOnly` | `allow_managed_hooks_only = true` | — | CODEOWNERS dla `.claude/`, `.codex/`, `.cursor/` |

Kolumna repozytorium ocenia zmianę, a nie narzędzie, więc obejmuje każdego agenta, także nieautoryzowane narzędzia; dlatego trafiły tam punkty od 5.1 do 5.4 oraz 6.4. Oba narzędzia dodają atrybucję, instruując model, a nie przepisując commit. Codex bierze przełącznik z ustawień konta użytkownika (`commit_attribution_enabled` w `openai/codex` na tagu `rust-v0.157.1`, sprawdzone 2026-09-26), a `requirements.toml` nie ma na to klucza, więc w Codex punkt 4.1 jest tylko wykrywany. Człowiek może poprawić każdy commit, więc dowodem dla obu narzędzi jest kontrola trailera w CI.

## Jak wyegzekwować punkty o danych i ścieżkach dostępu?

Rozsyłaj te pliki przez zarządzanie urządzeniami, a nie przez repozytorium (zobacz pierwszą awarię opisaną niżej).

**Claude Code**

Claude Code czyta ustawienia zarządzane z `/Library/Application Support/ClaudeCode/managed-settings.json` na macOS, `/etc/claude-code/managed-settings.json` na Linuksie i WSL oraz z `C:\Program Files\ClaudeCode\managed-settings.json` na Windowsie, albo z ustawień zarządzanych po stronie serwera w konsoli administracyjnej claude.ai w planach Team i Enterprise. Ustawienia zarządzane mają pierwszeństwo przed argumentami wiersza poleceń oraz ustawieniami projektu i użytkownika.

```json
{
  "forceLoginMethod": "claudeai",
  "forceLoginOrgUUID": "ORG_UUID",
  "availableModels": ["opus", "sonnet"],
  "enforceAvailableModels": true,
  "permissions": {
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(~/.aws/**)",
      "Read(~/.ssh/**)",
      "Bash(git push --force *)",
      "Bash(git push -f *)"
    ],
    "disableBypassPermissionsMode": "disable"
  },
  "allowManagedPermissionRulesOnly": true,
  "sandbox": {
    "enabled": true,
    "filesystem": { "denyRead": ["~/.aws/credentials", "~/.ssh"] }
  },
  "allowedMcpServers": [
    { "serverUrl": "https://api.githubcopilot.com/mcp/*" },
    { "serverUrl": "https://mcp.internal.example.com/*" }
  ],
  "allowManagedMcpServersOnly": true,
  "strictKnownMarketplaces": [
    { "source": "github", "repo": "anthropics/claude-plugins-official" },
    { "source": "github", "repo": "acme-corp/approved-plugins" }
  ],
  "allowManagedHooksOnly": true,
  "attribution": {
    "commit": "Co-Authored-By: Claude <noreply@anthropic.com>\nAI-Policy: v1.0"
  },
  "companyAnnouncements": [
    "AI usage policy v1.0 applies: handbook/ai-usage-policy. Restricted data never goes in a prompt."
  ]
}
```

`ORG_UUID` to identyfikator twojej organizacji w Anthropic. Reguły deny dla `Read` obejmują narzędzia plikowe Claude'a i polecenia plikowe, które Claude Code rozpoznaje w Bashu, na przykład `cat` i `sed`. Przy włączonym sandboxie Claude Code kopiuje każdą ścieżkę z reguł `Read(...)` do listy `denyRead` sandboxa, którą system operacyjny egzekwuje dla każdego polecenia w sandboxie; jawne wpisy `denyRead` dokładają pliki poświadczeń w katalogu domowym, które domyślna polityka odczytu sandboxa zostawiłaby dostępne. Wpisz marketplace'y, które faktycznie zatwierdzasz: pusta tablica `strictKnownMarketplaces` blokuje każde źródło, łącznie z oficjalnym marketplace'em Anthropic.

**Codex**

Codex czyta ograniczenia administracyjne z `/etc/codex/requirements.toml` na macOS i Linuksie oraz z `%ProgramData%\OpenAI\Codex\requirements.toml` na Windowsie (ścieżki ze źródeł `openai/codex`, sprawdzone 2026-09-26). Wartości domyślne trzymaj w `config.toml`, a ograniczenia w `requirements.toml`.

```toml
allowed_login_methods = ["chatgpt"]
allowed_chatgpt_workspaces = ["WORKSPACE_ID"]
allowed_approval_policies = ["on-request", "untrusted"]
allowed_sandbox_modes = ["read-only", "workspace-write"]
allowed_web_search_modes = ["disabled", "cached"]
allow_managed_hooks_only = true

[mcp_servers.github.identity]
url = "https://api.githubcopilot.com/mcp/"

[mcp_servers.jira.identity]
url = "https://mcp.internal.example.com/jira"

[rules]
prefix_rules = [
  { pattern = [{ token = "git" }, { token = "push" }, { any_of = ["--force", "-f"] }], decision = "forbidden", justification = "AI usage policy 6.3: no force-push" },
]
```

`WORKSPACE_ID` to identyfikator twojego workspace'u ChatGPT. Wpisy w `[mcp_servers.<name>.identity]` zamieniają tę sekcję w listę dozwolonych: serwer, którego nazwa oraz URL lub polecenie nie pasują, jest odfiltrowany. Reguła prefiksowa dopasowuje tokeny po kolei, więc `git push origin main --force` ją ominie, tak samo jak wzorzec `Bash(git push --force *)` w Claude Code. Dlatego punkt 6.3 ma też tag `[REPO]`: ruleset gałęzi blokuje force-push niezależnie od zapisu polecenia. `allowed_web_search_modes` trzyma poufny kontekst z dala od zapytań wyszukiwania na żywo (punkt 2.2); usuń ten wiersz, jeśli twoja polityka dopuszcza wyszukiwanie na żywo.

**Cursor**

Cursor dokumentuje Rules, Hooks (JSON przez stdio), Plugins i konfigurację MCP (sprawdzone 2026-08-28). Jego ustawień administracyjnych nie dało się ponownie zweryfikować 2026-09-26, więc ta strona ich nie nazywa.

- Poproś administratora Cursora, żeby potwierdził w panelu administracyjnym kontrolę dla każdego z punktów 2.2, 3.1, 3.2 i 3.3. Każdą znalezioną wpisz do mapy egzekwowania jako `[MANAGED]`.
- Wdróż to samo sprawdzanie promptów jako hook Cursora, po sprawdzeniu na stronie o hookach Cursora formatu wejścia i sposobu blokowania.

## Jak wyegzekwować zakazane działania hookiem?

Punkty 2.3 i 6.1 wymagają kontroli, która działa, zanim model zobaczy prompt. Poniższy skrypt odrzuca prompt zawierający klucz prywatny albo poświadczenie w typowym formacie; nie rozpozna danych osobowych klientów, dlatego punkt 2.4 zostaje `[TRUST]`. Zapisz go tam, gdzie deweloperzy nie mogą go edytować, i zarejestruj w ustawieniach zarządzanych.

```bash
#!/usr/bin/env bash
# /etc/claude-code/hooks/block-credentials.sh  (AI usage policy 2.3, 6.1)
command -v jq >/dev/null || { echo 'AI usage policy: jq missing, prompt blocked' >&2; exit 2; }
prompt=$(jq -r '.prompt // empty') || { echo 'AI usage policy: unreadable hook input, prompt blocked' >&2; exit 2; }
if printf '%s' "$prompt" | grep -Eq -- '-----BEGIN [A-Z ]*PRIVATE KEY-----|AKIA[0-9A-Z]{16}|gh[pousr]_[A-Za-z0-9]{36}|sk-ant-[A-Za-z0-9_-]{20,}'; then
  echo "Blocked by AI usage policy 2.3/6.1: the prompt contains a credential. Remove it and reference the secret by name." >&2
  exit 2
fi
exit 0
```

```json
{
  "hooks": {
    "UserPromptSubmit": [
      { "hooks": [{ "type": "command", "command": "/etc/claude-code/hooks/block-credentials.sh" }] }
    ]
  }
}
```

W Claude Code kod wyjścia 2 z hooka `UserPromptSubmit` odrzuca prompt i pokazuje komunikat; kod 1 to błąd nieblokujący, który przepuszcza prompt. Przy ustawionym `allowManagedHooksOnly` działają tylko hooki zarządzane i hooki z pluginów włączonych przez politykę. Dwa warunki z `jq` sprawiają, że hook blokuje prompt, gdy brakuje `jq` albo wejścia nie da się sparsować.

Codex ma to samo zdarzenie `UserPromptSubmit` wśród swoich 12 zdarzeń hooków. Zarejestruj skrypt w tabeli `[hooks]` pliku `requirements.toml` (struktura z `hook_config.rs` i `config_requirements.rs` w `openai/codex` na tagu `rust-v0.157.1`, sprawdzone 2026-09-26):

```toml
[hooks]
managed_dir = "/etc/codex/hooks"
windows_managed_dir = 'C:\ProgramData\OpenAI\Codex\hooks'

[[hooks.UserPromptSubmit]]

[[hooks.UserPromptSubmit.hooks]]
type = "command"
command = "/etc/codex/hooks/block-credentials.sh"
timeout = 10
```

Warstwa użytkownika ani projektu nie podmieni tych hooków zarządzanych. Kod źródłowy nie przesądza, czy Codex odczytuje kod wyjścia 2 tak jak Claude Code, więc potwierdź blokadę w `/hooks` i promptem testowym. Lista wzorców to minimum: połącz ją z regułami swojego skanera sekretów.

## Jak wyegzekwować ujawnianie i recenzję w repozytorium?

Punkty 4.2 oraz od 5.1 do 5.4 opierają się na trzech kontrolach:

1. **Ruleset na gałęzi domyślnej**, który wymaga pull requesta, jednej zatwierdzającej recenzji, zielonych wymaganych kontroli i blokuje force-push. Liczą się tylko zatwierdzenia kont z prawem zapisu, więc nie dawaj go tożsamościom agentów.
2. **CODEOWNERS** dla ścieżek należących do bezpieczeństwa i katalogów konfiguracji agentów (`.claude/`, `.codex/`, `.cursor/`, `.mcp.json`), żeby poszerzenie uprawnień agenta wymagało zespołu platformowego. Dodaj też `/.github/`: przy wyzwalaczu `pull_request` GitHub uruchamia plik workflow z samego PR, więc bez wymaganej recenzji CODEOWNERS autor może w tym samym PR zmienić albo usunąć poniższą kontrolę deklaracji.
3. **Wymagana kontrola ujawniania**, poniżej, na każdym pull requeście.

```yaml
name: ai-disclosure
on:
  pull_request:
    types: [opened, edited, synchronize]
permissions:
  contents: read
jobs:
  disclosure:
    runs-on: ubuntu-latest
    steps:
      - name: Require an AI assistance declaration (policy 4.2)
        env:
          PR_BODY: ${{ github.event.pull_request.body }}
        run: |
          if ! printf '%s' "$PR_BODY" | grep -Eq '^AI assistance: (none|assisted|agent-authored)[[:space:]]*$'; then
            echo "::error::Add 'AI assistance: none|assisted|agent-authored' to the PR description (AI usage policy 4.2)."
            exit 1
          fi
```

Workflow przekazuje niezaufaną treść PR przez `env:`, zamiast wstawiać ją do skryptu. Dowodzi, że deklaracja istnieje, a nie że jest prawdziwa: dodaj drugi krok, który oznacza PR, gdy jego commity mają trailer `Co-Authored-By: Claude` albo `Co-authored-by: Codex`, a opis mówi `none`. [Klucz odpowiedzi o pochodzeniu zmian](/pl/cto-scorecard-guide/ai-pr-labeling/) pokazuje, jak zamienić zadeklarowany poziom na głębokość recenzji.

## Jak sprawić, żeby punkty zaufania dało się sprawdzić?

Osiem punktów zostaje `[TRUST]`. Dla każdego nazwij kontrolę i właściciela, żeby „zaufanie” znaczyło „zaufanie i próbkowanie”, a nie „nikt tego nie ogląda”:

| Punkt | Kontrola | Właściciel | Częstotliwość |
| --- | --- | --- | --- |
| 1.1, 3.4 Zakres i czat w przeglądarce | Coroczne oświadczenie plus rejestr szkoleń z kompetencji AI | Kierownicy zespołów inżynierskich | Co rok, przy onboardingu |
| 2.4 Brak danych osobowych, płatniczych i medycznych | Próbka 10 zapisów sesji agenta oraz danych testowych i logów, których dotykały; szukaj prawdziwych danych klientów | Inspektor ochrony danych | Co kwartał |
| 2.6 Zanonimizowane dane produkcyjne | Próbka 10 plików z danymi testowymi dodanych w PR-ach agenta; szukaj prawdziwych identyfikatorów | Inspektor ochrony danych | Co kwartał |
| 4.3 Ujawnianie klientowi | Checklista umowy na starcie każdego projektu dla klienta | Kierownik realizacji projektu | Przy każdym projekcie |
| 5.2 Zatwierdzanie na podstawie dowodów | Próbka 20 scalonych PR-ów agenta; czy zatwierdzający potrafi wskazać dowody? | Tech leadzi | Co miesiąc |
| 6.6 Brak decyzji o ludziach | Przegląd procesów HR | HR i CTO | Co rok |
| 7.2 Przegląd polityki | Dziennik zmian z punktem, powodem i zmianą egzekwowania | CTO | Co kwartał |

Rejestr szkoleń z kompetencji AI może też posłużyć jako dowód działań na rzecz kompetencji personelu w zakresie AI, których art. 4 AI Act nadal wymaga (według podsumowania Gibson Dunn, sprawdzonego 2026-09-26, Digital Omnibus złagodził ten obowiązek, ale go nie usunął); zobacz [AI Act dla firm tworzących oprogramowanie z agentami](/pl/org/eu-ai-act/).

Trzy punkty `[DETECT]` również potrzebują nazwanego źródła i właściciela:

| Punkt | Źródło wykrywania | Właściciel | Częstotliwość |
| --- | --- | --- | --- |
| 1.2 Agenci bez nadzoru w rejestrze | Rejestr tożsamości agentów uzgadniany z kontami usługowymi CI i tokenami botów | Zespół platformowy | Co miesiąc |
| 3.5 Brak narzędzi spoza rejestru | Inwentarz oprogramowania z systemu zarządzania urządzeniami plus pokrycie zdarzeniem `claude_code.managed_settings_resolved` | IT i bezpieczeństwo | Co miesiąc |
| 7.1 Wyjątki wygasają | Zgłoszenia wyjątków po dacie końcowej | Bezpieczeństwo | Co tydzień |

## Jak sprawdzić, czy polityka naprawdę obowiązuje?

Punkt oznaczony `[MANAGED]`, który nie został wdrożony, jest gorszy niż punkt `[TRUST]`, bo wszyscy wierzą, że działa. Przeprowadzaj tę procedurę przy wdrożeniu i co kwartał.

1. **Potwierdź źródło zarządzane na próbce maszyn.** W Claude Code `/status` pokazuje `Enterprise managed settings` w wierszu `Setting sources`, a `claude doctor` wypisuje wpisy odrzucone jako nieprawidłowe. W Codex `/debug-config` pokazuje warstwy konfiguracji i źródła wymagań.
2. **Przećwicz każdy egzekwowany punkt** w jednorazowym testowym repozytorium bez prawdziwych sekretów, na jednorazowej maszynie albo w kontenerze z ograniczoną siecią (jeśli flaga obejścia nie zostanie odrzucona, sesja ruszy bez zabezpieczeń): najpierw potwierdź, że `claude --dangerously-skip-permissions`, `codex -s danger-full-access` i `codex --dangerously-bypass-approvals-and-sandbox` są odrzucane (6.2), a potem, w zwykłej sesji, wklej fałszywy klucz pasujący do wzorca hooka, dodaj serwer MCP spoza listy i wykonaj force-push z poziomu agenta. Każda próba musi się nie udać z komunikatem, który cytuje punkt polityki.
3. **Sprawdź kontrole repozytorium testowym PR-em.** Otwórz PR bez linii ujawniania i drugi, który zmienia `.claude/settings.json`. Pierwszy musi oblać wymaganą kontrolę, drugi musi wymagać recenzji zespołu platformowego.
4. **Obserwuj sygnały wykrywania.** Przy eksporcie OpenTelemetry z Claude Code (`CLAUDE_CODE_ENABLE_TELEMETRY=1` i endpoint OTLP ustawiony w ustawieniach zarządzanych) zdarzenie `claude_code.managed_settings_resolved` pokazuje, które źródło zarządzane wczytała każda sesja, a `claude_code.hook_execution_complete` liczy decyzje blokujące (`num_blocking`) dla każdego hooka. Pokrycie poniżej 100% oznacza maszyny poza wdrożeniem, a rosnąca liczba blokad jednego punktu oznacza, że blokuje on prawdziwą pracę (zobacz niżej). [Przewodnik po obserwowalności agentów](/pl/workflows/operate/agent-observability/) opisuje cały potok.
5. **Zapisz wyniki.** Przechowuj dziennik ćwiczeń razem z wersją polityki: to dowód dla audytora i wejście do kwartalnego przeglądu (punkt 7.2).

Zatwierdzenie: właściciel platformy podpisuje dziennik ćwiczeń, bezpieczeństwo kontrasygnuje mapę egzekwowania, a CTO zatwierdza każdą wersję polityki. [Model operacyjny](/pl/org/operating-model/) umieszcza te role w swojej macierzy RACI.

## Prompty do dopasowania polityki i jej audytu

Uruchom oba prompty w Claude Code lub Codex w katalogu głównym repozytorium z podręcznikiem.

**Prompt do skopiowania: dopasuj politykę do organizacji**

```text
Read handbook/ai-usage-policy.md (our draft, based on a 28-clause template) and every
file under .claude/, .codex/, .cursor/ and .github/ in this repository.
1. For each clause, report its tag ([MANAGED], [HOOK], [REPO], [DETECT], [TRUST]) and
   whether a file here actually implements it. Quote the file path and key.
2. List clauses tagged [MANAGED] or [REPO] that nothing in this repository or in the
   managed settings we keep under platform/managed/ implements.
3. Propose the smallest change that moves each [TRUST] clause to [DETECT] or better.
Do not edit any file. Output a table: clause | tag | implemented by | gap | proposed fix.
```

**Prompt do skopiowania: kwartalne ćwiczenie egzekwowania**

```text
We are drilling AI usage policy v1.0 in this scratch repository. For each clause below,
attempt the forbidden action exactly once and record what happened, verbatim:
- 6.3: run git push --force origin HEAD:drill-branch.
- 2.5: read the file .env in this directory.
Stop after each attempt. Do not retry, work around a block, or change any setting.
Finish with a table: clause | attempted action | blocked (yes/no) | message shown.
```

Punkt 6.1 ćwicz osobno, bo hook odrzuciłby wspólny prompt już przy wysłaniu: wyślij jednowierszowy prompt zawierający AKIAABCDEFGHIJKLMNOP i oczekuj komunikatu 2.3/6.1. Punkt 6.2 ćwicz z powłoki, jak w kroku 2 procedury weryfikacji.

„No” w kolumnie blokady to ustalenie audytowe, a nie błąd agenta.

## Dlaczego polityki korzystania z AI zawodzą w praktyce?

**Polityka zapisana w ustawieniach projektu.** `.claude/settings.json` albo `.codex/config.toml` w repozytorium można zmienić na dowolnej gałęzi. Naprawa: przenieś każdy klucz egzekwujący do ustawień zarządzanych albo `requirements.toml`, pliki projektu zostaw na wartości domyślne i ustaw CODEOWNERS na katalogach agentów.

**Przypinanie logowania złym kluczem.** W Claude Code `forceLoginMethod` wstępnie wybiera metodę na interaktywnym ekranie `/login`, ale jej tam nie wymusza; logowanie do claude.ai ogranicza do twojej organizacji dopiero `forceLoginOrgUUID` ze źródła zarządzanego. Naprawa: ustaw oba klucze i przetestuj logowanie kontem prywatnym.

**Reguły deny, które wyglądają na kompletne.** Reguły deny dla `Read` nie obejmują poleceń, które czytają pliki bez podawania nazw, jak `grep -r`, ani dowolnych podprocesów. Naprawa: włącz sandbox z `sandbox.filesystem.denyRead` i trzymaj sekrety poza przestrzenią roboczą, zgodnie z [tożsamością agentów, poświadczeniami i sekretami](/pl/org/agent-identity-and-secrets/).

**Plik zarządzany, który blokuje start lub wyłącza funkcję.** Claude Code odmawia uruchomienia, gdy plik ustawień zarządzanych nie jest poprawnym JSON-em, `allowManagedHooksOnly` uniemożliwia działanie `/goal`, bo ta komenda opiera się na hookach, `allowManagedPermissionRulesOnly` ignoruje każdą regułę allow użytkownika i projektu, a `sandbox.enabled` wymaga bubblewrap na Linuksie i WSL2 i nie działa na natywnym Windowsie. Naprawa: waliduj plik w CI, wpisz wspólne reguły allow do ustawień zarządzanych, potraktuj osobno natywny Windows i zacznij od pilotażu.

**Hook, który zawodzi w stronę przepuszczenia.** Bez tych warunków brakująca zależność albo wejście, którego nie da się sparsować, daje pusty prompt i kod 0, więc przechodzi wszystko, choć punkt nadal ma znacznik `[HOOK]`. Naprawa: niech hook zawodzi w stronę blokady, jak robią to warunki z `jq` powyżej, i włącz go do ćwiczenia.

**Klucze Codex w złym pliku albo w złym systemie.** `allow_managed_hooks_only` w `config.toml` nic nie robi, a wpis `[rules]` z `decision = "allow"` nie przechodzi parsowania. Jeśli używasz już profili uprawnień (beta), `allowed_sandbox_modes` to zły klucz: użyj `allowed_permission_profiles`, bo według OpenAI profile i starszy system sandboxa się nie łączą. Naprawa: trzymaj `requirements.toml` z lintem w repozytorium platformy i po każdej zmianie sprawdzaj `/debug-config` na próbce maszyn.

**Runnery CI objęte plikiem dla deweloperów.** Pominięcie `never` w `allowed_approval_policies` blokuje też `codex -a never` na każdej maszynie z tym plikiem, także na runnerze CI. Naprawa: wyłącz runnery z wdrożenia na urządzenia i daj im osobny `requirements.toml`.

**Polityka blokuje pracę.** Inżynierowie obchodzą zatwierdzoną ścieżkę, która jest wolniejsza niż zakazana. Obserwuj kolejkę wyjątków (punkt 7.1) i liczbę blokad hooków; punkt, który co tydzień generuje wyjątki, potrzebuje lepszej zatwierdzonej ścieżki, a nie surowszego okólnika.

**Nieautoryzowane narzędzia (shadow AI), których mapa nie objęła.** Nowy agent w IDE albo rozszerzenie przeglądarki nie mają żadnych twoich ustawień zarządzanych. Dodaj narzędzie do rejestru albo zablokuj je na poziomie urządzeń, zgodnie z [kluczem odpowiedzi o polityce narzędzi](/pl/cto-scorecard-guide/tooling-policy/).

Każde naruszenie polityki, które dotrze na produkcję, traktuj jak incydent: unieważnij tożsamość, a potem napraw kontrolę, która zawiodła; zobacz [gdy incydent wywoła agent](/pl/org/agent-incidents/).

## Co dalej z polityką korzystania z AI

- [Jedna polityka dla wszystkich agentów kodujących](/pl/org/managed-policy/) opisuje dystrybucję, wersjonowanie i audyt tych plików u różnych dostawców, łącznie z GitHub Copilot.
- [Zarządzanie i autonomia: ludzie przy bramkach](/pl/org/governance-autonomy/) definiuje bramkę produkcyjną, do której odsyła punkt 6.4.
- [Model zagrożeń dla agentów](/pl/org/agent-threat-model/) wyjaśnia, które ataki zamykają punkty 2.3, 3.3 i 6.5.
- [Gdzie działa model](/pl/org/model-hosting/) rozstrzyga pytania o przechowywanie danych i ich lokalizację, na których opiera się punkt 2.2.
- [Prawo i własność intelektualna a kod pisany przez agentów](/pl/org/legal-and-ip/) omawia ujawnianie wobec klientów i własność kodu (punkt 4.3).
- [Zarządzanie wspólnymi hookami](/pl/cto-scorecard-guide/shared-hooks-governance/) pokazuje, jak recenzować, testować i wersjonować hooki, na których opierają się punkty 2.3 i 6.1.
