Przepływy automatyzacji: potoki rozwoju oparte na AI

Headless agent Cursora, agent -p, działa nieinteraktywnie i wpina się w git hooki, CI oraz zadania cykliczne zamiast tylko w edytor. Tryb print domyślnie proponuje zmiany, a zapisuje je dopiero z --force. Te same wzorce — przegląd pre-commit, przegląd PR w CI, cykliczne podbijanie zależności — działają też w Claude Code i Codex z terminala, różniąc się tylko flagami.

Twoje nocne zadanie podbijające zależności świeci na czerwono od trzech dni, bot „przeglądu kodu AI”, który zespół doczepił na siłę, wypisuje ogólnikowe pochwały pod każdym PR, a jedyna osoba rozumiejąca skrypt wydania właśnie poszła na urlop. Interaktywne kodowanie z AI jest świetne wewnątrz edytora — ale w momencie, gdy próbujesz to oskryptować, trafiasz na ścianę zmyślonych flag CLI i kruchego kodu sklejającego.

Cursor dostarcza prawdziwego bezgłowego agenta (agent -p) zbudowanego dokładnie do tego. Ten przewodnik pokazuje, jak wpiąć go w haki git, CI/CD i zadania cykliczne — z uruchamialnymi skryptami, a nie pseudokodem — oraz gdzie Claude Code i Codex robią to samo z poziomu terminala.

Co daje ten przewodnik po automatyzacji

Hak pre-commit, który uruchamia prawdziwy przegląd AI na zmianach w staging i blokuje commit przy znalezieniu problemów
Zadanie GitHub Actions publikujące ustrukturyzowany przegląd PR za pomocą agent -p --output-format json
Skrypt zaplanowanej konserwacji, który proponuje podbicia zależności i otwiera PR
Te same trzy przepływy pokazane dla Cursor, Claude Code i Codex, żebyś mógł wybrać per repozytorium
Checklistę „Gdy bezgłowa automatyzacja zawodzi” dla rozbieganych agentów, limitów kosztów i awarii uwierzytelniania MCP

Bezgłowy agent w 60 sekund

Wszystko poniżej opiera się na jednej komendzie. -p (tryb print) działa nieinteraktywnie; bez --force agent jedynie proponuje edycje, z --force je zapisuje:

# Zadaj pytanie, wypisz odpowiedź, zakończ (bez zmian w plikach)
agent -p "What does this codebase do?"

# Zastosuj zmiany bezpośrednio (skrypty/CI)
agent -p --force "Refactor src/auth/token.ts to use the jose library"

# Ustrukturyzowane wyjście do parsowania
agent -p --output-format json --model gpt-5.6-sol \
  "List the 3 riskiest changes in the current diff as a JSON array"

--output-format przyjmuje text (domyślnie), json i stream-json. W CI ustaw zmienną środowiskową CURSOR_API_KEY zamiast logować się interaktywnie.

Kontrole AI przed commitem

Blokuj commity, gdy zmiany w staging mają oczywiste problemy. Hak przekazuje diff ze staging do agenta i kończy się błędem przy niezerowym kodzie wyjścia. Przepływy różnią się między narzędziami, więc oto wszystkie trzy:

#!/usr/bin/env bash
# .git/hooks/pre-commit  (chmod +x)
set -euo pipefail

DIFF=$(git diff --cached --diff-filter=ACMR -U3)
[ -z "$DIFF" ] && exit 0

echo "Running Cursor pre-commit review..."
RESULT=$(printf '%s' "$DIFF" | agent -p --output-format text \
  "Review this staged diff for bugs, missing error handling, and leaked secrets.
   Reply with exactly 'PASS' on the first line if it is safe to commit,
   otherwise 'FAIL' followed by a bulleted list of blocking issues.")

echo "$RESULT"
echo "$RESULT" | head -1 | grep -q '^PASS' || { echo "Commit blocked."; exit 1; }

#!/usr/bin/env bash
# .git/hooks/pre-commit  (chmod +x)
set -euo pipefail

DIFF=$(git diff --cached --diff-filter=ACMR -U3)
[ -z "$DIFF" ] && exit 0

echo "Running Claude Code pre-commit review..."
RESULT=$(printf '%s' "$DIFF" | claude -p --max-turns 2 \
  "Review this staged diff for bugs, missing error handling, and leaked secrets.
   Reply 'PASS' on line 1 if safe to commit, else 'FAIL' and a bulleted list.")

echo "$RESULT"
echo "$RESULT" | head -1 | grep -q '^PASS' || { echo "Commit blocked."; exit 1; }

#!/usr/bin/env bash
# .git/hooks/pre-commit  (chmod +x)
set -euo pipefail

DIFF=$(git diff --cached --diff-filter=ACMR -U3)
[ -z "$DIFF" ] && exit 0

echo "Running Codex pre-commit review..."
RESULT=$(printf '%s' "$DIFF" | codex exec --sandbox read-only \
  "Review this staged diff for bugs, missing error handling, and leaked secrets.
   Reply 'PASS' on line 1 if safe to commit, else 'FAIL' and a bulleted list.")

echo "$RESULT"
echo "$RESULT" | head -1 | grep -q '^PASS' || { echo "Commit blocked."; exit 1; }

Użyj promptu, który wymusza werdykt nadający się do maszynowego parsowania, żeby hak mógł się na nim rozgałęzić:

You are a strict pre-commit reviewer. Review ONLY the staged diff below.
Flag: real bugs, missing error handling on I/O and network calls, hardcoded
secrets or tokens, and obvious security issues (SQLi, command injection, path
traversal). Ignore style nits and naming.

Output line 1 = exactly "PASS" or "FAIL".
If FAIL, lines 2+ = one bullet per blocking issue as "file:line — problem — fix".
Do not explain anything else.

Automatyczny przegląd kodu w CI

Uruchom agenta na pull requestach i opublikuj wynik jako komentarz. Sprawdzony wzorzec to ograniczona autonomia: pozwól agentowi modyfikować wyłącznie katalog roboczy lub emitować tekst, a operacje git/PR pozostaw deterministycznymi krokami CI. Ten przepływ GitHub Actions przypina akcje zewnętrzne do bieżących wersji major i instaluje CLI Cursor bezpośrednio:

name: AI Code Review

on:
  pull_request:
    types: [opened, synchronize]

permissions:
  contents: read
  pull-requests: write

jobs:
  ai-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Install Cursor CLI
        run: |
          curl https://cursor.com/install -fsS | bash
          echo "$HOME/.cursor/bin" >> "$GITHUB_PATH"

      - name: Generate review
        env:
          CURSOR_API_KEY: ${{ secrets.CURSOR_API_KEY }}
        run: |
          git diff "origin/${{ github.base_ref }}...HEAD" > pr.diff
          agent -p --output-format text --model gpt-5.6-sol \
            "Review the diff in @pr.diff. Focus on correctness, security, and
             missing tests. Write concise, file-scoped feedback to review.md.
             Do not modify any source files."

      - name: Post review comment
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: gh pr comment "${{ github.event.pull_request.number }}" --body-file review.md

To samo zadanie w pozostałych dwóch narzędziach:

agent -p --output-format text --model gpt-5.6-sol \
  "Review the diff in @pr.diff for correctness, security, and missing tests.
   Write file-scoped feedback to review.md. Do not modify source files."

cat pr.diff | claude -p --output-format json --max-turns 3 \
  --allowedTools "Read,Grep" \
  "Review this diff for correctness, security, and missing tests.
   Return JSON: { verdict, comments: [{ path, line, severity, message }] }"

codex exec --sandbox read-only \
  "Review the diff in pr.diff for correctness, security, and missing tests.
   Write file-scoped feedback to review.md. Do not modify source files."

Prompt recenzenta, który zarabia na swoje miejsce (a nie sypie ogólnikami):

Review this pull request diff as a senior engineer who will be on call for it.
For each issue, output: severity (blocker | warning | nit), the file:line, what
breaks, and the minimal fix. Specifically check:
- error paths and timeouts on every network/DB/file call
- input validation and authz on new endpoints
- N+1 queries, unbounded loops, and missing pagination
- tests: does every new branch have coverage? name the untested branches
Skip anything that is purely stylistic. If the diff is safe, say so in one line.

Zaplanowana konserwacja

Cotygodniowe zadanie, które proponuje podbicia zależności, uruchamia zestaw testów i otwiera PR. Trzymaj krok AI ograniczony do edycji plików, a rozgałęzianie i tworzenie PR pozostaw CI:

name: Weekly Maintenance

on:
  schedule:
    - cron: '0 2 * * 0' # Niedziele, 02:00 UTC

permissions:
  contents: write
  pull-requests: write

jobs:
  maintenance:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install Cursor CLI
        run: |
          curl https://cursor.com/install -fsS | bash
          echo "$HOME/.cursor/bin" >> "$GITHUB_PATH"

      - name: Propose safe dependency bumps
        env:
          CURSOR_API_KEY: ${{ secrets.CURSOR_API_KEY }}
        run: |
          agent -p --force --model gpt-5.6-sol \
            "Bump dependencies in package.json to the latest non-breaking (caret)
             versions. Update the lockfile with 'npm install'. Do NOT bump across
             major versions. Do NOT touch source files. Summarize changes to
             CHANGES.md."

      - name: Verify
        run: npm ci && npm test

      - name: Open PR
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          git checkout -B chore/weekly-deps
          git add -A && git commit -m "chore: weekly dependency bumps"
          git push -f origin chore/weekly-deps
          gh pr create --fill --title "chore: weekly dependency bumps" || true

W przypadku Claude Code zamień krok agenta na claude -p --max-budget-usd 2.00 --dangerously-skip-permissions "...", żeby run zatrzymał się sam, gdy zacznie być kosztowny. Dla Codex w zaufanym CI bez nadzoru użyj codex exec --sandbox workspace-write -c approval_policy=never "..." wyłącznie w izolowanym checkoutcie; nie udostępniaj mu kodu z niezaufanego PR i wymagaj timeoutu oraz przeglądu diffu i testów. Rusztowanie CI wokół kroku AI jest identyczne we wszystkich trzech narzędziach.

Wyraźnie ogranicz promień rażenia, żeby bot nigdy nie wypuścił bez nadzoru aktualizacji major:

Update only the dependencies in package.json that have newer patch or minor
releases. Apply caret-compatible versions, regenerate the lockfile, and run the
test suite. If any update fails the build, revert that single package and note
it. Do NOT cross a major version boundary for any package. Do NOT edit
application source code. Write a one-line-per-package summary to CHANGES.md.

Równoległe agenty w Cursor 3.x

Cursor 3.0 przedefiniował IDE jako środowisko uruchomieniowe agentów, a 3.2–3.3 wprowadziły trzy komendy ze slashem, które orkiestrują pracę równoległą bez opuszczania pola czatu. Każda pasuje do innego kształtu zadania.

`/worktree` — Izolowane edycje, jedno zadanie

Uruchom izolowany git worktree dla zmian agenta. Używaj, gdy zadanie może wyprodukować edycje, które chcesz odizolować od bieżącej gałęzi — eksperymentalne refaktoryzacje, ryzykowne migracje, cokolwiek możesz porzucić.

/worktree refactor src/auth to use the new JWT library

Cursor tworzy worktree, przełącza do niego agenta i wystawia śledzoną lokalizację, którą na końcu możesz zmergować lub odrzucić.

`/best-of-n` — To samo zadanie, wiele modeli

Uruchom to samo zadanie równolegle na wielu modelach (Composer 2.5, Opus 5, Fable 5, GPT-5.6 Sol), każdy we własnym worktree, a potem porównaj wyniki. Przydatne, gdy nie ufasz żadnemu pojedynczemu modelowi w czystym rozstrzygnięciu — kod wrażliwy na bezpieczeństwo, niejednoznaczne specyfikacje, zadania na jeden strzał, które wolisz zrobić dobrze za pierwszym razem. W zadaniach wymagających najwyższej inteligencji Fable 5 to najmocniejsza opcja dostępna w selektorze modeli Cursor; pełne zestawienie znajdziesz w porównaniu modeli.

/best-of-n 3 implement the rate-limit middleware described in docs/rate-limit-rfc.md

Wybierasz liczbę uruchomień (n); Cursor zwraca diffy obok siebie, uszeregowane według liczby zaliczonych testów, czystości lint i szybkiego porównania semantycznego.

`/multitask` — Jedno zadanie, wiele subagentów

Cursor dzieli zadanie na kawałki i każdy dispatchuje do asynchronicznego subagenta równolegle. Najlepsze do zadań, które naturalnie się dekomponują — refaktoryzacje obejmujące wiele plików, równoległe naprawy testów, aktualizacje wielu modułów.

/multitask migrate every import of "@old-pkg/auth" to "@new-pkg/auth" and update tests

Dostępne w Cursor 3.2+; kontrolki subagentów (maksymalna głębokość, współbieżność, limit kosztów) dodano w 3.3.

Wybierz swoje narzędzie pracy równoległej

Narzędzie	Najlepsze do
`/worktree`	Jedno zadanie, edycje do odizolowania
`/best-of-n`	Porównanie strategii modeli na tym samym zadaniu
`/multitask`	Jedno zadanie naturalnie się dekomponujące — async subagenty równolegle
Background Agents	Hostowane w chmurze, długotrwałe, działa, gdy jesteś offline

Automatyzacja agentów w tle

Dla powtarzalnego środowiska chmurowego scommituj .cursor/environment.json, żeby każdy agent startował z gotowym łańcuchem narzędzi i usługami:

{
  "snapshot": "POPULATED_FROM_SETTINGS",
  "install": "npm ci",
  "start": "sudo service docker start",
  "terminals": [
    { "name": "Dev Server", "command": "npm run dev" },
    { "name": "Test Runner", "command": "npm run test:watch" }
  ]
}

Praktyczny wzorzec: odpal trzy gałęzie ze Slacka i monitoruj je na cursor.com/agents.

@Cursor [branch=feature/auth] implement OAuth 2.0 login: Passport.js with Google
and GitHub strategies, Redis-backed sessions, RBAC, and integration tests.

@Cursor [branch=feature/payments] add Stripe subscriptions: checkout endpoints,
webhook handlers, and error handling with retries.

@Cursor [branch=feature/notifications] build the email pipeline: Resend
integration, templated emails, a Bull queue, and an unsubscribe flow.

Trzymaj każde żądanie wąskie i weryfikowalne. Mgliste „@Cursor zbuduj całą platformę” spala tokeny na iteracjach względem niejasnego celu; trzy ograniczone zadania kończą się szybciej i czyściej się recenzuje.

Serwery MCP do automatyzacji

Serwery MCP dają agentowi pierwszoklasowy dostęp do twoich narzędzi dostarczania — GitHub, GitLab, Jenkins, Terraform, Kubernetes — dzięki czemu pojedynczy prompt może zorkiestrować wydanie zamiast zmuszać cię do sklejania dedykowanych klientów API. Konfiguracja mieszka w ~/.cursor/mcp.json (Cursor), .mcp.json (Claude Code) lub ~/.codex/config.toml (Codex); definicje serwerów są identyczne we wszystkich trzech narzędziach.

{
  "mcpServers": {
    "github": {
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": { "Authorization": "Bearer ${env:GITHUB_PAT}" }
    },
    "gitlab": {
      "type": "http",
      "url": "https://gitlab.com/api/v4/mcp",
      "headers": { "Authorization": "Bearer ${env:GITLAB_PAT}" }
    },
    "jenkins": {
      "command": "npx",
      "args": ["-y", "jenkins-mcp-server"],
      "env": {
        "JENKINS_URL": "https://jenkins.company.com",
        "JENKINS_USER": "your-username",
        "JENKINS_TOKEN": "your-api-token"
      }
    },
    "terraform": {
      "command": "npx",
      "args": ["-y", "terraform-mcp-server"]
    },
    "kubernetes": {
      "command": "npx",
      "args": ["-y", "kubernetes-mcp-server"],
      "env": { "KUBECONFIG": "~/.kube/config" }
    }
  }
}

Pakiety npm @modelcontextprotocol/server-github i @modelcontextprotocol/server-gitlab są przestarzałe (npm view zgłasza „no longer supported”). Oficjalny serwer GitHuba to teraz github/github-mcp-server, konsumowany jako hostowany zdalny endpoint https://api.githubcopilot.com/mcp/ (albo obraz Dockera) — nie jako pakiet npm. GitLab dostarcza oficjalny serwer MCP po HTTP pod https://<your-instance>/api/v4/mcp. Podobnie terraform-mcp nie istnieje — oficjalny serwer HashiCorp to terraform-mcp-server (czyta Terraform Registry; nie ma zmiennej środowiskowej TF_WORKSPACE, więc sprawdź jego README pod kątem zmiennych, których faktycznie używa), a kubernetes-mcp-server i jenkins-mcp-server to pakiety bez scope. Zawsze uruchamiaj npm view <package> version (albo potwierdź oficjalny endpoint), zanim wkleisz konfigurację MCP z jakiegokolwiek poradnika — nieaktualne lub zmyślone odniesienia do serwerów to najczęstszy błąd w dokumentacji generowanej przez AI.

Z podłączonymi tymi serwerami wydanie staje się jednym promptem:

Cut release v2.1.0:
- GitHub MCP: generate a changelog from commits since the last tag and create a draft release
- Jenkins MCP: trigger the build-and-test job and wait for it to go green
- Kubernetes MCP: roll out the new image and watch pod health
- If health checks fail, pause the rollout and report which pods are unhealthy

To jest „przed/po”, które kupuje ci MCP: zamiast skryptu na kilkaset linii żonglującego czterema klientami API, agent czyta na żywo stan z każdego serwera i decyduje o następnym kroku. Kompromis względem Agent Skill (lżejszego, jednozadaniowego rozszerzenia instalowanego przez npx skills add <owner/repo>) to głębia: po MCP sięgaj, gdy potrzebujesz trwałego, stanowego połączenia z narzędziem; po skill — gdy chcesz tylko nauczyć agenta jednej skoncentrowanej umiejętności.

Gdy bezgłowa automatyzacja zawodzi

Rozbiegane agenty / eksplozje kosztów. Pętla, która „nie potrafi skończyć”, będzie wydawać bez końca. Ogranicz ją: Claude Code --max-turns N i --max-budget-usd X; Codex przez jawną politykę --sandbox workspace-write -c approval_policy=never wyłącznie w zaufanym, izolowanym CI oraz timeout zadania; Cursor przez zawężenie promptu i ustawienie limitu wydatków w ustawieniach. Zawsze ustawiaj timeout-minutes na zadaniu CI i wymagaj przeglądu przez człowieka przed mergem.
agent -p zaproponował zmiany, ale nic nie zostało zapisane. Zapomniałeś --force. Bez niej tryb print jedynie proponuje edycje.
cursor: command not found w CI albo zmyślona podkomenda kończy się błędem. Binarka do automatyzacji to agent (z curl https://cursor.com/install -fsS | bash), nie cursor. Nie ma cursor lint/review/security/analyze/docs — zastąp każdą taką linię promptem agent -p.
Awarie uwierzytelniania MCP. Tokeny wygasły albo mają zły scope. Uruchom agent mcp list, żeby zobaczyć status serwerów, oraz agent mcp login <server>, żeby się ponownie uwierzytelnić; potwierdź, że zmienne środowiskowe zgadzają się z README serwera.
/worktree lub /best-of-n zostawia osierocone worktrees. Posprzątaj przez git worktree list, a następnie git worktree remove <path>. Jeśli zamiast N równoległych runów uruchomił się fallback z jednym agentem, sprawdź, czy jesteś na Cursor 3.2+, i ponów z jawnym n.
Sekrety CI wyciekły przez zatrutą akcję. Natychmiast zrotuj ujawnione poświadczenia i przypnij każdą akcję zewnętrzną na nowo do commit SHA.

Dokąd dalej z automatyzacją

Równoległe agenty i worktrees

Wejdź głębiej w /worktree, /best-of-n i /multitask w Pogłębionym przewodniku po trybach agenta.

Konfiguracja MCP

Podłącz i debuguj powyższe serwery we wszystkich trzech narzędziach w Niezbędnych serwerach MCP.

Więcej automatyzacji Cursor

Agenty w tle, checkpointy i strategie dla dużych baz kodu w Zaawansowanych technikach Cursor.

CI/CD z AI

Wepnij przegląd AI w swój potok od początku do końca w Automatyzacji potoków z AI.

Automatyzacja powinna wzmacniać twój osąd, a nie go zastępować. Zacznij od kontroli tylko do odczytu (recenzent pre-commit, który jedynie ostrzega), przejdź do operacji zapisu za bramką CI i trzymaj człowieka przy każdym nieodwracalnym kroku — wdrożeniach, force-pushach i wszystkim, co dotyka danych produkcyjnych.