AI w pracy PHP developera – Copilot, Claude, Ollama, gdzie pomaga a gdzie zawodzi

Od roku intensywnie używam narzędzi AI w codziennej pracy z PHP i Magento 2. GitHub Copilot, Claude, ChatGPT, lokalne modele przez Ollama – przetestowałem sporo. Czas na uczciwe podsumowanie: gdzie AI realnie oszczędza czas, gdzie zawodzi i jak nie wpaść w pułapkę ślepego ufania generowanemu kodowi.

GitHub Copilot – codzienne użycie w PHPStorm

Copilot jest najlepszy tam gdzie piszesz powtarzalny, przewidywalny kod. Gdzie naprawdę oszczędza czas:

<?php

declare(strict_types=1);

// Copilot świetnie radzi sobie z boilerplatem
// Wpisujesz nazwę metody i type hint, reszta pojawia się automagicznie

// Przykład 1 - getter/setter pattern
class ProductDto
{
    // Copilot sugeruje cały konstruktor gdy widzisz właściwości
    public function __construct(
        private readonly int $id,
        private readonly string $sku,
        private readonly float $price,
        private readonly bool $isActive
    ) {}

    // Po napisaniu "public function get" - Copilot sugeruje resztę
    public function getId(): int     { return $this->id; }
    public function getSku(): string { return $this->sku; }
    // ...itd.
}

// Przykład 2 - testy PHPUnit (tu Copilot jest szczególnie pomocny)
class DiscountCalculatorTest extends TestCase
{
    // Napisz nazwę testu - Copilot sugeruje asercje
    public function testCalculatesDiscountCorrectly(): void
    {
        // Copilot sugeruje: $calculator = new DiscountCalculator();
        // i dopasowane wywołania na podstawie nazwy testu
    }
}

Copilot zawodzi przy:

• Złożonej logice biznesowej Magento 2 – nie zna Twojego di.xml, nie wie jakie masz moduły
• Generowaniu kodu który wymaga kontekstu całego projektu
• Naprawianiu subtelnych bugów w istniejącym kodzie

Claude / ChatGPT – do zadań konwersacyjnych

Modele konwersacyjne lepiej sprawdzają się przy zadaniach wymagających wyjaśnienia i kontekstu:

<?php

// Co faktycznie działa dobrze:

// 1. Refaktoring z wyjaśnieniem
// "Mam tę metodę, jak ją przepisać żeby nie naruszała SRP?"

// 2. Wyjaśnienie nieznanego kodu
// "Co robi ta regex? /^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14})$/"

// 3. Generowanie danych testowych
// "Wygeneruj 20 przykładowych zamówień jako tablicę PHP dla testów jednostkowych"

// 4. Pisanie dokumentacji
// "Napisz PHPDoc dla tej metody"

/**
 * Calculates the total price including tax for an order.
 *
 * @param OrderItemInterface[] $items   Array of order items to calculate
 * @param float                $taxRate Tax rate as decimal (0.23 for 23%)
 *
 * @throws \InvalidArgumentException When tax rate is outside [0, 1] range
 *
 * @return float Total price including tax, rounded to 2 decimal places
 */
public function calculateTotal(array $items, float $taxRate): float
{
    if ($taxRate < 0 || $taxRate > 1) {
        throw new \InvalidArgumentException('Tax rate must be between 0 and 1');
    }

    $subtotal = array_sum(array_map(
        fn(OrderItemInterface $item) => $item->getPrice() * $item->getQty(),
        $items
    ));

    return round($subtotal * (1 + $taxRate), 2);
}

Ollama – lokalne modele LLM

Ollama pozwala uruchamiać modele AI lokalnie – bez wysyłania kodu do zewnętrznych serwisów. Przydatne gdy pracujesz z kodem który nie powinien opuszczać organizacji:

# Instalacja Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Pobranie modelu (codellama dobry do PHP)
ollama pull codellama:13b

# Uruchomienie przez API
ollama serve # nasłuchuje na localhost:11434

# Zapytanie przez curl
curl http://localhost:11434/api/generate -d '{
    "model": "codellama:13b",
    "prompt": "Write a PHP function that validates an email address",
    "stream": false
}'

<?php

declare(strict_types=1);

// Integracja Ollama w własnych skryptach PHP
class OllamaClient
{
    public function __construct(
        private string $baseUrl = 'http://localhost:11434',
        private string $model   = 'codellama:13b'
    ) {}

    public function generate(string $prompt): string
    {
        $response = file_get_contents($this->baseUrl . '/api/generate', false,
            stream_context_create(['http' => [
                'method'  => 'POST',
                'header'  => 'Content-Type: application/json',
                'content' => json_encode([
                    'model'  => $this->model,
                    'prompt' => $prompt,
                    'stream' => false,
                ]),
            ]])
        );

        $data = json_decode($response, true, 512, JSON_THROW_ON_ERROR);
        return $data['response'] ?? '';
    }

    public function reviewCode(string $phpCode): string
    {
        $prompt = "Review this PHP code for potential issues, bugs, and improvements. 
                   Focus on: type safety, error handling, performance, and best practices.
                   Code:\n\n{$phpCode}";

        return $this->generate($prompt);
    }
}

// Użycie w skrypcie CI/CD - automatyczne code review
$ollama = new OllamaClient();
$code   = file_get_contents('src/Model/OrderService.php');
$review = $ollama->reviewCode($code);
echo $review;

AI do pisania testów – największa wartość

Generowanie testów jednostkowych to obszar gdzie AI daje największy zwrot z inwestycji. Pisanie testów jest żmudne i powtarzalne – idealny przypadek użycia:

<?php

// Dajesz AI kod klasy i prosisz o testy
// Prompt: "Write PHPUnit tests for this class covering happy path and edge cases"

// Klasa wejściowa
class PriceCalculator
{
    public function calculate(float $price, float $taxRate, ?float $discount = null): float
    {
        if ($price < 0)    throw new \InvalidArgumentException('Price cannot be negative');
        if ($taxRate < 0)  throw new \InvalidArgumentException('Tax rate cannot be negative');

        $discounted = $discount ? $price * (1 - $discount / 100) : $price;
        return round($discounted * (1 + $taxRate), 2);
    }
}

// AI generuje (i to działa naprawdę dobrze):
class PriceCalculatorTest extends TestCase
{
    private PriceCalculator $calculator;

    protected function setUp(): void
    {
        $this->calculator = new PriceCalculator();
    }

    public function testCalculatesPriceWithTax(): void
    {
        $result = $this->calculator->calculate(100.0, 0.23);
        $this->assertSame(123.0, $result);
    }

    public function testCalculatesWithDiscount(): void
    {
        $result = $this->calculator->calculate(100.0, 0.23, 10.0);
        $this->assertSame(110.7, $result); // 90 * 1.23 = 110.70
    }

    public function testThrowsOnNegativePrice(): void
    {
        $this->expectException(\InvalidArgumentException::class);
        $this->calculator->calculate(-10.0, 0.23);
    }

    /** @dataProvider priceProvider */
    public function testVariousPrices(float $price, float $tax, float $expected): void
    {
        $this->assertSame($expected, $this->calculator->calculate($price, $tax));
    }

    public static function priceProvider(): array
    {
        return [
            'zero price'    => [0.0,   0.23, 0.0],
            'zero tax'      => [100.0, 0.0,  100.0],
            'fractional'    => [9.99,  0.23, 12.29],
        ];
    }
}

Gdzie AI nie zastąpi doświadczenia

Po roku intensywnego użytkowania mam klarowny obraz granic:

• Architektura systemu – AI sugeruje wzorce ale nie zna Twoich ograniczeń biznesowych, długu technicznego i kontekstu organizacyjnego
• Debug złożonych problemów Magento – gdy plugin wchodzi w konflikt z pluginem a DI zachowuje się dziwnie, doświadczenie > AI
• Decyzje dotyczące bezpieczeństwa – AI może przeoczyć subtelne podatności które wymagają głębokiego rozumienia przepływu danych
• Optymalizacja wydajności – profiler i znajomość stosu dają więcej niż sugestia AI która nie zna Twojego load profile

Mój praktyczny workflow z AI

Podsumowanie

AI to narzędzie które doświadczonemu developerowi oszczędza czas na mechanicznych zadaniach. Nie zastępuje rozumienia architektury, znajomości platformy i umiejętności debugowania. Największy błąd to ślepe kopiowanie wygenerowanego kodu bez jego zrozumienia – AI halucynuje, szczególnie przy specyficznych API jak Magento 2 Service Contracts. Traktuj AI jak szybkiego juniora który generuje pierwszy draft, a Ty go weryfikujesz i poprawiasz.