W poprzednim artykule uruchomiliśmy Copilot CLI i poznaliśmy trzy tryby pracy. Widziałeś już że możesz wpisać @Program.cs żeby przekazać plik do kontekstu – ale to zaledwie wierzchołek góry lodowej.

Ten artykuł dotyczy tego co sprawia że Copilot CLI jest naprawdę potężny: umiejętności przekazywania kontekstu. Zobaczysz jak analizować wiele plików jednocześnie, jak sesje zapisują się automatycznie i jak wrócić do przerwanej pracy parę dni później.

Wyobraź sobie że zgłaszasz bug współpracownikowi:

Copilot CLI działa dokładnie tak samo. Bez kontekstu dostaniesz ogólną odpowiedź. Z kontekstem – precyzyjną analizę konkretnego kodu. Składnia @ to mechanizm którym przekazujesz Copilotowi "spójrz na ten plik".

Symbol @ przed nazwą pliku lub katalogu informuje Copilot CLI że ma wczytać zawartość i dołączyć ją do kontekstu rozmowy. Trzy podstawowe wzorce:

Jeden plik

copilot

> Wyjaśnij co robi @Program.cs

Wiele plików naraz

> Porównaj @Program.cs i @TaskItem.cs pod kątem spójności stylu

Cały katalog

> Przejrzyj wszystkie pliki w @TaskList/ pod kątem obsługi błędów

Analiza jednego pliku jest użyteczna. Analiza wielu plików jednocześnie jest transformacyjna – Copilot widzi zależności, duplikaty i niespójności których nigdy nie znajdziesz przeglądając pliki po kolei.

Przetestuj to na naszym projekcie TaskList. Rozbudujmy go najpierw o drugi plik – stwórz TaskService.cs obok Program.cs:

// TaskService.cs – logika biznesowa wydzielona z Program.cs
public class TaskService
{
    private readonly List<TaskItem> _tasks;
    private readonly string _dataFile;

    public TaskService(List<TaskItem> tasks, string dataFile)
    {
        _tasks = tasks;
        _dataFile = dataFile;
    }

    public IEnumerable<TaskItem> GetAll() => _tasks;

    public void Add(string title)
    {
        _tasks.Add(new TaskItem { Title = title });
    }

    public bool MarkDone(int number)
    {
        if (number < 1 || number > _tasks.Count) return false;
        _tasks[number - 1].Done = true;
        return true;
    }

    public bool Remove(int number)
    {
        if (number < 1 || number > _tasks.Count) return false;
        _tasks.RemoveAt(number - 1);
        return true;
    }

    // Uwaga: ta metoda robi to samo co ListTasks w Program.cs
    public void PrintTasks()
    {
        foreach (var (task, i) in _tasks.Select((t, i) => (t, i + 1)))
            Console.WriteLine($"{i}. [{(task.Done ? "x" : " ")}] {task.Title}");
    }
}

Teraz zapytaj Copilota o oba pliki razem:

copilot

> @Program.cs @TaskService.cs Jak te pliki ze sobą współpracują?
  Czy widzisz jakieś problemy?

Copilot powinien wykryć między innymi:

• Zduplikowaną logikę wyświetlania – ListTasks w Program.cs i PrintTasks w TaskService.cs robią to samo
• Niespójną obsługę błędów – Program.cs rzuca wyjątkiem przy złym numerze, TaskService zwraca false
• Brak przepływu danych przez serwis – Program.cs nadal bezpośrednio operuje na liście zamiast przez TaskService

Zrozumienie projektu w 60 sekund

Przejmujesz nowy projekt i chcesz szybko zrozumieć co robi? Jeden prompt wystarczy:

> @TaskList/ W jednym akapicie: co robi ta aplikacja i
  jakie są jej największe problemy jakościowe?

To co zajęłoby godzinę czytania kodu – Copilot zwraca w kilka sekund. Wiesz dokładnie gdzie skupić uwagę.

Prawdziwa moc trybu interaktywnego leży w tym że każdy kolejny prompt buduje na poprzednim. Nie zaczynasz od nowa – prowadzisz rozmowę z kimś kto pamięta wszystko co było wcześniej.

copilot

> @TaskService.cs Przejrzyj klasę TaskService pod kątem jakości kodu

> Dodaj type annotations do wszystkich metod publicznych

> Teraz popraw obsługę błędów – zamiast zwracać bool, rzucaj wyjątkami z opisem

> Wygeneruj testy jednostkowe dla tej finalnej wersji

Zwróć uwagę: przy prośbie o testy Copilot generuje je dla wersji z typami i wyjątkami – nie dla pierwotnego kodu. Każdy krok buduje na poprzednim. Gdybyś te same pytania zadawał w oddzielnych sesjach lub przez -p, przy każdym musisz od nowa wklejać zaktualizowany kod.

Każda sesja Copilot CLI zapisuje się automatycznie gdy ją kończysz. Możesz wrócić do niej później i kontynuować dokładnie w miejscu gdzie skończyłeś – z pełną historią rozmowy i kontekstem plików.

Wznowienie ostatniej sesji

# Kontynuuj ostatnią sesję
copilot --continue

Wybór konkretnej sesji

# Lista wszystkich zapisanych sesji – wybierz interaktywnie
copilot --resume

# Lub wznów po ID (ID znajdziesz na liście powyżej)
copilot --resume abc123

Nadawanie nazw sesjom

copilot

> /rename tasklist-refactoring

Nadaj sesji sensowną nazwę zanim wyjdziesz – łatwiej ją znaleźć przez --resume za tydzień niż szukać po dacie.

copilot

> /rename tasklist-code-review
> @Program.cs @TaskService.cs Znajdź i ponumeruj wszystkie problemy jakościowe
> Napraw problem #1 (zduplikowana logika wyświetlania)
> /exit

copilot --continue

> Które problemy z naszej listy jeszcze nie zostały naprawione?

Podgląd i eksport sesji

> /session       # szczegóły bieżącej sesji i podsumowanie workspace
> /usage         # statystyki zużycia w bieżącej sesji
> /share file ./session-export.md   # eksportuj sesję do pliku Markdown
> /share gist                       # utwórz GitHub Gist z sesją

> /resume   # pokazuje listę sesji do przełączenia

Każdy model AI ma context window – maksymalną ilość tekstu którą może "widzieć" jednocześnie. To jak biurko: możesz na nim położyć tylko tyle dokumentów ile się zmieści. Pliki które przekazujesz przez @, historia rozmowy i odpowiedzi Copilota – wszystko zajmuje miejsce w tym oknie.

Copilot CLI mierzy to w tokenach. Przybliżona reguła: 1 token ≈ 4 znaki, czyli 1000 tokenów to mniej więcej 750 słów lub ~50–70 linii kodu C#.

Monitorowanie i zarządzanie kontekstem

> /context
Context usage: 45 000 / 128 000 tokenów (35%)

Trzy komendy do zarządzania gdy kontekst się zapełnia:

• /clear – czyści całą historię rozmowy, zaczyna od nowa. Używaj gdy zmieniasz temat.
• /compact – kompresuje historię rozmowy do podsumowania, zwalnia tokeny bez utraty kluczowych ustaleń. Używaj gdy sesja jest długa ale chcesz kontynuować.
• Nowa sesja – gdy kontekst jest naprawdę pełny i temat jest zupełnie nowy.

Strategia przekazywania kontekstu

Nie zawsze musisz wrzucać cały katalog. Bardziej precyzyjne referencje = mniej zużytych tokenów = dłuższa sesja:

Zaawansowany wzorzec: staged context loading – zacznij od ogółu, zawęź do szczegółu:

copilot

# Krok 1: struktura projektu
> @TaskList/ Pokaż mi strukturę projektu i zależności między plikami

# Krok 2: zawęź na podstawie odpowiedzi
> @TaskService.cs Przyjrzyjmy się tej klasie bliżej

# Krok 3: dodaj powiązany plik tylko gdy potrzebny
> @Program.cs @TaskService.cs Jak Program.cs korzysta z TaskService?

Poza podstawowymi wzorcami Copilot CLI obsługuje też wildcardy i referencje do obrazów:

> Znajdź wszystkie TODO w @TaskList/**/*.cs

> @**/Tests/*.cs Przejrzyj wszystkie pliki testów pod kątem pokrycia

Mniej oczywista, ale bardzo przydatna funkcja: możesz przekazać zrzut ekranu lub mockup przez @ albo wklejając ze schowka (Ctrl+V):

> @screenshot-blad.png Co się dzieje na tym zrzucie ekranu?

> @mockup-ui.png Napisz kod HTML i CSS który odtwarza ten layout

Czas przećwiczyć wszystko na naszym projekcie. Poniższy scenariusz łączy analizę wielu plików, wieloetapową rozmowę i zarządzanie sesją:

copilot

# Krok 1: analiza przepływu danych między plikami
> @Program.cs @TaskService.cs Prześledź jak zadanie trafia od wejścia użytkownika
  do zapisu w tasks.json. Które metody są zaangażowane na każdym etapie?

# Krok 2: analiza odporności na błędy
> Co się stanie jeśli plik tasks.json jest uszkodzony lub brakuje go?
  Które metody zawiodą jako pierwsze?

# Krok 3: propozycja ulepszenia
> Zaproponuj spójną strategię obsługi błędów działającą w obu plikach

# Krok 4: nazwij sesję i wyjdź
> /rename tasklist-data-flow
> /exit

# Krok 5: wróć do sesji
copilot --continue

# Krok 6: kontynuuj bez ponownego wyjaśniania
> Zaimplementuj pierwszą z zaproponowanych poprawek obsługi błędów

Po wykonaniu sprawdź zużycie tokenów przez /context. Spróbuj też /compact i sprawdź ile tokenów udało się odzyskać.

Kontekst to fundament efektywnej pracy z Copilot CLI. Kluczowe wnioski z tego artykułu:

• Składnia @ – przekazuj pliki (@plik.cs), katalogi (@folder/) lub wiele plików naraz; bez @ Copilot nie widzi zawartości
• Analiza wielu plików – ujawnia problemy niewidoczne w izolacji: duplikaty, niespójności, zależności
• Wieloetapowe rozmowy – każdy prompt buduje na poprzednim; iteruj małymi krokami zamiast jednym wielkim promptem
• Sesje – zapisują się automatycznie; --continue wznawia ostatnią, --resume pozwala wybrać; nadawaj nazwy przez /rename
• Context window – monitoruj przez /context; /clear przy zmianie tematu, /compact przy długich sesjach

W następnym artykule wykorzystamy cały ten aparat do realnych zadań developerskich: code review, debugowanie, generowanie testów i integracja z git – wszystko z terminala.

Do zobaczenia w artykule 03! 🚀