# Praca z Gitem za pomocą Claude Code: poradnik dla początkujących

> Kompletny, praktyczny przewodnik po integracji Gita i Claude Code: inteligentne stage'owanie, automatyczne opisy commitów, rozwiązywanie konfliktów scalania, GitHub CLI oraz standardy bezpieczeństwa.

## 1. Czym jest integracja Git w Claude Code

Claude Code posiada głęboką, natywną integrację z systemem kontroli wersji Git. W przeciwieństwie do standardowych czatów AI, gdzie programista musi ręcznie kopiować wyjście komend `git diff` czy `git status`, terminalowy agent Claude Code samodzielnie interaguje z Waszym lokalnym repozytorium za pośrednictwem wbudowanego narzędzia do wykonywania poleceń.

Agent analizuje strukturę zmian, śledzi historię projektu, przestrzega przyjętego stylu komunikatów commitów oraz przejmuje rutynowe operacje: tworzenie gałęzi, selektywne stage’owanie plików, bezpieczny rebase, a nawet generowanie pełnych opisów dla Pull Requestów.

```mermaid
flowchart TD
    A["Запит розробника:<br><i>'Commit current changes'</i>"] --> B["Claude Code CLI"]
    B --> C["git status<br><i>(Перевірка змінених файлів)</i>"]
    B --> D["git diff<br><i>(Аналіз змісту та логіки)</i>"]
    B --> E["git log -n 5<br><i>(Визначення конвенції комітів)</i>"]
    C & D & E --> F["Інтелектуальний стейджинг<br><i>(Вибіркові git add &lt;file&gt;)</i>"]
    F --> G["Генерація опису коміту<br><i>(feat/fix згідно з контекстом)</i>"]
    G --> H{"Підтвердження користувача"}
    H -->|Схвалено| I["Виконання git commit"]
    H -->|Коригування| J["Оновлення повідомлення"]
```

### Korzyści z używania Gita przez Claude Code

| Kryterium | Tradycyjny, ręczny Git | Praca przez Claude Code |
| :--- | :--- | :--- |
| **Analiza zmian** | Ręczna przegląda każdego pliku przez `git diff` | Automatyczne rozumienie semantyki i powiązań między plikami |
| **Opis commitów** | Często nieinformacyjne frazy typu *"update"*, *"fix bug"* | Ustrukturyzowane komunikaty zgodne ze standardem Conventional Commits |
| **Stage’owanie** | Ryzyko przypadkowego dodania zbędnych lub tymczasowych plików przez `git add .` | Punktowe stage’owanie tylko relewantnych plików kodu |
| **Konflikty scalenia** | Skomplikowane ręczne porównywanie markerów `<<<<<<<` | Inteligentna analiza logiki biznesowej obu gałęzi |
| **Tworzenie PR** | Ręczne pisanie tytułu, opisu i checklisty testów | Autogeneracja szczegółowego opisu dzięki integracji z `gh CLI` |

> [!NOTE]
> Claude Code wykonuje każdą komendę w izolowanym kontekście Waszego lokalnego repozytorium i zawsze prosi o potwierdzenie przed wykonaniem działań modyfikujących pliki lub historię gałęzi.

---

## 2. Tworzenie commitów: inteligentne stage’owanie i opisy

Najczęstszy codzienny workflow developera to zatwierdzanie zmian w repozytorium. Zamiast sekwencyjnego wywoływania trzech-czterech komend terminala, możecie zwrócić się do Claude Code jednym prostym zdaniem w języku naturalnym:

```bash
Commit these changes with a descriptive message
```

### Co dzieje się pod maską

Gdy Claude otrzymuje instrukcję utworzenia commita, wykonuje sekwencyjną diagnostykę:

1. **Diagnostyka drzewa roboczego:** wywołuje `git status`, aby uzyskać listę zmienionych, usuniętych oraz nowych, nieśledzonych plików.
2. **Semantyczna analiza kodu:** uruchamia `git diff`, aby zbadać linie podlegające edycji, oddzielając logikę biznesową od formatowania.
3. **Studium konwencji repozytorium:** sprawdza `git log -n 5`, ustalając, jak nazywane są commity w Waszym zespole (np. `feat(auth): ...` czy `Add auth module`).
4. **Punktowe stage’owanie:** dodaje do indeksu Gita tylko te pliki, które dotyczą bieżącego zadania, pomijając pliki konfiguracyjne lub sekrety.
5. **Formułowanie komunikatu:** generuje zwięzły nagłówek oraz treściwy opis wyjaśniający przyczyny i skutki zmian.

:::tabs
@tab Conventional Commits
```text
feat(cart): implement instant item quantity counter in navbar

- Add reactive useCartCount hook to synchronize state across tabs
- Optimize database query to aggregate item count in a single request
- Add unit tests for edge cases when cart contains empty items
```
@tab Zwięzły opis (Simple)
```text
fix: resolve race condition in token refresh flow

Prevent multiple parallel requests from triggering duplicate OAuth
refresh cycles when access token expires.
```
@tab Z odniesieniem do zadań (Jira/Linear)
```text
PROJ-412: refactor notification worker queue

Migrate Redis connection pool to cluster mode to handle burst traffic.
Closes #184.
```
:::

> [!TIP]
> Jeśli chcecie zatwierdzić tylko konkretny plik lub część zmian, wskażcie to bezpośrednio w prompcie: `Commit only the changes in src/components/Header.tsx with an appropriate message`.

---

## 3. Praca z gałęziami i przełączanie kontekstu

Izolacja kodu w osobnych gałęziach to fundamentalna zasada pracy zespołowej. Claude Code pozwala jednocześnie tworzyć gałąź i przechodzić do realizacji funkcjonalności bez rutynowego przełączania się między terminalem a edytorem.

### Tworzenie i przełączanie gałęzi

```bash
# Створити нову гілку та перейти на неї
Create a new branch named feature/instant-search and switch to it
```

Claude automatycznie wykona komendę `git checkout -b feature/instant-search` (lub `git switch -c`).

### Łączenie tworzenia gałęzi z implementacją funkcji

Największa efektywność osiągalna jest, gdy łączycie intencję stworzenia gałęzi z sformułowaniem zadania inżynierskiego:

```bash
Create a branch called fix/email-validation, then fix the regex check in the signup form and write a test for it
```

### Powszechnie przyjęte prefiksy dla gałęzi

- `feature/` lub `feat/` – nowa funkcjonalność lub komponent (np. `feature/stripe-payments`).
- `fix/` lub `bugfix/` – poprawka błędu (np. `fix/oauth-redirect`).
- `refactor/` – optymalizacja struktury kodu bez zmiany zachowania (np. `refactor/user-service`).
- `chore/` – aktualizacja zależności, konfiguracji CI/CD lub dokumentacji (np. `chore/upgrade-nextjs-15`).

---

## 4. Rozwiązywanie konfliktów scalenia (Merge Conflicts)

Konflikty scalenia pojawiają się, gdy ten sam fragment kodu został zmodyfikowany w dwóch różnych gałęziach. Ręczne rozwiązywanie takich sytuacji często prowadzi do przypadkowego usunięcia przydatnego kodu lub błędów składniowych.

Claude Code analizuje obie strony konfliktu, rozumie intencję autora każdej gałęzi i integruje zmiany bez utraty funkcjonalności.

### Algorytm krok po kroku rozwiązywania konfliktu przez Claude

1. **Uruchom proces scalenia lub rebasingu w terminalu:**
   ```bash
   git merge origin/main
   # або
   git rebase main
   ```
2. **Jeśli pojawią się markery konfliktu, przekaż sterowanie Claude Code:**
   ```bash
   I have merge conflicts after rebasing on main. Please inspect each conflicting file, analyze both sides of the changes, and resolve them cleanly.
   ```
3. **Analiza markerów:** Claude odczytuje markery `<<<<<<< HEAD`, `=======` oraz `>>>>>>>`, a następnie formułuje syntetyczną wersję kodu.
4. **Weryfikacja kompilacji:** po usunięciu markerów agent uruchamia sprawdzenie typów (`tsc --noEmit`) lub testy (`npm test`), aby upewnić się co do sprawności rozwiązania.
5. **Stage’owanie rozwiązanych plików:** agent wykonuje `git add <resolved-files>` i przygotowuje finalny krok do zakończenia scalenia.

```typescript
// Приклад конфлікту у файлі конфігурації:
<<<<<<< HEAD
export const API_TIMEOUT = 10000; // Збільшено таймаут для повільних мереж у гілці фічі
=======
export const API_TIMEOUT = 8000; // Оновлений стандарт бекенду з гілки main
export const RETRY_ATTEMPTS = 3;  // Нове поле, додане колегою у main
>>>>>>> origin/main
```

Claude zaproponuje optymalne, spójne rozwiązanie: zachowanie zwiększonego timeoutu `10000` z Waszej gałęzi oraz jednoczesne dodanie nowej stałej `RETRY_ATTEMPTS = 3` z gałęzi `main`.

---

## 5. Cherry-pick, Rebase i przenoszenie commitów

Czasami zachodzi potrzeba przeniesienia pojedynczego patcha lub krytycznej poprawki do gałęzi release’owej bez przenoszenia całej historii rozwoju. Służy do tego mechanizm `cherry-pick`.

### Przenoszenie pojedynczego commita (Cherry-pick)

```bash
Cherry-pick commit a7b9c1d from branch feature/cart onto release/v1.2.0
```

Jeśli podczas przenoszenia commita wystąpią rozbieżności w bazie kodowej, Claude automatycznie zlokalizuje diffy, skoryguje ścieżki importów lub zmienne i zaproponuje czyste rozwiązanie.

### Inteligentny backporting

W dużych projektach z kilkoma stabilnymi wersjami backporting jest rutynową procedurą. Możecie zlecić Claude’owi cały kompleks działań:

```bash
Backport the security fix from commit 3f8a92 to the legacy-support branch. Verify that existing legacy tests still pass and commit the result.
```

### Rebase vs Merge: kiedy co wybrać

| Operacja | Kiedy stosować | Zalety | Co robi Claude |
| :--- | :--- | :--- | :--- |
| **`git rebase main`** | Podczas aktualizacji lokalnej gałęzi świeżymi zmianami z `main` | Liniowa i czysta historia commitów bez zbędnych merge-commitów | Sprawdza każdy commit kolejno, automatycznie naprawia trywialne konflikty |
| **`git merge main`** | Przy scalaniu ukończonej gałęzi feature’owej do wspólnej gałęzi release’owej | Zachowuje dokładny chronologiczny porządek rozwoju | Tworzy pojedynczy merge-commit z wyczerpującą listą połączonych zmian |

---

## 6. Zarządzanie tymczasowymi zmianami przez Git Stash

Jeśli pilnie musicie przełączyć się na krytyczny bugfix lub sprawdzić działanie innej gałęzi, ale bieżąca praca nie jest jeszcze gotowa na commit, z pomocą przychodzi `git stash`.

Claude Code potrafi wykonywać wieloetapowe sekwencje operacji na schowku niezakończonych zmian:

```bash
Stash my current changes with a label 'wip-checkout', switch to main, pull latest changes, and report back
```

### Powrót do zapisanego stanu

Po zakończeniu sprawdzenia lub pilnego zatwierdzenia przywróćcie swoje dorobki:

```bash
Switch back to feature/checkout, pop the stash 'wip-checkout', and resolve any conflicts if the base changed
```

> [!TIP]
> Dzięki analizie semantycznej Claude automatycznie sprawdzi, czy pliki nie zostały usunięte podczas aktualizacji gałęzi bazowej, i poprawnie zastosuje zapisane zmiany.

---

## 7. Tworzenie Pull Requests i integracja z GitHub CLI (gh)

Jeśli w Waszym systemie zainstalowana jest oficjalna utility GitHub CLI (`gh`), Claude Code staje się pełnoprawnym asystentem tworzenia i recenzowania Pull Requestów.

### Automatyczne sporządzanie PR przez Claude

Zamiast ręcznie wypełniać formularz w przeglądarce, wpiszcie:

```bash
Push current branch to origin and create a pull request with gh CLI. Include summary, list of changes, and testing instructions.
```

### Przykład wygenerowanego Pull Requesta

Claude automatycznie formułuje szablon markdown wysokiej jakości:

```markdown
## Summary
This PR implements user session invalidation on password reset to prevent
unauthorized access from stolen legacy tokens.

## Changes
- Add `revokeAllUserSessions` service in `src/services/auth.ts`
- Update password reset controller to call invalidation hook
- Add Redis blacklist mechanism for active JWT tokens
- Cover revocation flow with integration tests in `auth.test.ts`

## Testing Instructions
1. Login from two different browsers (simulate active sessions)
2. Trigger "Forgot Password" flow in Browser A
3. Verify that Browser B gets redirected to `/login` on next API call
4. Run test suite: `npm run test:auth`

Fixes #284
```

> [!IMPORTANT]
> Upewnijcie się, że jesteście zalogowani w GitHub CLI za pomocą komendy `gh auth status` przed tworzeniem żądań scalenia.

---

## 8. Wbudowane zasady bezpieczeństwa i mechanizmy ochronne

Git to potężne narzędzie, ale niedbałe użycie niektórych flag może prowadzić do nieodwracalnej utraty kodu lub nadpisania wspólnej historii. Claude Code posiada wbudowane zasady ochrony przed takimi błędami.

```mermaid
flowchart LR
    subgraph Небезпечні_дії["Заблоковано без прямої команди"]
        D1["git push --force в main"]
        D2["git add -A / git add ."]
        D3["git commit --amend (чужі коміти)"]
        D4["git commit --no-verify"]
    end
    subgraph Безпечні_альтернативи["Стандарт Claude Code"]
        S1["Звичайний push або новий коміт"]
        S2["Точковий стейджинг окремих файлів"]
        S3["Створення нового фіксуючого коміту"]
        S4["Виправлення помилок лінтера/тестів"]
    end
    D1 -.-> S1
    D2 -.-> S2
    D3 -.-> S3
    D4 -.-> S4
```

### Cztery złote zasady bezpieczeństwa Claude Code

1. **Zakaz destrukcyjnego Force Push:** Claude nigdy nie wykonuje `git push --force` ani `-f` na zabezpieczonych gałęziach (`main`, `master`, `release`) bez Waszego wielokrotnego, jawnego potwierdzenia.
2. **Adresowe stage’owanie:** agent unika ślepych komend `git add .` lub `git add -A`. Każdy plik jest stage’owany według jego dokładnej ścieżki, co zapobiega przypadkowemu wyciekowi plików `.env`, kluczy szyfrujących lub lokalnych dumpów bazy danych.
3. **Zachowanie integralności historii:** agent preferuje tworzenie nowego commita korygującego zamiast modyfikacji historii przez `git commit --amend`, szczególnie jeśli zmiany zostały już wysłane na serwer zdalny.
4. **Szacunek dla Pre-commit Hooks:** Claude nie używa flagi `--no-verify` do obejścia sprawdzania Husky, ESLint czy Prettier. Jeśli hook blokuje commit, agent znajduje przyczynę błędu lintera lub testów, naprawia ją i ponawia próbę zgodnie z regułami.

> [!WARNING]
> Nigdy nie proście sztucznej inteligencji o wykonanie niesprawdzonych komend `git reset --hard HEAD~N` na wspólnych gałęziach. Zawsze używajcie `git stash` lub twórzcie tymczasową gałąź backupową przed masowymi zmianami historii.

---

## 9. Praktyczny warsztat: pełny cykl od gałęzi do PR

Spróbujmy przejść cały cykl pracy developera w realnym projekcie – od otrzymania zadania do wysłania gotowego kodu na review przy pomocy Claude Code.

### Krok 1. Sprawdzenie stanu i utworzenie gałęzi roboczej

Otwórzcie terminal w Waszym repozytorium, uruchomcie `claude` i dajcie zadanie:

```bash
Check git status, pull latest changes from main, and create a feature branch called feature/user-avatar
```

Claude upewni się, że katalog roboczy jest czysty, pobierze świeże aktualizacje i stworzy nową lokalną gałąź.

### Krok 2. Realizacja zadania

Postawcie zadanie agentowi:

```bash
Add an Avatar component in src/components/Avatar.tsx that renders a user image with fallback initials if the image URL is missing.
```

### Krok 3. Sprawdzenie i punktowy commit

Po utworzeniu pliku wydajcie polecenie zatwierdzenia wyniku:

```bash
Review what was created, make sure tests pass, and commit only the avatar component files with a clear conventional commit message
```

Claude sprawdzi sprawność działania, doda do indeksu `src/components/Avatar.tsx` (wraz z plikiem testowym) i sformułuje commit:

```text
feat(ui): add Avatar component with initials fallback

- Render user image with rounded profile styling
- Fallback to calculated two-letter initials on missing src or error
- Add unit test coverage for invalid image source handling
```

### Krok 4. Push i otwarcie Pull Requesta

Zakończcie cykl pracy finalnym promptem:

```bash
Push this branch to GitHub and create a draft PR using gh CLI describing the changes
```

---

## 10. Szybka samoocena i podsumowująca checklista

Sprawdźcie poziom przyswojenia materiału za pomocą krótkiego testu.

### Pytania kontrolne

> **1. Dlaczego Claude Code stage’uje pliki według ich dokładnych nazw zamiast wykonywać `git add .`?**
>
> > [!TIP]
> > **Odpowiedź:** Aby zapobiec przypadkowemu dodaniu do repozytorium danych poufnych (`.env`), tymczasowych plików systemowych (`.DS_Store`) oraz lokalnych buildów, które mogły zostać pominięte w `.gitignore`.

> **2. Jak Claude Code decyduje, w jakim formacie napisać komunikat commita?**
>
> > [!TIP]
> > **Odpowiedź:** Agent automatycznie analizuje ostatnie commity repozytorium przez `git log`, dostosowując się do istniejącego stylu zespołu (Conventional Commits, prefiksy ticketów Jira czy zwięzłe opisy).

> **3. Co się stanie, jeśli Pre-commit Hook (Husky/ESLint) zakończy się błędem podczas commita przez Claude?**
>
> > [!TIP]
> > **Odpowiedź:** Claude nie będzie omijał sprawdzenia flagą `--no-verify`. Zamiast tego przeanalizuje output lintera lub testów, usunie naruszenia w kodzie i ponownie wykona bezpieczny commit.

### Podsumowująca checklista efektywnej pracy z Gitem

- [ ] Używajcie jednego zdania `Commit these changes` zamiast ręcznego łańcucha komend `status -> add -> commit`.
- [ ] Łączcie tworzenie gałęzi z zadaniem biznesowym w jednym prompcie, aby zachować spójny kontekst.
- [ ] Powierzcie Claude’owi wstępną analizę i rozwiązywanie złożonych konfliktów scalenia po `rebase` czy `merge`.
- [ ] Zawsze używajcie `git stash` przez Claude’a przed pilnym przełączeniem się na inną gałąź.
- [ ] Zainstalujcie `gh CLI`, aby delegować Claude’owi generację ustrukturyzowanych PR-ów.