Mistrzostwo terminala

Masz Claude Code uruchomione w jednej zakładce terminala, serwer deweloperski w drugiej, wyjście testów w trzeciej i git log w czwartej. Ciągle przełączasz zakładki, tracąc z oczu tę, która ma potrzebne wyjście. Potem Claude kończy zadanie, a ty przegapiasz powiadomienie, bo czytałeś logi w innej zakładce.

Zaawansowani użytkownicy rozwiązują to za pomocą multiplekserów terminala. Jeden ekran, wiele paneli, Claude Code zawsze widoczny.

Co z tego wyniesiesz

Konfigurację tmux zoptymalizowaną dla przepływów pracy z Claude Code
Układy wielopanelowe do developmentu, debugowania i przeglądów
Wzorce integracji z powłoką, które przekazują dane do Claude Code
Strategie powiadomień, aby nigdy nie przegapić zakończenia przez Claude

Układ terminala zaawansowanego użytkownika

tmux dla Claude Code

Idealny układ ma trzy lub cztery panele:

+----------------------------+------------------+
|                            |                  |
|      Claude Code           |   Serwer dev     |
|      (panel główny)        |   (góra-prawo)   |
|                            |                  |
+----------------------------+------------------+
|                            |                  |
|   Edytor / Pliki           |  Wyjście testów  |
|   (dół-lewo)               |   (dół-prawo)    |
|                            |                  |
+----------------------------+------------------+

Skrypt sesji tmux do skopiowania dla developmentu z Claude Code:

#!/bin/bash
# Zapisz jako ~/bin/dev-session.sh i chmod +x
SESSION="dev"

tmux new-session -d -s $SESSION -n "work"

# Panel główny: Claude Code
tmux send-keys -t $SESSION "claude" C-m

# Panel prawy: serwer dev
tmux split-window -h -t $SESSION
tmux send-keys -t $SESSION "npm run dev" C-m

# Panel lewy-dolny: obserwowanie plików
tmux split-window -v -t $SESSION:0.0
tmux send-keys -t $SESSION "git status" C-m

# Panel prawy-dolny: test runner
tmux split-window -v -t $SESSION:0.1
tmux send-keys -t $SESSION "npm run test:watch" C-m

# Fokus na panelu Claude Code
tmux select-pane -t $SESSION:0.0

tmux attach -t $SESSION

Skróty nawigacji paneli

Dodaj do ~/.tmux.conf dla szybkiego przełączania paneli:

# Użyj Alt+strzałka do przełączania paneli bez prefiksu
bind -n M-Left select-pane -L
bind -n M-Right select-pane -R
bind -n M-Up select-pane -U
bind -n M-Down select-pane -D

# Zwiększ historię dla scrollbacku
set -g history-limit 50000

Wzorce integracji z powłoką

Przekazywanie wyjścia do Claude Code

Prawdziwa moc developmentu opartego na CLI to przekazywanie. Wyjście każdego polecenia powłoki może stać się wejściem dla Claude Code:

# Analizuj niepowodzenia testów
npm run test 2>&1 | claude -p "Jakie są przyczyny źródłowe tych niepowodzeń testów? Pogrupuj według kategorii."

# Wyjaśnij złożoną historię git
git log --oneline --graph --since="1 week ago" | claude -p "Podsumuj aktywność rozwojową z tego tygodnia."

# Debuguj błędy budowania
npm run build 2>&1 | claude -p "Napraw te błędy budowania TypeScript. Pokaż mi dokładne potrzebne zmiany."

# Analizuj podatności zależności
npm audit --json | claude -p "Które z tych podatności są krytyczne i jakie są ścieżki aktualizacji?"

Funkcja powłoki do skopiowania dla szybkiej analizy Claude Code:

Dodaj do ~/.zshrc lub ~/.bashrc:

# Przekaż wyjście dowolnego polecenia do Claude Code dla analizy
ask() {
  "$@" 2>&1 | claude -p "Przeanalizuj to wyjście i wyjaśnij, co się dzieje. Jeśli są błędy, zasugeruj poprawki."
}

# Użycie: ask npm run build
# Użycie: ask git diff HEAD~3
# Użycie: ask curl -I https://api.example.com

Łańcuchowanie poleceń

Buduj wieloetapowe pipeline’y, które używają Claude Code jako kroku przetwarzania:

# Wygeneruj changelog z commitów
git log --oneline v1.2.0..HEAD | \
  claude -p "Wygeneruj changelog dla użytkowników z tych commitów. Pogrupuj według: Funkcje, Naprawy błędów, Wydajność." \
  --output-format text > CHANGELOG-draft.md

# Utwórz opis PR z diffa
git diff main...HEAD | \
  claude -p "Napisz opis PR dla tych zmian. Dołącz: Podsumowanie, Wprowadzone zmiany, Notatki testowe." \
  --output-format text

Przepływy pracy z wieloma sesjami

Równoległe instancje Claude Code

Uruchom wiele instancji Claude Code dla różnych celów. Pierwsze uruchomienie w każdym panelu startuje świeżą sesję; -r/--resume wznawia ją po nazwie przy kolejnych uruchomieniach (resume nie tworzy sesji — wskazanie go na nazwę, która nie istnieje, wrzuca cię w interaktywny wybór sesji):

# Terminal 1: Main development -- start fresh, resume by name later
claude              # later: claude -r "feature-work"

# Terminal 2: Background code review (separate tmux pane)
claude --model sonnet   # later: claude -r "review-session" --model sonnet

# Terminal 3: Test debugging (another pane) -- pin the ID up front to resume deterministically
claude --session-id "550e8400-e29b-41d4-a716-446655440000"

Każda sesja utrzymuje własny kontekst. Sesja pracy nad funkcją zna twoje decyzje architektoniczne. Sesja przeglądu koncentruje się na jakości kodu. Sesja testowa śledzi wzorce i niepowodzenia testów. Użyj --session-id <uuid>, gdy chcesz mieć znany uchwyt do późniejszego wznowienia; w przeciwnym razie pozwól, by sesja powstała przy pierwszym uruchomieniu, i wznawiaj ją po nazwie.

Wzorzec obserwuj-i-przekaż

Monitoruj proces i przekazuj jego wyjście do Claude Code, gdy coś pójdzie nie tak:

# Watch test output and analyze the FIRST failure of each run automatically.
# A naive version fires `claude -p` on every line matching FAIL -- on a noisy
# suite that is dozens of API calls per save (cost and rate-limit blow-up).
# The `triggered` guard limits it to one analysis per run; the test runner
# clearing the screen resets it for the next run.
triggered=0
npm run test:watch 2>&1 | while IFS= read -r line; do
  echo "$line"
  case "$line" in
    *"Watching for file changes"*|*"Ran all test suites"*) triggered=0 ;;
    *FAIL*)
      if [ "$triggered" -eq 0 ]; then
        triggered=1
        echo "$line" | claude -p "This test just failed. What is the likely cause based on the error message?"
      fi
      ;;
  esac
done

Strategie powiadomień

Powiadomienia dźwiękowe przez hooki

Skonfiguruj Claude Code, aby odtwarzał dźwięk po zakończeniu:

{
  "hooks": {
    "Stop": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "afplay /System/Library/Sounds/Glass.aiff"
          }
        ]
      }
    ]
  }
}

Integracja dzwonka terminala

Większość emulatorów terminala może migać lub podskakiwać w docku, gdy otrzymany zostanie znak dzwonka:

{
  "hooks": {
    "Stop": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "printf '\\a'"
          }
        ]
      }
    ]
  }
}

Hook powiadomień do skopiowania dla macOS:

{
  "hooks": {
    "Stop": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "osascript -e 'display notification \"Claude Code zakończył\" with title \"Claude Code\" sound name \"Glass\"'"
          }
        ]
      }
    ]
  }
}

Gdy to nie działa

Scrollback tmux nie przechwytuje wyjścia Claude Code: Zwiększ limit historii za pomocą set -g history-limit 50000 w ~/.tmux.conf. Sesje Claude Code mogą produkować tysiące linii.

Przekazane wyjście jest zbyt duże dla Claude Code: Przy przekazywaniu dużych wyjść użyj head lub tail, aby ograniczyć wejście. Claude Code działa najlepiej ze skoncentrowanym kontekstem, a nie 10 000 liniami logów.

Wiele instancji Claude Code osiąga limity: Każda instancja zużywa tokeny niezależnie. Jeśli uruchamiasz trzy równoległe sesje, twoje zużycie tokenów się potraja. Obserwuj swój /cost we wszystkich sesjach.

Dźwięki powiadomień odtwarzają się podczas spotkań: Uwarunkuj dźwięk od poziomu głośności. Unikaj output muted of (get volume settings) — w wielu konfiguracjach macOS zwraca missing value zamiast true/false, więc warunek odczytuje to jako niewyciszone i dźwięk i tak się odtwarza. Sprawdzaj zamiast tego poziom: [[ "$(osascript -e 'output volume of (get volume settings)')" -gt 0 ]] && afplay /System/Library/Sounds/Glass.aiff.

Co dalej

Inżynieria promptów — Pisz prompty, które maksymalizują wyjście z twojego przepływu pracy w terminalu
Automatyzacja skryptów — Przekształć swoje najlepsze wzorce terminala w skrypty wielokrotnego użytku
Koordynacja IDE + CLI — Połącz przepływy pracy w terminalu z edytorem