Cursor – pełny przewodnik po możliwościach i konfiguracji agentów AI

Maj 2026

Cursor to edytor kodu zbudowany na bazie VS Code, który od 2023 roku zrewolucjonizował sposób, w jaki programiści pracują z AI. W odróżnieniu od prostych wtyczek do czatowania z modelem językowym, Cursor traktuje AI jako pełnoprawnego uczestnika procesu tworzenia oprogramowania – agenta, który czyta pliki, wykonuje polecenia w terminalu, przegląda błędy, pisze i modyfikuje kod, a nawet otwiera pull requesty na GitHubie. Ten artykuł to szczegółowy przegląd tego, co Cursor potrafi, i – co ważniejsze – jak go skonfigurować, żeby agenci działali lepiej, sprawniej i zgodnie z Twoimi oczekiwaniami.

Tryby pracy z AI

Cursor oferuje kilka trybów interakcji z modelem:

Ask (Pytaj)

Tryb tylko do odczytu. Agent może przeglądać pliki, przeszukiwać kod i odpowiadać na pytania, ale nie wprowadza żadnych zmian. Świetny do eksplorowania nieznanej bazy kodu, rozumienia architektury czy wyjaśniania fragmentów.

Agent (domyślny tryb roboczy)

Pełnoprawny agent z dostępem do wszystkich narzędzi: może czytać i zapisywać pliki, uruchamiać komendy w terminalu, przeszukiwać kod, instalować pakiety, klonować repozytoria, otwierać przeglądarki, wywoływać narzędzia MCP i delegować zadania do podagentów. Znakomita większość pracy dzieje się w tym trybie.

Plan (Planuj)

Tryb tylko do odczytu przeznaczony do projektowania rozwiązań przed ich implementacją. Gdy zadanie jest duże, wielowątkowe albo ma istotne kompromisy architektoniczne, tryb Plan pozwala omówić podejście zanim cokolwiek zostanie zmienione w kodzie.

Inline Edit

Szybka edycja bezpośrednio w edytorze – zaznaczasz fragment kodu, naciskasz skrót klawiszowy i opisujesz zmianę. Idealny do refaktoringu pojedynczej funkcji, naprawiania konkretnego błędu, dodawania komentarzy.

Tab Completion

Inteligentne uzupełnianie kodu – Cursor przewiduje, co napiszesz dalej, uwzględniając kontekst całego projektu, a nie tylko aktualnego pliku. Obsługuje wieloliniowe sugestie i potrafi zaproponować kolejny krok w sekwencji zmian.

Kontekst – serce pracy agenta

Agent jest tak dobry, jak kontekst, który dostaje. Cursor oferuje kilka mechanizmów dostarczania kontekstu:

@-mentions

W oknie czatu możesz odwołać się do:
- @plik.ts – konkretny plik
- @folder/ – cały katalog
- @Git – historia commitów
- @Docs – zewnętrzna dokumentacja (np. React, Tailwind)
- @Web – wyszukiwarka internetowa w czasie rzeczywistym
- @Codebase – przeszukiwanie semantyczne całej bazy kodu

Dołączanie plików

Możesz przeciągnąć pliki do okna czatu lub użyć przycisku załącznika, żeby agent miał dostęp do konkretnych zasobów – np. screenshotu błędu, pliku CSV z danymi, schematu bazy.

MCP – Model Context Protocol

MCP to otwarty standard integracji zewnętrznych narzędzi z agentami AI. Cursor obsługuje serwery MCP, które rozszerzają możliwości agenta o dostęp do zewnętrznych systemów.

Przykłady dostępnych serwerów MCP:
- Datadog – zapytania o logi, metryki, trace'y,
- Linear – zarządzanie ticketami i projektami,
- Sentry – przeglądanie błędów i issue,
- Slack – wysyłanie wiadomości, przeglądanie kanałów,
- Databricks – zapytania SQL, praca z danymi,
- Stripe – dane o subskrypcjach i płatnościach,
- GitHub – pull requesty, issues, code review,
- PostgreSQL / SQLite – bezpośrednie zapytania do bazy.

MCP konfiguruje się w ~/.cursor/mcp.json (globalnie) lub .cursor/mcp.json (per projekt). Przykładowa konfiguracja:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..."
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
    }
  }
}

Canvas – interaktywne artefakty

Canvas to nowsza funkcja Cursora, która pozwala agentowi tworzyć żywe aplikacje React otwierane bezpośrednio obok okna czatu. Zamiast wklejać tabelę z danymi w markdown, agent może wyrenderować interaktywny dashboard, wykres, timeline czy narzędzie do eksploracji danych.

Canvasy są idealne gdy:
- wynik to standalone artefakt analityczny – zestawienie metryk, audyt bezpieczeństwa, raport, przegląd architektury,
- dane z MCP (Datadog, Databricks itp.) są głównym produktem, a nie krokiem pośrednim,
- wynik ma wiele wierszy i skorzystałby na wizualnym układzie.

Plik canvas ma rozszerzenie .canvas.tsx i importuje tylko z cursor/canvas – bez zewnętrznych pakietów, bez fetch(). Agent tworzy go automatycznie, gdy temat na to wskazuje.

Reguły (Rules) – persistentna konfiguracja agenta

Reguły to jeden z najpotężniejszych mechanizmów konfiguracyjnych Cursora. Pozwalają na trwałe instruowanie agenta – ustalenie standardów kodowania, konwencji projektu, wzorców architektonicznych, których agent ma przestrzegać.

Gdzie je przechowywać?

Reguły projektowe – w .cursor/rules/ (wersjonowane razem z projektem, wspólne dla całego zespołu).

Format pliku

Pliki reguł mają rozszerzenie .mdc i zawierają frontmatter YAML:

---
description: Standardy TypeScript dla tego projektu
globs: **/*.ts
alwaysApply: false
---

# Obsługa błędów

Zawsze loguj błędy przed ponownym rzuceniem wyjątku:

\`\`\`typescript
// ❌ ŹLE
try {
  await fetchData();
} catch (e) {}

// ✅ DOBRZE
try {
  await fetchData();
} catch (e) {
  logger.error('Błąd pobierania danych', { error: e });
  throw new DataFetchError('Nie udało się pobrać danych', { cause: e });
}
\`\`\`

Pola frontmatter

Dobre praktyki

• Reguła powinna mieć jeden, konkretny cel – nie pakuj wszystkiego do jednego pliku.
• Zawieraj konkretne przykłady (dobrze / źle) – agent znacznie lepiej uczy się z przykładów niż z abstrakcyjnych opisów.
• Trzymaj reguły poniżej 500 linii – im zwięźlej, tym lepiej.
• Używaj alwaysApply: true dla reguł globalnych (np. język odpowiedzi, styl commitów).

Przykłady użytecznych reguł

Reguła językowa (agent zawsze odpowiada po polsku):

---
description: Język odpowiedzi agenta
alwaysApply: true
---
Zawsze odpowiadaj po polsku, chyba że użytkownik wyraźnie poprosi o inny język.

Reguła stylowa dla React:

---
description: Wzorce komponentów React
globs: **/*.tsx
alwaysApply: false
---
- Używaj komponentów funkcyjnych, nigdy klasowych.
- Wyodrębniaj logikę do własnych hooków (useXxx).
- Kolocuj style z komponentem (CSS Modules lub styled-components).
- Props typuj przez interfejsy, nie type aliases.

Reguła commitów:

---
description: Format wiadomości commitów
alwaysApply: true
---
Commity w formacie Conventional Commits:
- feat: nowa funkcja
- fix: naprawa błędu
- refactor: refaktoryzacja bez zmiany zachowania
- docs: dokumentacja
- test: testy

Przykład: `feat(auth): dodaj logowanie przez Google OAuth`

Skille (Skills) – specjalistyczna wiedza agenta

Skille to coś więcej niż reguły – to zestawy instrukcji opisujące jak wykonywać konkretne zadania. Agent ładuje skill tylko wtedy, gdy temat rozmowy na to wskazuje (lub gdy go o to poprosisz). Dzięki temu kontekst nie jest zaśmiecany nieistotnymi informacjami.

Gdzie przechowywać?

• ~/.cursor/skills/nazwa-skilla/ – skille osobiste, dostępne we wszystkich projektach.
• .cursor/skills/nazwa-skilla/ – skille projektowe, wersjonowane z repozytorium.

Uwaga: Nigdy nie twórz skillów w ~/.cursor/skills-cursor/ – to katalog wewnętrzny Cursora.

Struktura skilla

moj-skill/
├── SKILL.md              # Wymagany – główne instrukcje.
├── reference.md          # Opcjonalny – szczegółowa dokumentacja.
├── examples.md           # Opcjonalny – przykłady użycia.
└── scripts/              # Opcjonalny – skrypty pomocnicze.
    └── helper.py

Format SKILL.md

---
name: analiza-sprzedazy
description: Analizuje dane sprzedażowe z CSV, generuje raporty i wykresy. Użyj gdy użytkownik wspomina o sprzedaży, przychodach, raportach miesięcznych lub plikach CSV.
---

# Analiza danych sprzedażowych

## Szybki start

1. Wczytaj plik CSV przez pandas.
2. Sprawdź typy kolumn i brakujące wartości.
3. Oblicz agregaty (suma, średnia, trend).
4. Wygeneruj wykres przez matplotlib.

## Skrypty pomocnicze

\`\`\`bash
python scripts/validate_csv.py plik.csv
# Zwraca: "OK" lub listę problemów
\`\`\`

Kluczowe zasady pisania skillów

Opis (description) jest krytyczny – agent używa go do decydowania, kiedy załadować skill. Powinien zawierać:
- Co skill robi (możliwości)?
- Kiedy użyć (scenariusze wyzwalające, słowa kluczowe)?

Przykład dobrego opisu:

description: Przegląda pull requesty pod kątem jakości, bezpieczeństwa i zgodności ze standardami zespołu. Użyj gdy recenzujesz PR, przeglądasz zmiany w kodzie lub gdy użytkownik prosi o code review.

Zwięzłość – agent jest inteligentny, nie wyjaśniaj oczywistości. Pisz tylko to, czego agent nie wiedziałby sam.

disable-model-invocation: true – domyślna opcja, skill ładuje się tylko gdy zostanie wprost wywołany lub gdy agent sam go wybierze na podstawie kontekstu.

Przykłady przydatnych skillów

• code-review – Standardy recenzji kodu dla Twojego projektu, checklist bezpieczeństwa.
• deploy – Kroki wdrożeniowe (staging → produkcja), lista rzeczy do sprawdzenia.
• db-schema – Opis struktury bazy danych, relacje między tabelami.
• commit-messages – Preferowany format, przykłady dobrych i złych komunikatów.
• api-conventions – Standardy nazewnictwa endpointów, formaty odpowiedzi, obsługa błędów.
• onboarding – Przewodnik dla nowych deweloperów, jak uruchomić projekt lokalnie.

Hooki (Hooks) – automatyzacja wokół zdarzeń agenta

Hooki to zaawansowana funkcja pozwalająca uruchamiać własne skrypty lub zapytania do modelu przed lub po konkretnych zdarzeniach w pracy agenta. Dzięki nim możesz:

• blokować niebezpieczne operacje (np. rm -rf, komendy sieciowe),
• formatować pliki automatycznie po każdej edycji,
• audytować co agent robi,
• wstrzykiwać dodatkowy kontekst po wykonaniu narzędzia,
• chainować subagentów w pętle.

Gdzie przechowywać?

• .cursor/hooks.json + .cursor/hooks/ – hooki projektowe
• ~/.cursor/hooks.json + ~/.cursor/hooks/ – hooki użytkownika (globalne)

Format hooks.json

{
  "version": 1,
  "hooks": {
    "beforeShellExecution": [
      {
        "command": ".cursor/hooks/approve-network.sh",
        "matcher": "curl|wget|nc",
        "failClosed": true
      }
    ],
    "afterFileEdit": [
      {
        "command": ".cursor/hooks/format.sh"
      }
    ]
  }
}

Dostępne zdarzenia

Przykład: blokowanie niebezpiecznych komend

#!/bin/bash
# .cursor/hooks/approve-network.sh
input=$(cat)
command=$(echo "$input" | jq -r '.command // empty')

if <span class="text-amber-500/50" title="Nieznany link">[[&quot;$command&quot; =~ curl]]</span>; then
  echo '{
    "permission": "ask",
    "user_message": "Ta komenda może wysłać żądanie sieciowe. Czy zatwierdzasz?",
    "agent_message": "Hook zablokował komendę jako potencjalne żądanie sieciowe."
  }'
  exit 0
fi

echo '{ "permission": "allow" }'
exit 0

Przykład: auto-formatowanie po edycji

#!/bin/bash
# .cursor/hooks/format.sh
input=$(cat)
file=$(echo "$input" | jq -r '.path // empty')

if <span class="text-amber-500/50" title="Nieznany link">[[&quot;$file&quot; =~ \.(ts]]</span>; then
  npx prettier --write "$file" 2>/dev/null
fi

exit 0

Hooki promptowe

Zamiast skryptu możesz użyć modelu językowego do podjęcia decyzji:

{
  "version": 1,
  "hooks": {
    "beforeShellExecution": [
      {
        "type": "prompt",
        "prompt": "Czy ta komenda wygląda bezpiecznie? Pozwalaj tylko na operacje read-only. Komenda: $ARGUMENTS",
        "timeout": 10
      }
    ]
  }
}

Hooki promptowe są proste w konfiguracji, ale hooki skryptowe są deterministyczne i audytowalne – wybieraj w zależności od potrzeb.

Status line w CLI

Cursor ma własny interfejs CLI (cursor w terminalu) z obsługą customowej linii statusu nad promptem. Jest to skrypt, który odpala się przy każdej aktualizacji konwersacji i może pokazywać dowolne informacje.

Konfiguracja w ~/.cursor/cli-config.json:

{
  "statusLine": {
    "type": "command",
    "command": "~/.cursor/statusline.sh",
    "padding": 2
  }
}

Skrypt otrzymuje na stdin JSON z informacjami o sesji – aktualny model, procent wykorzystania okna kontekstu, katalog roboczy, aktywną gałąź git, tryb vim, nazwę worktree i więcej.

Przykład skryptu pokazującego model i pasek kontekstu:

#!/usr/bin/env bash
input=$(cat)
MODEL=$(echo "$input" | jq -r '.model.display_name')
PCT=$(echo "$input" | jq -r '.context_window.used_percentage // 0' | cut -d. -f1)

BAR_WIDTH=10
FILLED=$((PCT * BAR_WIDTH / 100))
EMPTY=$((BAR_WIDTH - FILLED))
BAR=""
[ "$FILLED" -gt 0 ] && printf -v FILL "%${FILLED}s" && BAR="${FILL// /▓}"
[ "$EMPTY" -gt 0 ] && printf -v PAD "%${EMPTY}s" && BAR="${BAR}${PAD// /░}"

printf "\033[36m[%s]\033[0m ctx %s %s%%\n" "$MODEL" "$BAR" "$PCT"

Wynik: [Claude Sonnet 4.5] ctx ▓▓▓░░░░░░░ 30%

Subagenci i zadania równoległe

Cursor Agent może tworzyć podagentów – wyspecjalizowane procesy uruchamiane równolegle do obsługi złożonych zadań. Jest to szczególnie przydatne przy:

• eksploracji dużej, nieznanej bazy kodu (agent „explore" przeszukuje wiele miejsc jednocześnie),
• wykonywaniu izolowanych eksperymentów w osobnych gałęziach git (worktrees),
• analizach wymagających wielu niezależnych źródeł danych,
• uruchamianiu testów, buildów czy deploymentów w tle.

Typy podagentów

Subagenci działają w tle i notyfikują agenta głównego po zakończeniu.

Worktrees – izolowane środowiska pracy

Cursor obsługuje git worktrees – możliwość posiadania kilku roboczych kopii repozytorium jednocześnie, każda na innej gałęzi. Agenci mogą pracować w oddzielnych worktree'ach niezależnie od siebie, nie kolidując ze swoją pracą.

Przydatne gdy:
- chcesz porównać kilka implementacji tego samego problemu,
- uruchamiasz długi build w tle i jednocześnie pracujesz na innej funkcji,
- testujesz różne podejścia do refaktoringu.

Babysitting PR – agent pilnujący pull requestów

Skill babysit realizuje scenariusz, w którym agent samodzielnie nadzoruje PR do momentu, gdy jest gotowy do merge'a. W pętli:

1. Sprawdza komentarze do PR (w tym od botów jak Bugbot).
2. Naprawia te, z którymi się zgadza; wyjaśnia przy tych, co do których nie jest pewien.
3. Rozwiązuje konflikty merge (tylko gdy intencja zmian jest oczywista).
4. Naprawia czerwone CI.
5. Pushuje zmiany i obserwuje CI ponownie.
6. Powtarza do skutku.

Split to PRs – dzielenie dużej pracy na małe PR-y

Skill split-to-prs pomaga podzielić dużą porcję niezatwierdzonej pracy na kilka małych, przeglądanych pull requestów. Procedura:

1. Agent analizuje stan repo i historię czatu, żeby zrozumieć intencję.
2. Proponuje podział (zazwyczaj sam tytuł PR wystarczy).
3. Czeka na Twoją zgodę.
4. Tworzy gałęzie, commituje tylko zaplanowane pliki lub hunki, pushuje i otwiera PR-y.
5. Zachowuje backup przed jakimikolwiek operacjami git.

Konfiguracja ustawień edytora

Cursor dziedziczy pełną konfigurowalność VS Code. Ustawienia użytkownika znajdują się w:

Popularne ustawienia specyficzne dla Cursora:

{
  "cursor.cpp.enablePartialAccepts": true,
  "cursor.chat.showSuggestedFiles": true,
  "cursor.chat.smoothStreaming": true,
  "cursor.composer.shouldAutoScrollToBottom": true
}

Jak to wszystko połączyć – przykładowa konfiguracja projektu

Oto jak może wyglądać dobrze skonfigurowany projekt:

moj-projekt/
├── .cursor/
│   ├── rules/
│   │   ├── typescript-standards.mdc    # Standardy TS, alwaysApply: false, globs: **/*.ts
│   │   ├── react-patterns.mdc          # Wzorce React, alwaysApply: false, globs: **/*.tsx
│   │   ├── commit-style.mdc            # Format commitów, alwaysApply: true
│   │   └── polish-responses.mdc        # Odpowiedzi po polsku, alwaysApply: true
│   ├── skills/
│   │   ├── db-schema/
│   │   │   └── SKILL.md                # Schemat bazy danych tego projektu.
│   │   └── deploy/
│   │       └── SKILL.md                # Procedura deploymentu.
│   ├── hooks.json                      # Automatyzacje zdarzeń agenta.
│   ├── hooks/
│   │   ├── format.sh                   # Auto-formatowanie po edycji.
│   │   └── approve-network.sh          # Pytaj przed requestami sieciowymi.
│   └── mcp.json                        # Integracje z zewnętrznymi narzędziami.

Na poziomie użytkownika (globalnie):

~/.cursor/
├── skills/
│   ├── code-review/
│   │   └── SKILL.md                   # Mój osobisty styl code review.
│   └── git-workflow/
│       └── SKILL.md                   # Mój workflow z git
├── hooks.json                         # Globalne hooki (np. blokada rm -rf).
├── hooks/
│   └── safety-check.sh
└── cli-config.json                    # Status line CLI.

Dobre praktyki pracy z agentem

Bądź konkretny w poleceniach

Im precyzyjniej opisujesz zadanie, tym lepszy wynik. Zamiast „napraw błąd", napisz „funkcja calculateTotal w cart.ts zwraca undefined gdy lista produktów jest pusta – napraw ją tak, żeby zwracała 0".

Używaj @-mentions świadomie

Dodawaj do kontekstu tylko to, co istotne. Agent z przeładowanym kontekstem traci wydajność. Wskaż konkretny plik zamiast całego folderu, jeśli to wystarczy.

Czytaj, zanim zaakceptujesz

Agent popełnia błędy. Zawsze przejrzyj proponowane zmiany przed zatwierdzeniem – szczególnie przy modyfikacjach plików konfiguracyjnych, bazy danych czy skryptów deploymentu.

Iteruj w małych krokach

Zamiast jednego wielkiego zadania (które może się nie udać), podziel pracę na mniejsze etapy. Po każdym etapie sprawdź wynik, zadaj pytania, popraw kierunek.

Buduj regułowy fundament

Poświęć czas na napisanie dobrych reguł i skillów na początku projektu. To jednorazowa inwestycja, która procentuje przy każdej kolejnej rozmowie z agentem.

Korzystaj z trybu Plan przed dużymi zmianami

Przed refaktoringiem dużego modułu, migracją bazy danych czy przepisaniem krytycznej logiki – przejdź najpierw do trybu Plan, omów podejście, upewnij się że agent rozumie ograniczenia i zamierzenia.

Nowości (2026)

Cursor CLI jako autonomiczny agent terminalowy

Cursor nie jest już tylko edytorem. CLI (cursor) pozwala uruchamiać agenta bezpośrednio z terminala – bez otwierania interfejsu graficznego. Idealne do automatyzacji, skryptów CI/CD czy pracy na zdalnych serwerach przez SSH.

Best-of-N runner

Subagent best-of-n-runner uruchamia to samo zadanie wielokrotnie w izolowanych worktree'ach i zwraca najlepszy wynik. Przydatny gdy zadanie ma wiele prawidłowych podejść i zależy Ci na jakości rozwiązania, a nie tylko na szybkości.

Rozszerzone hooki

Nowe zdarzenia hookowe dają jeszcze lepszą kontrolę nad zachowaniem agenta: afterAgentResponse, afterAgentThought, preCompact (przed kompresją kontekstu). Możliwe jest budowanie kompleksowych systemów audytu i bezpieczeństwa wokół agenta.

Prompt hooks – polityki opisane językiem naturalnym

Zamiast pisać skrypt bash do walidacji, można opisać politykę bezpieczeństwa słowami naturalnymi w hooku promptowym – Cursor wywołuje model językowy, który decyduje czy akcja jest dozwolona. Szczególnie przydatne dla nietrywialnych reguł biznesowych.

Integracja z kanbanami i narzędziami PM

Przez serwery MCP agent może teraz bezpośrednio czytać i modyfikować tickety w Linear, Jira, Notion i podobnych narzędziach – kontekst zadania trafia do agenta bez copy-paste.

Podsumowanie

Cursor to nie tylko „edytor z AI" – to platforma do budowania własnego środowiska pracy z agentem AI dopasowanym do Twoich potrzeb. Kluczowe mechanizmy konfiguracyjne:

Im lepsza konfiguracja, tym mniej czasu spędzasz na wyjaśnianiu agentowi kontekstu, a więcej na faktycznej pracy. Dobrze skonfigurowany Cursor to agent, który zna Twój projekt, Twój styl i Twoje ograniczenia – i działa w zgodzie z nimi od pierwszego słowa.

Artykuł napisany w maju 2026. Cursor aktywnie się rozwija – niektóre funkcje mogą być dostępne tylko w określonych planach lub wersjach.

Źródła i dalsze czytanie

1. Cursor Docs – dokumentacja główna – przegląd wszystkich funkcji agenta, reguł, MCP, skillów i CLI
   cursor.com/docs

2. Hooks | Cursor Docs – pełna dokumentacja systemu hooków: zdarzenia, format JSON, matchers, przykłady skryptów
   cursor.com/docs/agent/third-party-hooks

3. Agent Skills | Cursor Docs – specyfikacja skillów: struktura SKILL.md, lokalizacje, frontmatter, automatyczne wywoływanie
   cursor.com/docs/context/skills

4. Model Context Protocol (MCP) | Cursor Docs – konfiguracja serwerów MCP, transporty (stdio, SSE, HTTP), instalacja z Marketplace
   cursor.com/docs/context/mcp

5. Canvases | Cursor Docs – opis formatu canvas.tsx, komponenty SDK, workflow tworzenia interaktywnych artefaktów
   cursor.com/docs/agent/tools/canvas

6. Cursor Marketplace – biblioteka gotowych pluginów, reguł i serwerów MCP do instalacji jednym kliknięciem
   cursor.com/marketplace