# Claude Code Desktop: sesje, worktree i code review w aplikacji

URL: https://developertoolkit.ai/pl/claude-code/build/desktop-app/
Description: Co aplikacja Claude Code Desktop dodaje do CLI: równoległe sesje w worktree, przegląd diffów, podgląd aplikacji, monitoring CI i wspólne ustawienia.

Claude Code Desktop to karta **Code** w aplikacji desktopowej Claude: ten sam silnik co Claude Code CLI, z interfejsem graficznym do równoległych sesji, każdej we własnym git worktree, komentowania diffów linia po linii, podglądu działającej aplikacji i śledzenia pull requesta w CI. Czyta te same pliki `CLAUDE.md`, ustawienia, hooki, skille i konfigurację MCP co CLI.

W jednym terminalu masz w połowie zbudowaną funkcję, na Slacku czeka zgłoszenie błędu, a recenzent prosi o poprawki we wczorajszym pull requeście. W CLI oznacza to trzy terminale, trzy sesje z `--worktree`, których trzeba pilnować, osobną kartę przeglądarki na każdy serwer deweloperski i diff czytany przez `git diff | less`. Ta strona jest dla **deweloperów**, którzy już pracują z Claude Code w terminalu albo zaraz zaczną, i chcą wiedzieć, kiedy aplikacja desktopowa jest lepszym stanowiskiem pracy i co ustawić, żeby CLI i Desktop zachowywały się tak samo.

**Sprawdzone na Claude Code 2.1.283**

Wszystko na tej stronie sprawdzono 26 września 2026 na Claude Code v2.1.283 i w [dokumentacji aplikacji desktopowej](https://code.claude.com/docs/en/desktop) producenta. Układ paneli, terminal, edytor plików i tryby widoku wymagają Claude Desktop v1.2581.0 lub nowszej. Aplikacja zmienia się co tydzień; zanim oprzesz się na szczególe, sprawdź wersję w **Claude → About Claude** (macOS) albo **Help → About** (Windows).

## Co daje ci praca w aplikacji desktopowej

- Tabelę decyzyjną: kiedy pracować w Desktop, a kiedy zostać w terminalu.
- Konfigurację, w której każda sesja Desktop startuje we własnym worktree, z właściwymi plikami `.env` i serwerem deweloperskim.
- Cztery prompty do skopiowania: konfigurację podglądu, sesję z nową funkcją zakończoną dowodami, przegląd pozostałych sesji i mapę diffu do code review.
- Pętlę code review opartą na widoku diffu, przycisku **Review code** i pasku statusu CI, w której bramką są testy, a nie twoje oczy.
- Pułapki konfiguracji: zmienne środowiskowe, pierwszeństwo serwerów MCP i tryby uprawnień, które działają inaczej niż w CLI.

## Co aplikacja desktopowa dodaje do terminala?

Desktop korzysta z tego samego silnika, więc model, narzędzia i pętla agenta są identyczne. Zmienia się sposób nadzorowania kilku sesji i oglądania wyniku. Zanim zainstalujesz aplikację, upewnij się, że masz płatną subskrypcję Pro, Max, Team albo Enterprise; bez niej karta Code kończy się błędem uwierzytelniania (zobacz tabelę rozwiązywania problemów).

| Możliwość | CLI | Desktop |
| :-- | :-- | :-- |
| Równoległe sesje | Jeden terminal na sesję albo [agent view](/pl/claude-code/automate/agent-view/) | Lista w pasku bocznym; `Cmd`+kliknięcie (macOS) lub `Ctrl`+kliknięcie (Windows) otwiera dwie sesje obok siebie |
| Izolacja sesji | `claude --worktree [nazwa]` (`-w`; nazwa jest opcjonalna) | Opcja **worktree** obok nazwy gałęzi przy starcie sesji |
| Przegląd diffu | `/diff`, `git diff`, twoje IDE | Widok diffu z komentarzami do linii, na które Claude reaguje, oraz przycisk **Review code** |
| Podgląd aplikacji | Twoja przeglądarka | Panel Browser, który uruchamia serwer z `.claude/launch.json` i pozwala Claude robić zrzuty ekranu, klikać i badać DOM |
| Obsługa pull requesta | `gh`, strona CI | Pasek statusu CI z przełącznikami **Auto-fix** i **Auto-merge** (wymaga zalogowanego `gh`) |
| Gdzie działa | Twój komputer, chmura (`--cloud`), devcontainer | **Local**, **Cloud**, host **SSH** albo dystrybucja **WSL** w Windows |
| Skrypty | `claude -p`, `--output-format`, [Agent SDK](/pl/claude-code/automate/agent-sdk/) | Niedostępne; Desktop działa tylko interaktywnie |
| Wiele agentów | Agent teams (eksperymentalne), subagenci, [dynamic workflows](/pl/claude-code/automate/dynamic-workflows/) | Subagenci i dynamic workflows; agent teams tylko w CLI (sprawdzone 26.09.2026) |
| Tryby uprawnień | Wszystkie, łącznie z `dontAsk` | Manual, Accept edits, Plan, Auto; Bypass permissions dopiero po włączeniu; bez `dontAsk` (sprawdzone 26.09.2026) |

Aplikacja działa na macOS, Windows (x64 i ARM64) i Linuksie (beta, instalacja przez apt w Ubuntu i Debianie). Computer use, czyli sterowanie przez Claude innymi aplikacjami na ekranie, to research preview na macOS i Windows tylko w planach Pro i Max; w wersji linuksowej go nie ma.

## Kiedy wybrać Desktop zamiast CLI?

Wybieraj narzędzie według rodzaju pracy, a nie z przyzwyczajenia. CLI i Desktop mogą działać jednocześnie na tym samym projekcie, a każde z nich ma własną listę sesji.

| Twoja praca wygląda tak… | Użyj | Dlaczego |
| :-- | :-- | :-- |
| Kilka niezależnych zadań, które prowadzisz ręcznie w ciągu dnia | Desktop | Pasek boczny, widok dzielony i powiadomienia systemowe pokazują, która sesja cię potrzebuje |
| Praca nad UI albo API, której efekt chcesz zobaczyć | Desktop | Panel Browser i auto-verify stawiają działającą aplikację obok diffu |
| Przegląd zmiany, zanim stanie się pull requestem | Desktop | Komentarze do linii trafiają prosto do Claude jako nowa tura |
| Skrypt, zadanie CI, hook pre-commit, cokolwiek z `-p` | CLI | Desktop nie ma trybu nieinteraktywnego |
| Wiele sesji w tle zlecanych z jednego miejsca | CLI ([agent view](/pl/claude-code/automate/agent-view/)) | Zbudowane do zlecania i podglądu; narzędzia międzysesyjne Desktop nie widzą sesji z CLI |
| Amazon Bedrock, Agent Platform w Google Cloud (dawniej Vertex AI) albo Microsoft Foundry | CLI, chyba że dział IT skonfigurował Claude Desktop dla tego dostawcy | Desktop domyślnie łączy się z API Anthropic |
| Skoordynowane zespoły agentów (agent teams) | CLI | Niedostępne w Desktop |
| Długa migracja, która ma działać dalej po zamknięciu laptopa | Sesja **Cloud** w Desktop albo `claude --cloud` w CLI | Sesje w chmurze działają na infrastrukturze Anthropic i liczą się do limitów twojego planu |

Przekazywanie działa w obie strony. W sesji terminalowej uruchom `/desktop` (alias `/app`), żeby zapisać sesję i otworzyć ją w aplikacji; działa to na macOS i Windows x64 z subskrypcją Claude, ale nie z kluczem API ani u zewnętrznego dostawcy. W aplikacji wpisz `/resume` w polu promptu, żeby podjąć dowolną sesję rozpoczętą w CLI; listę przeszukasz po tytule, folderze albo gałęzi.

## Skonfiguruj Desktop tak, żeby każda sesja była izolowana i weryfikowalna

Ustawienia domyślne wystarczą na pierwszą sesję. Do codziennej pracy równoległej wykonaj poniższą konfigurację raz dla każdego repozytorium; to ona sprawia, że sesje nie wchodzą sobie w drogę, a Claude ma czym sprawdzić własną pracę. Najpierw zainstaluj aplikację zgodnie z [przewodnikiem instalacji](/pl/claude-code/quick-start/installation/) albo ze strony pobierania producenta i zaloguj się.

1. **Otwórz kartę Code i przed pierwszą wiadomością wybierz cztery rzeczy.** W obszarze promptu wybierz środowisko (**Local** dla twojego komputera), folder projektu, model i tryb uprawnień. Zacznij od modelu domyślnego; [przegląd modeli](/pl/ecosystem/models/) wyjaśnia, kiedy go zmienić. Przy wszystkim większym niż poprawka błędu zacznij od **Plan**, a po zatwierdzeniu planu przełącz na **Accept edits**.

2. **Włączaj opcję worktree dla każdej sesji w repozytorium git.** Zaznacz **worktree** obok nazwy gałęzi. Każda sesja dostaje wtedy własny checkout w `<project-root>/.claude/worktrees/`, więc zmiany w jednej sesji nie dotykają innej, dopóki ich nie zacommitujesz. W **Settings → Claude Code** możesz przenieść lokalizację worktree i ustawić prefiks gałęzi, na przykład `claude/`, żeby gałęzie agentów łatwo było rozpoznać i sprzątnąć.

3. **Kopiuj ignorowane pliki do nowych worktree.** Worktree to świeży checkout, więc brakuje w nim `.env` i serwer deweloperski nie wstaje. Dodaj plik `.worktreeinclude` w katalogu głównym projektu. Używa składni `.gitignore` i kopiuje tylko pliki, które są też ignorowane przez gita:

   ```text
   .env
   .env.local
   config/local.json
   ```

   Ten sam plik działa dla sesji CLI z `--worktree` i dla worktree subagentów, więc piszesz go raz.

4. **Daj podglądowi konfigurację serwera.** Claude wykrywa serwer deweloperski i zapisuje `.claude/launch.json` w otwartym folderze. Dodaj go do repozytorium i popraw; dla monorepo z aplikacją webową i API wygląda tak:

   ```json
   {
     "version": "0.0.1",
     "configurations": [
       {
         "name": "web",
         "runtimeExecutable": "pnpm",
         "runtimeArgs": ["--filter", "web", "dev"],
         "port": 3000,
         "autoPort": true
       },
       {
         "name": "api",
         "runtimeExecutable": "pnpm",
         "runtimeArgs": ["--filter", "api", "start"],
         "port": 8080,
         "autoPort": false
       }
     ]
   }
   ```

   Ustaw `autoPort: true` dla serwerów, które mogą zmienić port, gdy działają dwa worktree naraz; Claude przekazuje nowy port w zmiennej `PORT`. Ustaw `autoPort: false` dla serwera, którego port wyznacza callback OAuth albo lista CORS. Nigdy nie wpisuj sekretów w `env`: ten plik trafia do repozytorium. Auto-verify jest domyślnie włączone, więc po każdej edycji Claude robi zrzut ekranu i sprawdza stronę; wyłączysz je dla projektu przez `"autoVerify": false`.

5. **Ustaw lokalne zmienne środowiskowe w aplikacji, nie tylko w powłoce.** Gdy uruchamiasz aplikację z Docka albo Findera na macOS, odczytuje ona z profilu powłoki `PATH` i stały zestaw zmiennych Claude Code, a resztę eksportów pomija. W Windows ignoruje profile PowerShell. Otwórz listę środowisk, najedź na **Local**, kliknij ikonę koła zębatego i dodaj zmienne potrzebne serwerowi deweloperskiemu. Klucz `env` w `~/.claude/settings.json` trafia do sesji Claude, ale nie do serwerów podglądu.

6. **Zaloguj `gh`, jeśli chcesz monitorować pull requesty.** Pasek statusu CI odpytuje checki przez GitHub CLI. Uruchom `gh auth status` w zintegrowanym terminalu (`` Ctrl+` ``); jeśli się nie powiedzie, uruchom `gh auth login`.

**Prompt do skopiowania: konfiguracja podglądu dla tego repozytorium**

```text
Inspect package.json files, Procfile, docker-compose.yml and any README run
instructions in this repository. Write .claude/launch.json with one
configuration per server a developer runs locally. Use the exact commands the
repo documents, not guesses. Set autoPort to false for any server whose port
appears in an OAuth redirect URI, a CORS allowlist or another service's config,
and cite the file and line that pins it. Put no secrets in env. Then start each
server from the preview, load its root URL, and report which ones came up and
which failed, with the error output for any failure.
```

## Prowadź równoległe sesje, które kończą się dowodami

W aplikacji desktopowej rozpoczęcie sesji nic nie kosztuje. Twój dzień ogranicza to, ile wyników zdążysz sprawdzić, więc niech każda sesja wytwarza dowód, który sprawdzisz. Naciśnij `Cmd+N` (macOS) albo `Ctrl+N` (Windows), wybierz opcję worktree i zacznij od promptu, który nazywa kryterium akceptacji i rezultat. [Kryteria akceptacji](/pl/workflows/plan/acceptance-criteria/) pokazują, jak pisać warunki, których agent nie „przegada”.

**Prompt do skopiowania: sesja z funkcją, która sama się dowodzi**

```text
Add CSV export to the invoices table on /billing/invoices. Acceptance: the
Export button downloads a file with the same columns and row order as the
table, respects the current filters, and escapes commas and quotes correctly.
Work only in this worktree. Write the tests first: a unit test for the CSV
serializer with a row containing a comma, a quote and a newline, and an
end-to-end test that applies a filter and checks the downloaded file. Show me
the failing tests, then implement. Run the full test suite, the type checker
and the linter. Open the preview, apply a filter, export, and attach a
screenshot. Finish with a summary listing each acceptance point, the test that
covers it, and the command output that shows it passing. Do not commit.
```

`Ctrl+Tab` i `Ctrl+Shift+Tab` przełączają między sesjami. Aplikacja wysyła powiadomienie systemowe, gdy sesja kończy zadanie, a ty akurat na nią nie patrzysz, więc możesz ją zostawić i przejść do innej. Żeby zadać pytanie bez zbijania sesji z kursu, otwórz boczny czat (`Cmd+;` na macOS, `Ctrl+;` na Windows albo `/btw`). Może odczytać sesję do tego momentu, a po jego zamknięciu wracasz do głównego wątku.

Claude potrafi też podejrzeć twoje pozostałe sesje **Desktop** i wysłać im wiadomość. Zapytaj zwykłym językiem w dowolnej sesji:

**Prompt do skopiowania: co robią pozostałe sesje**

```text
List my other sessions in this project. For each one, tell me its branch, what
it changed, whether its tests last passed, and whether it is waiting on me.
Flag any two sessions that edited the same file. If the payments session has
not seen the schema change in migrations/0042_invoice_currency.sql, send it a
message describing the new column and ask it to rerun its tests.
```

Ten mechanizm widzi tylko sesje lokalne, SSH i WSL uruchomione przez samą aplikację, domyślnie 20 ostatnio aktywnych. Nie widzi sesji w chmurze ani sesji z CLI czy rozszerzenia VS Code, nawet w worktree tego samego repozytorium. Przed zarchiwizowaniem sesji Claude zawsze pyta o zgodę, w każdym trybie uprawnień.

## Przejrzyj diff bez czytania każdej linii

Twoim zadaniem na tym etapie jest ocena, czy dowody się bronią, a nie korekta tekstu. [Dowody zamiast diffów](/pl/ladder/evidence-not-diffs/) tłumaczą tę zmianę; aplikacja desktopowa daje do niej narzędzia w tej kolejności:

1. **Najpierw przeczytaj podsumowanie sesji.** Każdy punkt akceptacji potrzebuje wskazanego testu i wyniku, który przechodzi. Punkt bez testu to luka, a nie sukces. Poproś o test, zanim spojrzysz na kod.
2. **Otwórz widok diffu, klikając wskaźnik `+12 -1`** (albo `Cmd+Shift+D`). Lista plików po lewej pokazuje, gdzie leży ryzyko. Jeśli zmiana dotyka więcej niż kilku plików, poproś o mapę do code review (prompt poniżej).
3. **Kliknij Review code.** Claude analizuje bieżący diff i zostawia w nim komentarze. Szuka błędów kompilacji, oczywistych błędów logicznych, podatności bezpieczeństwa i ewidentnych bugów, a pomija styl i wszystko, co wyłapie linter. Traktuj to jako drugie przejście, nie zatwierdzenie: to ta sama rodzina modeli, która napisała kod.
4. **Skomentuj linie, które cię niepokoją.** Kliknij linię, wpisz komentarz i wyślij wszystkie komentarze naraz przez `Cmd+Enter` (`Ctrl+Enter` w Windows). Claude odpowiada nowym diffem. Komentuj zachowanie („co się stanie, gdy filtr nie pasuje do żadnego wiersza?”), a nie nazewnictwo.
5. **Sprawdź, czy testy nie zostały osłabione.** W diffie przejrzyj pliki testów przed plikami źródłowymi. Usunięta asercja albo nowy `skip` to najczęstszy sposób, w jaki agent „przechodzi” testy. [Chroń wyrocznię](/pl/workflows/test/protect-the-oracle/) pokazuje, jak to uniemożliwić hookami i uprawnieniami do plików.
6. **Otwórz pull request i pozwól decydować CI.** W sesji pojawia się pasek statusu CI. **Auto-fix** pozwala Claude czytać nieudane checki i wypychać poprawki. **Auto-merge** sprawia, że Claude scala pull request metodą squash, gdy tylko wszystkie checki przejdą; wymaga włączenia auto-merge w ustawieniach repozytorium GitHub. Włączaj go tylko w repozytoriach, w których ochrona gałęzi wymaga twojego code review i każdego checka, na którym polegasz, bo zielona lista checków to jedyne, na co czeka.

**Prompt do skopiowania: mapa diffu przed code review**

```text
Before I review this diff, produce a review map. Group every changed file into
one of: behaviour change, test, config or migration, generated or mechanical.
For each behaviour change, name the test that exercises it and quote the
assertion. List every test file where an assertion was removed, loosened or
skipped. List anything that touches authentication, payments, data deletion
or a migration. End with the three hunks you think are most likely to be
wrong and why. Do not change any code.
```

Dla tech leadów: widok diffu to osobista pomoc przy code review, a nie bramka zespołu. Bramką pozostają wymagane checki w CI i code ownerzy na pull requeście, opisani w [automatyzacji code review](/pl/claude-code/ship/review-automation/) i w [przeglądzie pull requesta od agenta](/pl/workflows/ship/agent-pr-review/).

## Jak Desktop i CLI współdzielą ustawienia?

Desktop i CLI czytają te same pliki, więc większość konfiguracji przechodzi bez wysiłku:

- **Pamięć**: `CLAUDE.md` i `CLAUDE.local.md` w projekcie; zobacz [system pamięci](/pl/claude-code/build/memory-system/).
- **Ustawienia**: `~/.claude/settings.json`, projektowy `.claude/settings.json` i `~/.claude.json`. Reguły uprawnień i dozwolone narzędzia obowiązują w sesjach Desktop.
- **Hooki i skille** zdefiniowane w ustawieniach oraz osobiste skille w `~/.claude/skills/`. Sesja SSH czyta `~/.claude/skills/` na zdalnym hoście, a nie na twoim laptopie.
- **Serwery MCP** z `~/.claude.json` i `.mcp.json`; zobacz [konfigurację MCP](/pl/claude-code/quick-start/mcp-setup/).
- **Pluginy** w zakresie użytkownika, projektu albo lokalnym, łącznie z pluginami zarządzanymi przez organizację.

Domyślny tryb uprawnień ustaw raz, dla obu interfejsów, w `~/.claude/settings.json`:

```json
{
  "permissions": {
    "defaultMode": "acceptEdits"
  }
}
```

W Desktop tryb wybrany w selektorze jest zapamiętywany dla folderu i nadpisuje `defaultMode` w tym folderze, z wyjątkiem **Plan**, który trwa jedną sesję. To najczęstszy powód, dla którego sesja Desktop kolegi pyta o mniej zgód niż twoja w tym samym repozytorium.

Trzy rzeczy **nie** są współdzielone tak, jak można by się spodziewać:

| Co | Zachowanie w Desktop | Co zrobić |
| :-- | :-- | :-- |
| Serwery MCP w `claude_desktop_config.json` (konfiguracja karty Chat) | Ładowane do lokalnych sesji Code; przy konflikcie nazw z `~/.claude.json` albo `.mcp.json` wygrywa definicja z `claude_desktop_config.json` | Trzymaj jedną definicję na nazwę serwera. Żeby skopiować te serwery do CLI, uruchom `claude mcp add-from-claude-desktop` (macOS i WSL) |
| Serwer stdio zdefiniowany i w `~/.claude.json` (zakres użytkownika), i w projektowym `.mcp.json` | Karta Code używa wersji z `~/.claude.json`, odwrotnie niż kolejność zakresów w CLI | Usuń kopię osobistą, gdy źródłem prawdy jest plik projektu |
| Listy sesji | Osobne dla CLI i Desktop | Przenoś sesje przez `/desktop` z CLI albo `/resume` w Desktop |

Konektory, czyli serwery dodawane przyciskiem **+**, to serwery MCP z graficzną konfiguracją. Używaj ich do obsługiwanych usług, takich jak GitHub, Linear czy Slack; wszystko, co współdzieli zespół, trzymaj w projektowym `.mcp.json`, żeby widziały to też CLI i CI.

## Co się psuje po przejściu na Desktop?

| Objaw | Przyczyna | Naprawa |
| :-- | :-- | :-- |
| Claude nie znajduje `node`, `pnpm` ani `python` | Aplikacja nie odziedziczyła `PATH`, który buduje twoja powłoka (menedżery wersji, własne profile) | Sprawdź, czy narzędzie działa w terminalu, popraw `PATH` w profilu powłoki, zrestartuj aplikację; brakujące zmienne dodaj w edytorze środowiska lokalnego |
| Serwer podglądu startuje, ale nie łączy się z bazą | Zmienna jest w powłoce albo w `env` w `settings.json`, które nie trafia do serwerów podglądu | Dodaj ją w edytorze środowiska lokalnego (koło zębate przy **Local**) |
| „Git is required” albo błąd Git LFS przy starcie sesji | Sesje w worktree wymagają gita, a niektóre repozytoria Git LFS | Zainstaluj Git (w Windows Git for Windows); dla LFS zainstaluj go, uruchom `git lfs install` i zrestartuj aplikację |
| Serwer drugiej sesji nie startuje, bo port jest zajęty | Dwa worktree uruchamiają ten sam serwer na tym samym porcie | Ustaw `autoPort: true` dla tej konfiguracji albo `false` i uruchamiaj go w jednej sesji naraz |
| Serwer MCP działa inaczej niż w terminalu | Ta sama nazwa jest w `claude_desktop_config.json` albo w zakresie użytkownika, a te wygrywają w karcie Code | Zmień nazwę albo usuń zdublowaną definicję |
| `/permissions` odpowiada `isn't available in this environment` | Polecenia otwierające okno dialogowe terminala nie działają w Desktop | Edytuj plik ustawień bezpośrednio albo uruchom polecenie w CLI |
| `Error 403: Forbidden` w karcie Code | Nieaktualne logowanie albo brak płatnego planu | Wyloguj się i zaloguj ponownie; jeśli CLI działa, a Desktop nie, zamknij aplikację całkowicie i otwórz ją znowu |
| „Branch doesn't exist yet” przy otwieraniu sesji chmurowej w CLI | Sesja w chmurze utworzyła gałąź, której nie pobrałeś | Skopiuj nazwę gałęzi z paska narzędzi, potem `git fetch origin <gałąź>` i `git checkout <gałąź>` |
| **Continue in → Claude Code on the Web** jest nieaktywne albo odmawia | Przekazanie wypycha gałąź i wymaga czystego drzewa roboczego; nie działa dla sesji SSH | Najpierw zacommituj albo zrób stash i spróbuj ponownie; w sesji SSH wypchnij gałąź i uruchom z niej sesję w chmurze |
| Znika worktree, który był jeszcze potrzebny | Archiwizacja sesji, ręczna albo automatyczna po scaleniu lub zamknięciu pull requesta, usuwa jej worktree | Commituj i wypychaj przed archiwizacją; nie włączaj auto-archiwizacji, jeśli wracasz do gałęzi po zamknięciu pull requesta |

Dwa ustawienia wymagają ostrożności także poza rozwiązywaniem problemów. **Bypass permissions** to odpowiednik `--dangerously-skip-permissions` w Desktop; używaj go tylko w jednorazowym kontenerze lub maszynie wirtualnej z ograniczoną siecią, nigdy na laptopie z produkcyjnymi poświadczeniami w zasięgu. [Uprawnienia i sandboxing](/pl/workflows/harness/permissions-and-sandboxing/) opisują bezpieczne konfiguracje. Na urządzeniach zarządzanych administratorzy mogą wyłączyć sesje lokalne (`disableDesktopLocalSessions`), ograniczyć tryby uprawnień, z góry skonfigurować hosty SSH i zablokować przeglądanie zewnętrznych stron; zajrzyj do [integracji w firmie](/pl/claude-code/team/enterprise-integration/), zanim obiecasz zespołowi jakąś funkcję.

Te same idee istnieją w innych narzędziach, choć w innej formie: aplikację desktopową Codex opisują [Codex app mastery](/pl/codex/build/app-mastery/) i [worktree w Codex](/pl/codex/automate/worktrees/), a równoległych agentów Cursora — [okno Agents w Cursorze](/pl/cursor-ide/build/agents-window/).

## Dokąd dalej z Claude Code Desktop

- [Agent view](/pl/claude-code/automate/agent-view/) — Zlecaj i nadzoruj wiele sesji w tle z terminala, gdy pasek boczny Desktop to za mało.
- [Integracja z IDE](/pl/claude-code/quick-start/ide-integration/) — Połącz Claude Code z VS Code albo JetBrains, gdy wolisz edycje obok edytora niż osobną aplikację.
- [Przegląd pull requesta od agenta](/pl/workflows/ship/agent-pr-review/) — Protokół triażu pull requestów otwieranych przez twoje sesje Desktop.
- [Channels i Remote Control](/pl/claude-code/automate/channels-and-remote-control/) — Steruj działającą sesją z telefonu albo czatu, gdy jesteś z dala od biurka.
