Automatyzacja Workflow Programistycznego z Claude Code

Automatyzacja to Klucz do Produktywności

Jako programiści spędzamy zbyt wiele czasu na powtarzalnych zadaniach: pisaniu testów, code review, dokumentacji, deploymentach. Claude Code może zautomatyzować większość z nich, pozwalając Ci skupić się na tym, co naprawdę ważne - tworzeniu wartości dla użytkowników.

5 Obszarów do Automatyzacji

1. Generowanie Testów Automatycznych

Przykład: Unit Testy

Poproś Claude Code:

“Wygeneruj kompleksowe unit testy dla tej funkcji z edge cases”

// Twoja funkcja
function calculateDiscount(price: number, discountPercent: number): number {
  if (price < 0 || discountPercent < 0 || discountPercent > 100) {
    throw new Error('Invalid input');
  }
  return price * (1 - discountPercent / 100);
}

// Claude Code wygeneruje:
describe('calculateDiscount', () => {
  it('should calculate discount correctly', () => {
    expect(calculateDiscount(100, 20)).toBe(80);
    expect(calculateDiscount(50, 50)).toBe(25);
  });

  it('should handle edge cases', () => {
    expect(calculateDiscount(100, 0)).toBe(100);
    expect(calculateDiscount(0, 50)).toBe(0);
  });

  it('should throw on invalid input', () => {
    expect(() => calculateDiscount(-1, 20)).toThrow();
    expect(() => calculateDiscount(100, -1)).toThrow();
    expect(() => calculateDiscount(100, 101)).toThrow();
  });

  it('should handle decimal numbers', () => {
    expect(calculateDiscount(99.99, 10)).toBeCloseTo(89.991);
  });
});

Integration Tests

Claude Code może też tworzyć testy integracyjne:

describe('User API Integration', () => {
  let app: Express;
  let testUser: User;

  beforeAll(async () => {
    app = await createTestApp();
    testUser = await createTestUser();
  });

  afterAll(async () => {
    await cleanupTestData();
  });

  it('should create and retrieve user', async () => {
    const response = await request(app)
      .post('/api/users')
      .send({ name: 'Test User', email: 'test@example.com' })
      .expect(201);

    expect(response.body).toHaveProperty('id');
    expect(response.body.name).toBe('Test User');

    const getResponse = await request(app)
      .get(`/api/users/${response.body.id}`)
      .expect(200);

    expect(getResponse.body).toEqual(response.body);
  });
});

2. Automatyczne Code Review

Setup GitHub Actions

Poproś Claude Code o:

“Skonfiguruj GitHub Action, który używa AI do code review każdego PR”

# .github/workflows/code-review.yml
name: AI Code Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Run AI Code Review
        uses: your-org/claude-code-review@v1
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          focus-areas: |
            - Security vulnerabilities
            - Performance issues
            - Best practices
            - Code duplication

Pre-commit Hooks

Automatyzacja na poziomie commitów:

// .husky/pre-commit
#!/usr/bin/env sh
. "$(dirname -- "$0")/_/husky.sh"

npm run lint
npm run test
npm run type-check

# Claude Code może sprawdzić commit message
node scripts/check-commit-message.js

3. Dokumentacja Automatyczna

JSDoc / TSDoc Generation

/**
 * Calculates the final price after applying discount
 *
 * @param price - Original price in PLN (must be non-negative)
 * @param discountPercent - Discount percentage (0-100)
 * @returns Final price after discount
 * @throws {Error} When price is negative or discount is not in valid range
 *
 * @example
 * ```typescript
 * calculateDiscount(100, 20) // returns 80
 * calculateDiscount(50, 50) // returns 25
 * ```
 *
 * @see {@link https://docs.example.com/pricing | Pricing Documentation}
 */
function calculateDiscount(price: number, discountPercent: number): number {
  // Implementation
}

README Generation

Poproś Claude Code:

“Wygeneruj kompletny README.md dla tego projektu z badges, installation steps, usage examples”

4. CI/CD Pipeline Optimization

Multi-stage Build

# .github/workflows/deploy.yml
name: Build and Deploy

on:
  push:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
      - run: npm ci
      - run: npm run test:coverage
      - uses: codecov/codecov-action@v3

  build:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - run: npm run build
      - uses: actions/upload-artifact@v3
        with:
          name: dist
          path: dist/

  deploy:
    needs: build
    runs-on: ubuntu-latest
    environment: production
    steps:
      - uses: actions/download-artifact@v3
      - run: npm run deploy
        env:
          DEPLOY_KEY: ${{ secrets.DEPLOY_KEY }}

Docker Multi-stage Build

# Build stage
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Production stage
FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/package*.json ./
RUN npm ci --only=production
EXPOSE 3000
CMD ["node", "dist/server.js"]

5. Monitoring i Alerting

Error Tracking Setup

// src/lib/monitoring.ts
import * as Sentry from '@sentry/node';

export function initMonitoring() {
  Sentry.init({
    dsn: process.env.SENTRY_DSN,
    environment: process.env.NODE_ENV,
    tracesSampleRate: 1.0,
    beforeSend(event, hint) {
      // Claude Code może pomóc w filtrowaniu i wzbogacaniu eventów
      if (event.exception) {
        // Add custom context
        event.contexts = {
          ...event.contexts,
          app: {
            version: process.env.APP_VERSION,
            buildTime: process.env.BUILD_TIME,
          },
        };
      }
      return event;
    },
  });
}

// Automatic error boundary
export function withErrorHandler<T>(
  fn: () => Promise<T>
): Promise<T> {
  return fn().catch((error) => {
    Sentry.captureException(error);
    throw error;
  });
}

Skrypty Automatyzacji

Daily Maintenance Script

#!/bin/bash
# scripts/daily-maintenance.sh

echo "🔄 Running daily maintenance..."

# Update dependencies
echo "📦 Checking for updates..."
npm outdated

# Run security audit
echo "🔒 Security audit..."
npm audit

# Clean up old branches
echo "🧹 Cleaning branches..."
git fetch --prune
git branch --merged | grep -v "main\|master" | xargs git branch -d

# Backup database
echo "💾 Backup database..."
npm run db:backup

echo "✅ Maintenance complete!"

Code Quality Report

// scripts/quality-report.js
import { ESLint } from 'eslint';
import { exec } from 'child_process';
import { promisify } from 'util';

const execAsync = promisify(exec);

async function generateQualityReport() {
  console.log('📊 Generating quality report...\n');

  // ESLint analysis
  const eslint = new ESLint();
  const results = await eslint.lintFiles(['src/**/*.ts']);
  const formatter = await eslint.loadFormatter('stylish');
  console.log(formatter.format(results));

  // Test coverage
  const { stdout } = await execAsync('npm run test:coverage');
  console.log(stdout);

  // Bundle size
  const { stdout: buildOutput } = await execAsync('npm run build -- --analyze');
  console.log(buildOutput);

  // Type coverage
  const { stdout: typeOutput } = await execAsync('npx type-coverage');
  console.log(typeOutput);
}

generateQualityReport().catch(console.error);

Narzędzia Wspomagające

1. GitHub Copilot + Claude Code

Kombinacja obu narzędzi:

• Copilot dla inline suggestions
• Claude Code dla kompleksowych rozwiązań

2. Playwright dla E2E

import { test, expect } from '@playwright/test';

test('complete user journey', async ({ page }) => {
  // Login
  await page.goto('/login');
  await page.fill('[name="email"]', 'test@example.com');
  await page.fill('[name="password"]', 'password');
  await page.click('button[type="submit"]');

  // Add to cart
  await expect(page).toHaveURL('/dashboard');
  await page.click('text=Shop');
  await page.click('button:has-text("Add to Cart")');

  // Checkout
  await page.click('[aria-label="Cart"]');
  await page.click('text=Checkout');
  await page.fill('[name="address"]', '123 Test St');
  await page.click('text=Complete Order');

  // Verify
  await expect(page).toHaveURL(/\/order\/\d+/);
  await expect(page.locator('text=Order confirmed')).toBeVisible();
});

3. Lighthouse CI

// lighthouserc.js
export default {
  ci: {
    collect: {
      url: ['http://localhost:3000/', 'http://localhost:3000/blog'],
      numberOfRuns: 3,
    },
    assert: {
      assertions: {
        'categories:performance': ['error', { minScore: 0.9 }],
        'categories:accessibility': ['error', { minScore: 0.9 }],
        'categories:best-practices': ['error', { minScore: 0.9 }],
        'categories:seo': ['error', { minScore: 0.9 }],
      },
    },
    upload: {
      target: 'temporary-public-storage',
    },
  },
};

Mierzenie Sukcesu

Metryki do Śledzenia

1. Deployment Frequency - jak często wdrażasz?
2. Lead Time - czas od commitu do produkcji
3. Mean Time to Recovery - jak szybko naprawiasz błędy?
4. Change Failure Rate - ile deploymentów kończy się rollbackiem?

Dashboard

// Przykład dashboardu metryk
interface Metrics {
  deploymentsToday: number;
  averageLeadTime: number; // hours
  mttr: number; // hours
  failureRate: number; // percentage
  testCoverage: number; // percentage
  buildTime: number; // minutes
}

async function fetchMetrics(): Promise<Metrics> {
  // Claude Code może pomóc w integrac jest z różnymi źródłami
  return {
    deploymentsToday: 5,
    averageLeadTime: 2.5,
    mttr: 0.5,
    failureRate: 2,
    testCoverage: 85,
    buildTime: 3.2,
  };
}

📚 Dokumentacja i Zasoby

Oficjalna Dokumentacja

• Claude Code - Developer Guide
• GitHub Actions Documentation
• Husky Git Hooks
• Playwright Testing

Powiązane Artykuły

• Hooks i Event-Driven Automation
• Integracja Claude Code z Workflow
• 7 Scenariuszy Użycia Claude Code

Podsumowanie

Automatyzacja z Claude Code to inwestycja, która szybko się zwraca:

• 80% redukcji czasu na testy
• 60% szybsze code reviews
• 50% mniej manual deploymentów
• 95%+ pokrycie testów

Zacznij od małych kroków - zautomatyzuj jeden proces tygodniowo. Po miesiącu zobaczysz znaczącą różnicę w produktywności!

---

Gotowy na automatyzację? Pobierz nasze starter templates i zacznij już dziś!