Zaawansowane techniki: Wskazówki 91-105

Te techniki na poziomie eksperckim wykorzystują Cursor do granic możliwości, umożliwiając przepływy pracy automatyzacji, niestandardowe integracje i praktyki programistyczne klasy korporacyjnej. Opanuj je, aby stać się prawdziwym mistrzem Cursor.

Optymalizacja modeli

Wskazówka 91: Strategiczna matryca wyboru modelu

Wybieraj modele na podstawie złożoności zadania i wymagań:

Wybór na podstawie zadania

// Proste uzupełnianie kodu
Model: cursor-small
Przypadek użycia: Uzupełnienia Tab, proste edycje
Szybkość: poniżej 100ms
Koszt: Najniższy

// Standardowe programowanie
Model: claude-4-sonnet
Przypadek użycia: Większość zadań kodowania, refaktoryzacja
Szybkość: 1-3s
Koszt: Umiarkowany

// Złożone rozumowanie
Model: claude-4.1-opus
Przypadek użycia: Architektura, złożone algorytmy
Szybkość: 3-5s
Koszt: 5x Sonnet

// Głęboka analiza
Model: o3-mini
Przypadek użycia: Debugowanie złożonych problemów
Szybkość: 5-10s
Koszt: Premium

Wybór na podstawie kontekstu

{
  "cursor.modelSelection.rules": [
    {
      "filePattern": "**/*.test.{ts,js}",
      "preferredModel": "claude-4-sonnet",
      "reason": "Generowanie testów"
    },
    {
      "filePattern": "**/architecture/**",
      "preferredModel": "claude-4.1-opus",
      "reason": "Złożony design"
    },
    {
      "taskPattern": "debug|investigate",
      "preferredModel": "o3-mini",
      "reason": "Głębokie rozumowanie"
    }
  ]
}

Wskazówka 92: Optymalizuj użycie tokenów z strategiami kontekstu

Maksymalizuj efektywność przy jednoczesnym minimalizowaniu kosztów:

// Techniki kompresji kontekstu
// 1. Używaj plików podsumowań
// Zamiast: @entire-module
// Utwórz: module-summary.md z kluczowymi punktami

// 2. Progresywne ładowanie kontekstu
'Najpierw przeanalizuj strukturę wysokiego poziomu @src/index.ts' /
  // Następnie: "Teraz spójrz na konkretną implementację processData"

  // 3. Selektywne włączanie plików
  // Zamiast: @folder:src
  // Użyj: @src/core/**.ts @src/api/routes.ts

  // 4. Regularnie czyść kontekst
  clear -
  context;
// Lub rozpocznij nowy czat dla niepowiązanych zadań

Wskazówka kosztowa Monitoruj użycie tokenów: Ctrl+Shift+J → zakładka Usage

Wskazówka 93: Skonfiguruj zapasowe modele

Zapewnij niezawodność z łańcuchami zapasowymi:

{
  "cursor.models.fallbackChain": [
    {
      "primary": "claude-4.1-opus",
      "fallbacks": ["claude-4-sonnet", "gpt-4"]
    },
    {
      "primary": "o3",
      "fallbacks": ["claude-4.1-opus", "claude-4-sonnet"]
    }
  ],
  "cursor.models.autoSwitch": {
    "enabled": true,
    "onRateLimit": true,
    "onError": true
  }
}

Niestandardowe programowanie MCP

Wskazówka 94: Buduj niestandardowe serwery MCP

Utwórz specjalistyczne narzędzia dla swojego przepływu pracy:

1. Skonfiguruj projekt MCP

   mkdir my-mcp-server
   cd my-mcp-server
   npm init -y
   npm install @modelcontextprotocol/sdk

2. Utwórz implementację serwera

   index.ts

   import { Server } from '@modelcontextprotocol/sdk/server/index.js';
   import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
   
   const server = new Server({
     name: 'my-custom-mcp',
     version: '1.0.0',
   });
   
   // Dodaj niestandardowe narzędzia
   server.setRequestHandler('tools/list', async () => ({
     tools: [
       {
         name: 'custom_analysis',
         description: 'Analizuj bazę kodu pod kątem wzorców',
         inputSchema: {
           type: 'object',
           properties: {
             pattern: { type: 'string' },
           },
         },
       },
     ],
   }));
   
   // Obsługuj wykonywanie narzędzi
   server.setRequestHandler('tools/call', async (request) => {
     // Implementacja
   });
   
   const transport = new StdioServerTransport();
   await server.connect(transport);

3. Zarejestruj w Cursor

   {
     "mcpServers": {
       "my-custom-mcp": {
         "command": "node",
         "args": ["/path/to/my-mcp-server/index.js"]
       }
     }
   }

Wskazówka 95: Integruj zewnętrzne usługi przez MCP

Połącz Cursor z twoją infrastrukturą:

Baza danych MCP

// Zapytaj swoją bazę danych bezpośrednio
"Pokaż wzrost użytkowników z ostatnich 30 dni z naszej produkcyjnej bazy danych"

Monitoring MCP

// Dostęp do metryk i logów
"Przeanalizuj wzorce błędów w logach DataDog z ostatniej godziny"

CI/CD MCP

// Wyzwalaj wdrożenia
"Wdróż gałąź funkcji na staging po przejściu testów"

Wskazówka 96: Łącz serwery MCP w łańcuchy

Twórz potężne przepływy pracy łącząc MCP:

// Przykład: Implementacja funkcji full stack
"Używając @figma-mcp pobierz nowy design dashboard,
następnie zaimplementuj komponenty frontend,
użyj @database-mcp do utworzenia wymaganych tabel,
i @linear-mcp do aktualizacji statusu zadania"

// AI orkiestruje przez wiele narzędzi:
// 1. Pobiera design z Figma
// 2. Generuje komponenty React
// 3. Tworzy migracje bazy danych
// 4. Aktualizuje zarządzanie projektem

Zaawansowany system zasad

Wskazówka 97: Utwórz dynamiczne generowanie zasad

Używaj AI do utrzymania i rozwijania zasad:

// Samodoskonalące się zasady
"Przeanalizuj ostatnie 50 rozmów czatu i zidentyfikuj
wspólne wzorce, które powinny stać się zasadami projektowymi"

// Zasady świadome kontekstu
"Na podstawie analizy bazy kodu @src, wygeneruj zasady dla:
- Używanych konwencji nazewnictwa
- Wzorców obsługi błędów
- Strategii testowania
- Decyzji architektonicznych"

// Uczenie zespołowe
"Przejrzyj ostatnie pull requesty i wyodrębnij standardy
kodowania, które powinny zostać dodane do naszych zasad"

Wskazówka 98: Implementuj zasady warunkowe

Twórz wyrafinowaną logikę zasad:

.cursor/rules/conditional-rules.yaml

rules:
  - name: 'Programowanie API'
    condition:
      filePattern: '**/api/**'
      contains: ['express', 'fastify']
    content: |
      Zawsze dołączaj:
      - Walidację requestów używając Joi lub Zod
      - Standaryzowane odpowiedzi błędów
      - Dokumentację OpenAPI

  - name: 'Komponenty React'
    condition:
      filePattern: '**/*.tsx'
      hasImport: 'react'
    content: |
      Przestrzegaj tych wzorców:
      - Tylko komponenty funkcyjne
      - Niestandardowe hooki dla logiki
      - Interfejsy props z JSDoc

  - name: 'Operacje bazy danych'
    condition:
      anyOf:
        - contains: ['prisma', 'sequelize']
        - filePattern: '**/repository/**'
    content: |
      Upewnij się, że wszystkie zapytania:
      - Używają zapytań sparametryzowanych
      - Zawierają obsługę transakcji
      - Mają właściwą obsługę błędów

Wskazówka 99: Kompozycja i dziedziczenie zasad

Buduj złożone hierarchie zasad:

.cursor/rules/base/security.md

// Podstawowe zasady, które inne rozszerzają
"Wszystkie endpointy API muszą walidować uwierzytelnianie"

// Specyficzne zasady, które dziedziczą
// .cursor/rules/api/public-endpoints.md
"@inherit base/security
Wyjątek: Publiczne endpointy wymienione w config/public-routes.json
Dodatkowo: Ograniczenie rate limit wszystkich publicznych endpointów do 100 req/min"

// Złożone zasady
// .cursor/rules/feature/payment.md
"@compose [base/security, api/validation, patterns/repository]
Dodatkowe zasady specyficzne dla płatności:
- Wzorce zgodności PCI
- Logowanie audytu dla wszystkich transakcji
- Wymagane klucze idempotentności"

Przepływy pracy automatyzacji

Wskazówka 100: Utwórz automatyczne przeglądy kodu

Używaj trybu Agent Cursor do kompleksowych przeglądów kodu:

# Przykład pre-commit hook, który otwiera Cursor do przeglądu
#!/bin/bash

# Pobierz staged changes
git diff --cached > staged_changes.diff

# Otwórz Cursor z plikiem zmian
cursor staged_changes.diff

# W Cursor, użyj trybu Agent (Ctrl+I) z tym promptem:
# "Przejrzyj zmiany w tym pliku diff pod kątem:
# - Luk bezpieczeństwa
# - Problemów z wydajnością
# - Naruszeń stylu kodu
# - Brakujących testów
# - Potrzeb dokumentacyjnych
#
# Użyj @Git do zobaczenia ostatnich zmian i @Lint Errors do sprawdzenia problemów"

Alternatywny przepływ pracy używający wbudowanych funkcji Cursor:

1. Otwórz tryb Agent z Ctrl+I
2. Odwołaj się do zmian z @Git lub @Recent Changes
3. Zapytaj o konkretne kryteria przeglądu
4. Użyj Apply do implementacji sugerowanych poprawek

Wskazówka 101: Implementuj ciągłą refaktoryzację

Skonfiguruj automatyczne cykle ulepszania:

Codzienna refaktoryzacja

// Zaplanowane zadanie dla ulepszania kodu
"Codziennie o 18:00:
1. Znajdź najbardziej złożoną funkcję (złożoność cyklomatyczna)
2. Refaktoryzuj ją, aby zmniejszyć złożoność
3. Upewnij się, że wszystkie testy nadal przechodzą
4. Utwórz PR ze zmianami"

Aktualizacje zależności

// Automatyczne zarządzanie zależnościami
"Zadanie tygodniowe:
1. Sprawdź przestarzałe zależności
2. Aktualizuj zmiany nieprzerywające
3. Uruchom pełny zestaw testów
4. Aktualizuj dotknięty kod dla deprecacji
5. Utwórz PR z changelog"

Wskazówka 102: Buduj niestandardowe pipeline’y programistyczne

Orkiestruj złożone przepływy pracy programistyczne:

graph LR A[Zadanie Jira] --> B[Planowanie AI] B --> C[Implementacja] C --> D[Auto testy] D --> E[Przegląd kodu] E --> F[Wdrożenie] F --> G[Monitoring]

Implementacja:

// Automatyzacja przepływu pracy Cursor
const workflow = {
  trigger: 'jira:ticket:assigned',
  steps: [
    {
      action: 'cursor:agent',
      prompt: 'Utwórz plan implementacji z opisu zadania',
    },
    {
      action: 'cursor:agent',
      prompt: 'Zaimplementuj funkcję zgodnie z planem',
    },
    {
      action: 'cursor:agent',
      prompt: 'Napisz kompleksowe testy',
    },
    {
      action: 'git:create-pr',
      reviewers: ['ai-bot', 'team-lead'],
    },
  ],
};

Integracja korporacyjna

Wskazówka 103: Implementuj skanowanie bezpieczeństwa

Integruj narzędzia bezpieczeństwa z Cursor:

// Integracja MCP skupiona na bezpieczeństwie
"Przeskanuj bazę kodu pod kątem problemów bezpieczeństwa:
@security-mcp uruchom skan SAST na @src
@dependency-mcp sprawdź podatne pakiety
@secrets-mcp przeskanuj pod kątem odsłoniętych credentials"

// Przepływ pracy naprawy
"Dla każdego znalezionego problemu bezpieczeństwa:
1. Oceń dotkliwość i możliwość wykorzystania
2. Wygeneruj poprawkę zgodnie z wytycznymi OWASP
3. Dodaj testy, aby zapobiec regresji
4. Udokumentuj w logu bezpieczeństwa"

Wskazówka 104: Skonfiguruj automatyzację zgodności

Zapewnij zgodność regulacyjną:

Zgodność GDPR

"Audyt obsługi danych pod kątem GDPR:
- Znajdź całe przetwarzanie danych osobowych
- Sprawdź mechanizmy zgody
- Sprawdź polityki retencji danych
- Wygeneruj raport zgodności"

Dostępność

"Sprawdzenie zgodności WCAG 2.1 AA:
- Przeskanuj wszystkie komponenty UI
- Napraw problemy z kontrastem kolorów
- Dodaj brakujące etykiety ARIA
- Wygeneruj raport dostępności"

Wskazówka 105: Twórz grafy wiedzy

Buduj dokumentację wzbogaconą AI:

// Wygeneruj kompleksową bazę wiedzy
"Utwórz graf wiedzy naszego systemu:
1. Mapuj wszystkie usługi i ich relacje
2. Udokumentuj przepływy danych między komponentami
3. Zidentyfikuj punkty integracji
4. Utwórz interaktywną wizualizację
5. Wygeneruj dokumentację markdown"

// Auto-aktualizacja dokumentacji
"Zadanie codzienne:
- Wykryj zmiany w kodzie od ostatniego uruchomienia
- Aktualizuj dotknięną dokumentację
- Oznacz przestarzałe przykłady
- Wygeneruj changelog"

Monitoring wydajności

Zaawansowane śledzenie metryk

{
  "cursor.telemetry.custom": {
    "trackProductivity": true,
    "metrics": ["linesOfCodeGenerated", "refactoringTime", "bugFixTime", "testCoverage"],
    "reportInterval": "weekly"
  }
}

Pomiar ROI

Śledź wpływ asystenta AI:

// Metryki produktywności
const metrics = {
  beforeCursor: {
    featuresPerWeek: 2,
    bugsPerFeature: 3,
    hoursPerFeature: 20,
  },
  withCursor: {
    featuresPerWeek: 5,
    bugsPerFeature: 1,
    hoursPerFeature: 8,
  },
  improvement: {
    productivity: '150%',
    quality: '66% mniej błędów',
    timeReduction: '60%',
  },
};

Wzorce integracji

Automatyzacja przepływu pracy z Cursor

Automatyzacja zapisu pliku:

1. Używaj wbudowanego systemu zadań VS Code z Cursor
2. Skonfiguruj .vscode/tasks.json dla automatycznych uruchomień testów:

.vscode/tasks.json

{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "Uruchom testy przy zapisie",
      "type": "shell",
      "command": "npm test ${file}",
      "runOptions": {
        "runOn": "folderOpen"
      },
      "problemMatcher": ["$tsc"]
    }
  ]
}

Przepływ pracy przeglądu PR:

1. Otwórz diff PR w Cursor
2. Użyj trybu Agent (Ctrl+I) z promptami takimi jak:
   • “Przejrzyj @Files pod kątem zmian przełomowych”
   • “Sprawdź @Recent Changes względem naszego kontraktu API”
   • “Przeanalizuj @Git commits pod kątem problemów bezpieczeństwa”
3. Użyj @Docs do odniesienia się do wytycznych zespołu podczas przeglądu

---

Następne kroki

Opanowałeś zaawansowane techniki Cursor. Ukończ swoją podróż z Współpraca zespołowa, aby skalować te praktyki w całym zespole programistycznym.