W poprzednim artykule omówiliśmy czym jest Copilot CLI i co potrafi. Czas przestać czytać, a zacząć działać. W tym wpisie zainstalujemy CLI, zalogujemy się, stworzymy projekt przewodni serii – TaskList – i zobaczymy pierwsze efekty pracy z AI w terminalu.

Na końcu omówimy trzy tryby pracy z Copilot CLI – bez ich zrozumienia trudno wycisnąć z narzędzia więcej niż podstawowe "zapytaj AI o coś".

Copilot CLI można zainstalować na kilka sposobów. Wybierz metodę odpowiednią dla swojego systemu:

Windows (WinGet)

winget install GitHub.Copilot

Windows / wszystkie platformy (npm)

npm install -g @github/copilot

macOS / Linux (Homebrew)

brew install copilot-cli

macOS / Linux (skrypt instalacyjny)

curl -fsSL https://gh.io/copilot-install | bash

npm config get prefix

Po instalacji uruchom CLI po raz pierwszy. Zostaniesz poproszony o zaufanie katalogowi roboczemu – możesz zatwierdzić jednorazowo lub dla wszystkich przyszłych sesji.

copilot

Następnie zaloguj się do GitHub:

> /login

Co się dzieje pod spodem:

• CLI wyświetla jednorazowy kod (np. ABCD-1234)
• Otwiera się przeglądarka z formularzem autoryzacji urządzenia na GitHub
• Wpisujesz kod, klikasz "Authorize"
• Wracasz do terminala – jesteś zalogowany

Zweryfikuj że wszystko działa:

> Powiedz cześć i opisz krótko do czego możesz mi pomóc

Powinieneś dostać przyjazną odpowiedź opisującą możliwości CLI. Wyjdź z sesji:

> /exit

Przez całą serię będziemy pracować na jednej aplikacji: prostej C# Console App do zarządzania listą zadań. Stwórzmy ją teraz – będziemy ją rozbudowywać w kolejnych artykułach.

Stwórz projekt

mkdir tasklist-cli
cd tasklist-cli
dotnet new console -n TaskList
cd TaskList

Zastąp zawartość Program.cs poniższym kodem startowym:

// TaskList – prosta aplikacja CLI do zarządzania zadaniami
// Projekt przewodni serii "GitHub Copilot CLI" na plukasiewicz.net

using System.Text.Json;

var dataFile = "tasks.json";
var tasks = LoadTasks(dataFile);

if (args.Length == 0)
{
    PrintHelp();
    return;
}

switch (args[0].ToLower())
{
    case "list":
        ListTasks(tasks);
        break;
    case "add":
        if (args.Length < 2) { Console.WriteLine("Podaj treść zadania."); break; }
        AddTask(tasks, string.Join(" ", args[1..]));
        SaveTasks(dataFile, tasks);
        break;
    case "done":
        if (args.Length < 2) { Console.WriteLine("Podaj numer zadania."); break; }
        MarkDone(tasks, int.Parse(args[1]));
        SaveTasks(dataFile, tasks);
        break;
    case "remove":
        if (args.Length < 2) { Console.WriteLine("Podaj numer zadania."); break; }
        RemoveTask(tasks, int.Parse(args[1]));
        SaveTasks(dataFile, tasks);
        break;
    default:
        Console.WriteLine($"Nieznana komenda: {args[0]}");
        PrintHelp();
        break;
}

static List<TaskItem> LoadTasks(string path)
{
    if (!File.Exists(path)) return new List<TaskItem>();
    var json = File.ReadAllText(path);
    return JsonSerializer.Deserialize<List<TaskItem>>(json) ?? new List<TaskItem>();
}

static void SaveTasks(string path, List<TaskItem> tasks)
{
    var json = JsonSerializer.Serialize(tasks, new JsonSerializerOptions { WriteIndented = true });
    File.WriteAllText(path, json);
}

static void ListTasks(List<TaskItem> tasks)
{
    if (tasks.Count == 0) { Console.WriteLine("Brak zadań."); return; }
    foreach (var (task, i) in tasks.Select((t, i) => (t, i + 1)))
        Console.WriteLine($"{i}. [{(task.Done ? "x" : " ")}] {task.Title}");
}

static void AddTask(List<TaskItem> tasks, string title)
{
    tasks.Add(new TaskItem { Title = title });
    Console.WriteLine($"Dodano: {title}");
}

static void MarkDone(List<TaskItem> tasks, int number)
{
    if (number < 1 || number > tasks.Count) { Console.WriteLine("Nieprawidłowy numer."); return; }
    tasks[number - 1].Done = true;
    Console.WriteLine($"Oznaczono jako wykonane: {tasks[number - 1].Title}");
}

static void RemoveTask(List<TaskItem> tasks, int number)
{
    if (number < 1 || number > tasks.Count) { Console.WriteLine("Nieprawidłowy numer."); return; }
    var removed = tasks[number - 1];
    tasks.RemoveAt(number - 1);
    Console.WriteLine($"Usunięto: {removed.Title}");
}

static void PrintHelp()
{
    Console.WriteLine("TaskList – zarządzanie zadaniami");
    Console.WriteLine("  list          – wyświetl zadania");
    Console.WriteLine("  add <treść>   – dodaj zadanie");
    Console.WriteLine("  done <nr>     – oznacz jako wykonane");
    Console.WriteLine("  remove <nr>   – usuń zadanie");
}

class TaskItem
{
    public string Title { get; set; } = "";
    public bool Done { get; set; } = false;
}

Sprawdź że aplikacja działa:

dotnet run -- list
dotnet run -- add "Nauczyć się Copilot CLI"
dotnet run -- add "Przeczytać całą serię"
dotnet run -- list
dotnet run -- done 1
dotnet run -- list

Brak zadań.
Dodano: Nauczyć się Copilot CLI
Dodano: Przeczytać całą serię
1. [ ] Nauczyć się Copilot CLI
2. [ ] Przeczytać całą serię
Oznaczono jako wykonane: Nauczyć się Copilot CLI
1. [x] Nauczyć się Copilot CLI
2. [ ] Przeczytać całą serię

Mamy działający projekt. Teraz zobaczmy co potrafi Copilot CLI gdy dostanie go do przejrzenia.

Uruchom Copilot CLI z katalogu projektu i poproś o przegląd kodu:

copilot

> Przejrzyj @Program.cs pod kątem jakości kodu i zasugeruj ulepszenia

Copilot przeanalizuje plik i zwróci listę obserwacji – np. brak obsługi wyjątków przy parsowaniu numeru zadania, brak separacji odpowiedzialności, brak komentarzy XML. Odpowiedź będzie inna za każdym razem, ale typ informacji jest przewidywalny: Copilot traktuje Twój kod jak senior developer który robi code review.

Spróbuj jeszcze dwóch szybkich demonstracji w tej samej sesji:

> Wyjaśnij w prostych słowach co robi metoda LoadTasks w @Program.cs

> Napisz funkcję C# która przyjmuje listę TaskItem i zwraca statystyki:
  łączna liczba zadań, ile wykonanych, ile niewykonanych

To ostatnie zapytanie – generowanie kodu – to scenariusz który w praktyce oszczędza kilka minut googlowania i testowania. Wyjdź z sesji gdy skończyłeś:

> /exit

Widziałeś już tryb interaktywny w akcji. Czas poznać wszystkie trzy tryby i wiedzieć kiedy którego używać. Kurs oryginalny opisuje je przez analogię do zamawiania jedzenia – i to naprawdę działa:

Tryb 1: Interactive – zacznij tutaj

Uruchamiasz go przez samo wpisanie copilot. Kontekst rozmowy narasta – każda wiadomość buduje na poprzednich, dokładnie jak w normalnej rozmowie. To tryb który powinieneś opanować jako pierwszy.

copilot

> Przejrzyj @Program.cs – co można poprawić?
> Dodaj obsługę wyjątków do parsowania numeru zadania
> Dodaj XML docs do wszystkich metod statycznych
> /exit

Zwróć uwagę: każde kolejne polecenie buduje na poprzednim. Nie zaczynasz od nowa – prowadzisz rozmowę.

Tryb 2: Plan – najpierw mapa, potem kod

Uruchamiasz go komendą /plan wewnątrz sesji interaktywnej, lub skrótem Shift+Tab który przełącza między trybami. Copilot układa krok po kroku plan implementacji – Ty go przeglądasz i akceptujesz zanim cokolwiek zostanie napisane.

copilot

> /plan Dodaj komendę "search" która filtruje zadania po fragmencie tytułu

Dostaniesz plan w stylu: krok 1 – dodaj gałąź w switch, krok 2 – zaimplementuj metodę SearchTasks, krok 3 – zaktualizuj help, krok 4 – przetestuj. Możesz zaakceptować, zmodyfikować, albo poprosić o inny podział kroków.

Tryb 3: Programmatic – jedno pytanie, jedna odpowiedź

Flaga -p pozwala zadać pytanie bez wchodzenia w sesję interaktywną. Idealne do skryptów, automatyzacji i szybkich jednorazowych pytań.

# Szybkie pytanie bez sesji
copilot -p "Jak sprawdzić czy plik JSON jest poprawnie sformatowany w C#?"

# Przegląd pliku z automatu
copilot --allow-all -p "Szybki code review @Program.cs – tylko krytyczne problemy"

Tryb programmatic świeci szczególnie w skryptach PowerShell lub bash. Przykład: automatyczny code review wszystkich plików .cs w projekcie:

# PowerShell
Get-ChildItem *.cs | ForEach-Object {
    $path = $_.Name
    Write-Host "Przeglądam: $path"
    copilot --allow-all -p "Szybki code review @$path – tylko krytyczne problemy"
}

W trybie interaktywnym masz do dyspozycji komendy slash. Sześć poniższych pokrywa 90% codziennego użycia – resztę możesz odkrywać stopniowo przez /help:

Jedna wskazówka której brakuje w oficjalnej dokumentacji: komendy shell możesz uruchamiać bezpośrednio z sesji bez wychodzenia z CLI, używając prefiksu !:

> !dotnet build
> !dotnet test
> !git status

Copilot CLI wykonuje komendę w tle i wraca do sesji. Przydatne gdy chcesz np. zbudować projekt po sugerowanej zmianie i od razu zapytać o błąd kompilacji.

Mamy zainstalowane CLI, działający projekt TaskList i rozumiemy trzy tryby pracy. To solidna baza.

Kluczowe obserwacje z tego artykułu:

• Interactive – do eksploracji i iteracyjnej pracy; kontekst narasta przez całą sesję
• Plan – do złożonych zadań; najpierw widzisz plan, potem akceptujesz implementację
• Programmatic – do automatyzacji i jednorazowych pytań; wchodzi i wychodzi bez sesji

W następnym artykule zajmiemy się tym co sprawia że Copilot CLI jest naprawdę potężny: zarządzaniem kontekstem. Zobaczysz jak używać @ do przekazywania plików i całych katalogów, jak działa context window pod spodem i dlaczego ta wiedza przekłada się bezpośrednio na jakość odpowiedzi.

Do zobaczenia w artykule 02! 🚀