Bramy jakości kodu wspomagane przez AI

Utrzymywanie spójnej jakości kodu w dużych bazach kodu korporacyjnych jest wyzwaniem. Narzędzia wspomagane przez AI transformują zapewnienie jakości z wąskiego gardła w akcelerator, wyłapując problemy wcześnie przy jednoczesnym automatycznym egzekwowaniu standardów.

Architektura bram jakości

Walidacja przed commitowaniem - Lokalne kontrole AI przed przesłaniem kodu
Analiza pull requestów - Automatyczne przeglądy z działaniami zwrotnymi
Ciągłe monitorowanie - Metryki jakości w czasie rzeczywistym i trendy
Weryfikacja po wdrożeniu - Śledzenie jakości kodu produkcyjnego

Trójwarstwowy framework jakości

Warstwa 1: Jakość w trakcie programowania

Linting i formatowanie w czasie rzeczywistym
Sugestie i poprawki inline
Egzekwowanie wzorców podczas kodowania

Warstwa 2: Bramy jakości integracji

Automatyczne przeglądy PR
Kontrole bezpieczeństwa i wydajności
Walidacja zgodności architektonicznej

Warstwa 3: Ciągłe monitorowanie jakości

Dashboardy metryk jakości kodu
Śledzenie długu technicznego
Analiza trendów jakości

Automatyczne standardy kodu

Konfiguracja standardów egzekwowanych przez AI

Cursor
Claude Code

---
description: Standardy jakości kodu korporacyjnego
alwaysApply: true
---
## Styl kodu
- Używaj 4 spacji do wcięć
- Maksymalna długość linii: 100 znaków
- Wszystkie funkcje muszą mieć komentarze JSDoc
- Używaj opisowych nazw zmiennych (min 3 znaki)

## Wzorce architektoniczne
- Przestrzegaj wzorca repository dla dostępu do danych
- Używaj dependency injection dla serwisów
- Implementuj odpowiednie granice błędów
- Wszystkie wywołania API przez scentralizowane moduły

## Standardy wydajności
- Zapytania do bazy danych muszą używać indeksowanych kolumn
- Implementuj paginację dla endpointów list
- Używaj cachowania dla kosztownych operacji
- Unikaj wzorców zapytań N+1

## Wymagania bezpieczeństwa
- Nigdy nie loguj wrażliwych danych
- Waliduj wszystkie dane wejściowe użytkownika
- Używaj sparametryzowanych zapytań
- Implementuj ograniczanie prędkości na API

## Standardy kodowania

### Wytyczne stylu
- Konfiguracja ESLint: .eslintrc.json
- Formatowanie Prettier: .prettierrc
- Włączony tryb strict TypeScript
- Brak typów any bez uzasadnienia

### Bramy jakości
- Minimalne pokrycie kodu: 80%
- Limit złożoności cyklomatycznej: 10
- Brak console.log w kodzie produkcyjnym
- Wszystkie TODO muszą zawierać numery ticketów

### Lista kontrolna przeglądu
- [ ] Testy napisane dla nowej funkcjonalności
- [ ] Dokumentacja zaktualizowana
- [ ] Brak luk bezpieczeństwa
- [ ] Oceniony wpływ na wydajność
- [ ] Zaimplementowana obsługa błędów

Automatyczne egzekwowanie

Konfiguracja hooków dla Claude Code:

{
  "hooks": [
    {
      "matcher": "Edit|Write",
      "hooks": [
        {
          "type": "command",
          "command": "prettier --write \"$CLAUDE_FILE_PATHS\""
        },
        {
          "type": "command",
          "command": "eslint --fix \"$CLAUDE_FILE_PATHS\""
        }
      ]
    },
    {
      "matcher": "Edit",
      "hooks": [
        {
          "type": "command",
          "command": "if [[ \"$CLAUDE_FILE_PATHS\" =~ \\.(ts|tsx)$ ]]; then npx tsc --noEmit \"$CLAUDE_FILE_PATHS\"; fi"
        }
      ]
    }
  ]
}

Integracja lintingu i formatowania

Wsparcie dla wielu języków

JavaScript/TypeScript

ESLint z konfiguracją korporacyjną
Prettier do formatowania
TSLint do sprawdzania typów
Niestandardowe reguły przez pluginy

Python

Ruff do szybkiego lintingu
Black do formatowania
mypy do sprawdzania typów
pylint do jakości kodu

Java

Checkstyle dla standardów
SpotBugs do wykrywania błędów
PMD do analizy kodu
Google Java Format

golangci-lint agregator
gofmt do formatowania
go vet dla podejrzanego kodu
staticcheck dla błędów

Przepływy pracy lintingu wspomaganego przez AI

Pętla auto-naprawy Cursor:

// Gdy błędy ESLint pojawiają się w panelu Problems:
// 1. Cursor wykrywa błędy
// 2. Jeśli włączone "Loops on Errors", AI auto-naprawia
// 3. Poprawki są stosowane bez ręcznej interwencji
// 4. Proces powtarza się do czyszczenia

// Przykład: AI konwertuje to...
const data = response.data as any;

// ...na to z odpowiednim typowaniem:
interface ResponseData {
  id: string;
  status: 'active' | 'inactive';
  metadata: Record<string, unknown>;
}
const data = response.data as ResponseData;

Łańcuch walidacji Claude Code:

# Niestandardowe polecenie slash: /project:validate
Proszę zwalidować obecne zmiany:
1. Uruchom wszystkie lintery i formatery
2. Sprawdź luki bezpieczeństwa
3. Zweryfikuj pokrycie testów
4. Przeanalizuj implikacje wydajnościowe
5. Wygeneruj raport jakości

Dołącz konkretne poprawki dla znalezionych problemów.

Przeglądy kodu wspomagane przez AI

Konfiguracja BugBot (Cursor)

Utwórz .cursor/BUGBOT.md w głównym katalogu projektu:

# Wytyczne przeglądu korporacyjnego

## Krytyczne kontrole bezpieczeństwa
- Brak zahardkodowanych danych uwierzytelniających lub kluczy API
- Walidacja wejścia dla wszystkich danych użytkownika
- Zapobieganie SQL injection przez sparametryzowane zapytania
- Ochrona XSS w renderowanej treści
- Uwierzytelnianie na wszystkich chronionych endpointach

## Względy wydajnościowe
- Wsadowe operacje bazy danych gdzie możliwe
- Implementacja cachowania dla kosztownych obliczeń
- Używanie paginacji dla dużych zbiorów danych
- Monitorowanie wzorców zapytań N+1
- Regularne profilowanie krytycznych ścieżek

## Standardy jakości kodu
- Funkcje poniżej 50 linii
- Klasy przestrzegają pojedynczej odpowiedzialności
- Odpowiednia obsługa błędów z konkretnymi wyjątkami
- Kompleksowe logowanie (bez wrażliwych danych)
- Pokrycie testów dla nowego kodu > 80%

## Powszechne antywzorce
- Mutacje stanu globalnego
- Operacje synchroniczne w kontekstach asynchronicznych
- Brakujące granice błędów w React
- Nieobsłużone odrzucenia promise
- Wycieki pamięci z event listenerów

Automatyczne przepływy pracy przeglądu PR

Skonfiguruj integrację GitHub/GitLab

# Claude Code
claude mcp add github

# Lub dla GitHub App
/install-github-app

Skonfiguruj automatyzację przeglądu

name: AI Code Review
on: [pull_request]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: AI Review
        run: |
          claude --no-interactive \
            "Przejrzyj ten PR pod kątem bezpieczeństwa, wydajności \
             i problemów jakości kodu. Skup się na: \
             $(git diff origin/main...HEAD)"

Włącz powiadomienia zespołu
- Połącz ze Slack/Teams
- Skonfiguruj progi przeglądu
- Skonfiguruj reguły eskalacji

Metryki jakości przeglądu

Śledź te metryki, aby zmierzyć skuteczność przeglądu AI:

Wskaźnik wykrywania błędów: Problemy znalezione przez AI vs. uciekły do produkcji
Czas obrotu przeglądu: Od otwarcia PR do pierwszego feedback AI
Wskaźnik fałszywych pozytywów: Nieprawidłowe problemy zgłoszone przez AI
Akceptacja programistów: Procent sugestii AI wdrożonych

Ciągłe monitorowanie jakości

Dashboardy jakości w czasie rzeczywistym

// Przykład konfiguracji monitorowania jakości
interface QualityMetrics {
  codeComplexity: number;
  testCoverage: number;
  duplicateCodePercentage: number;
  technicalDebtHours: number;
  securityVulnerabilities: number;
}

// Raport jakości generowany przez AI
async function generateQualityReport(): Promise<QualityMetrics> {
  // Claude/Cursor może przeanalizować bazę kodu i wygenerować
  return {
    codeComplexity: 8.2,        // Średnia złożoność cyklomatyczna
    testCoverage: 84.5,         // Procent pokryty
    duplicateCodePercentage: 3.2,
    technicalDebtHours: 120,
    securityVulnerabilities: 0
  };
}

module.exports = {
  rules: {
    coverage: { min: 80, severity: 'error' },
    complexity: { max: 10, severity: 'warning' },
    duplicates: { max: 5, severity: 'warning' },
    vulnerabilities: { max: 0, severity: 'error' },

    // Bramy specyficzne dla AI
    aiReviewPassed: { required: true },
    documentationUpdated: { required: true },
    testsAdded: { required: true }
  },

  enforcement: {
    blockMerge: ['error'],
    requireApproval: ['warning']
  }
};

// Monitoruj jakość kodu w produkcji
import { QualityMonitor } from '@company/quality-tools';

const monitor = new QualityMonitor({
  metrics: ['performance', 'errors', 'security'],
  aiAnalysis: true,
  alertThresholds: {
    errorRate: 0.01,      // 1% wskaźnik błędów
    responseTime: 1000,   // 1 sekunda
    memoryUsage: 0.8      // 80% przydzielonej pamięci
  }
});

// AI analizuje anomalie
monitor.on('anomaly', async (event) => {
  const analysis = await aiAnalyzeAnomaly(event);
  if (analysis.severity === 'critical') {
    await notifyOncall(analysis);
  }
});

Jakość ukierunkowana na wydajność

Analiza wydajności sterowana przez AI

Identyfikacja problemów wydajnościowych:

# Polecenie Claude Code
"Przeanalizuj tę bazę kodu pod kątem wąskich gardeł wydajnościowych.
Skup się na:
- Wydajności zapytań do bazy danych
- Złożoności algorytmów
- Wzorcach użycia pamięci
- Optymalizacji żądań sieciowych
- Możliwościach cachowania

Podaj konkretne przykłady kodu i poprawki."

Egzekwowanie standardów wydajnościowych:

---
description: Wymagania wydajnościowe
globs: ["**/*.ts", "**/*.js"]
---
- Wszystkie zapytania do bazy danych muszą używać indeksowanych kolumn
- Implementuj paginację dla list > 100 elementów
- Używaj memoizacji dla kosztownych obliczeń
- Wsaduj żądania API gdzie możliwe
- Implementuj debouncing dla danych wejściowych użytkownika
- Profiluj i optymalizuj funkcje > 100ms

Integracja testowania obciążenia

// Scenariusze testów obciążenia generowane przez AI
export const loadTestScenarios = {
  userRegistration: {
    vus: 100,              // Użytkownicy wirtualni
    duration: '5m',
    thresholds: {
      http_req_duration: ['p(95) < 500'], // 95% poniżej 500ms
      http_req_failed: ['rate < 0.1'],    // Wskaźnik błędów mniej niż 10%
    }
  },

  apiEndpoints: {
    vus: 200,
    duration: '10m',
    scenarios: {
      constant_load: {
        executor: 'constant-vus',
        vus: 50,
        duration: '5m',
      },
      spike_test: {
        executor: 'ramping-vus',
        stages: [
          { duration: '2m', target: 100 },
          { duration: '1m', target: 200 },
          { duration: '2m', target: 100 },
        ],
      },
    }
  }
};

Jakość z naciskiem na bezpieczeństwo

Automatyczne skanowanie bezpieczeństwa

Skonfiguruj reguły bezpieczeństwa

module.exports = {
  rules: {
    'no-eval': 'error',
    'no-implied-eval': 'error',
    'no-hardcoded-secrets': 'error',
    'validate-inputs': 'error',
    'parameterized-queries': 'error',
    'secure-random': 'warning',
    'crypto-strong': 'error'
  }
};

Zaimplementuj przeglądy bezpieczeństwa AI

# Niestandardowe polecenie audytu bezpieczeństwa
/project:security-audit

# Kompleksowa kontrola obejmująca:
# - Luki OWASP Top 10
# - Luki zależności
# - Ryzyko wstrzyknięcia kodu
# - Słabości uwierzytelniania
# - Ryzyko ujawnienia danych

Skonfiguruj ciągłe monitorowanie
- Skanowanie zależności przy każdym buildzie
- Analiza bezpieczeństwa kodu w PR
- Monitorowanie bezpieczeństwa runtime
- Alerty luk bezpieczeństwa

Praktyki jakości zespołowej

Onboarding standardów jakości

Lista kontrolna nowego programisty:

Przeczytaj standardy kodowania zespołu w rules/
Zainstaluj wymagane lintery i formatery
Skonfiguruj pomoc AI z regułami zespołu
Przejrzyj przykładowe PR z feedback AI
Ukończ moduł szkoleniowy jakości

Dzielenie się wiedzą

Biblioteka wzorców jakości:

// Dziel się udanymi wzorcami w zespole
export const QualityPatterns = {
  errorHandling: {
    description: "Spójny wzorzec obsługi błędów",
    example: `
      try {
        const result = await riskyOperation();
        return { success: true, data: result };
      } catch (error) {
        logger.error('Operacja nie powiodła się', { error, context });
        return { success: false, error: error.message };
      }
    `,
    aiPrompt: "Zastosuj ten wzorzec obsługi błędów konsekwentnie"
  },

  performantQueries: {
    description: "Zoptymalizowane wzorce zapytań do bazy danych",
    example: "Używaj batch loading, indeksów i projekcji",
    aiPrompt: "Optymalizuj zapytania do bazy danych używając naszych wzorców"
  }
};

Ciągłe doskonalenie

Śledź i poprawiaj metryki jakości w czasie:

graph LR A[Mierz] --> B[Analizuj] B --> C[Poprawiaj] C --> D[Implementuj] D --> A A --- E[Wskaźnik błędów] A --- F[Czas przeglądu] A --- G[Pokrycie kodu] A --- H[Dług techniczny]

Podsumowanie najlepszych praktyk

🎯 Zacznij od małego

Rozpocznij od podstawowego lintingu i formatowania, potem stopniowo dodawaj bardziej wyrafinowane bramy jakości.

📊 Mierz wpływ

Śledź metryki przed i po wdrożeniu narzędzi jakości AI, aby wykazać wartość.

🤝 Zespołowe przyjęcie

Włącz zespół w definiowanie standardów i konfigurowanie zachowania AI dla lepszej adopcji.

🔄 Iteruj często

Regularnie przeglądaj i aktualizuj reguły jakości na podstawie feedback zespołu i ewolucji projektu.

Powiązane zasoby

Testowanie wydajności - Strategie testowania obciążenia i stresu
Zgodność bezpieczeństwa - Rozwój ukierunkowany na bezpieczeństwo
Potoki CI/CD - Integracja bram jakości w potokach
Doskonałość testowania - Kompleksowe strategie testowania