Master PHP 8.3 with Claude Sonnet 4.6

PHP 8.3 brought a wave of powerful features — typed class constants, the json_validate() function, the new Override attribute, deep-cloning of readonly properties, and much more. But navigating these features, integrating them into existing codebases, and learning to apply them correctly in frameworks like Symfony can be overwhelming.

Enter Claude AI with Sonnet 4.6 — Anthropic's most capable everyday model. Whether you're a seasoned PHP developer or just stepping into PHP 8.3 territory, Claude Sonnet 4.6 can act as your always-available expert pair programmer, code reviewer, and architectural advisor.

In this guide, you'll see exactly how Claude Sonnet 4.6 can help you take full advantage of PHP 8.3 with real code examples and practical step-by-step workflows.

Why Claude Sonnet 4.6 for PHP 8.3?

Claude Sonnet 4.6 is fast, intelligent, and deeply knowledgeable about modern PHP. Here's why it's a particularly good fit for PHP 8.3 development:

• Deep PHP knowledge: Claude understands not just PHP syntax but also best practices, design patterns, and framework conventions.
• Context awareness: It can analyze your existing code and recommend PHP 8.3-specific improvements in context.
• Iterative refinement: You can ask follow-up questions, request alternatives, and guide Claude toward your exact requirement.
• Explanation alongside code: Claude doesn't just generate code — it explains why a solution works, helping you grow as a developer.

Let's explore specific use cases with step-by-step walkthroughs.

Step 1: Generating PHP 8.3 Code from a Description

One of Claude's most powerful capabilities is translating a plain-English description into working PHP 8.3 code.

Use Case: Creating a Strongly-Typed Value Object

Suppose you need a Money value object that is immutable, uses PHP 8.3's readonly properties, and validates its inputs.

Prompt to Claude:

"Create a PHP 8.3 Money value object using readonly properties. It should accept an amount in cents (integer) and a currency code (string). Validate that the amount is non-negative and the currency code is exactly 3 uppercase letters. Make it Stringable."

Claude Sonnet 4.6 Output:

<?php

declare(strict_types=1);

final class Money implements Stringable
{
    public readonly int $amount;
    public readonly string $currency;

    public function __construct(int $amount, string $currency)
    {
        if ($amount < 0) {
            throw new InvalidArgumentException(
                "Amount must be non-negative, got: {$amount}"
            );
        }

        if (!preg_match('/^[A-Z]{3}$/', $currency)) {
            throw new InvalidArgumentException(
                "Currency must be a 3-letter uppercase code, got: {$currency}"
            );
        }

        $this->amount = $amount;
        $this->currency = $currency;
    }

    public function add(Money $other): self
    {
        if ($this->currency !== $other->currency) {
            throw new InvalidArgumentException('Cannot add money with different currencies.');
        }

        return new self($this->amount + $other->amount, $this->currency);
    }

    public function __toString(): string
    {
        return sprintf('%s %d', $this->currency, $this->amount);
    }
}

// Usage
$price = new Money(1999, 'USD');
$tax   = new Money(160,  'USD');
$total = $price->add($tax);

echo $total; // USD 2159

This leverages PHP 8.3's readonly properties to enforce immutability — once a Money object is created, its values cannot be changed. Claude not only wrote the class but also included an add() method and a practical usage example.

Step 2: Refactoring Legacy Code to PHP 8.3

Upgrading a legacy codebase to PHP 8.3 can be tedious. Claude can analyze old code and suggest precise, idiomatic upgrades.

Use Case: Upgrading an Old Service Class

Prompt to Claude:

"Refactor this PHP 7.4 service class to use PHP 8.3 features: constructor property promotion, readonly where appropriate, named arguments, and the #[Override] attribute."

Legacy Code:

<?php

class UserNotificationService
{
    private NotificationSender $sender;
    private LoggerInterface $logger;
    private bool $debugMode;

    public function __construct(
        NotificationSender $sender,
        LoggerInterface $logger,
        bool $debugMode = false
    ) {
        $this->sender    = $sender;
        $this->logger    = $logger;
        $this->debugMode = $debugMode;
    }

    public function send(string $userId, string $message): void
    {
        if ($this->debugMode) {
            $this->logger->debug('Sending notification', ['user' => $userId]);
        }
        $this->sender->send($userId, $message);
    }
}

Claude Sonnet 4.6 Refactored Output:

<?php

declare(strict_types=1);

class UserNotificationService extends BaseNotificationService
{
    public function __construct(
        private readonly NotificationSender $sender,
        private readonly LoggerInterface $logger,
        private readonly bool $debugMode = false,
    ) {}

    #[Override]
    public function send(string $userId, string $message): void
    {
        if ($this->debugMode) {
            $this->logger->debug(
                message: 'Sending notification',
                context: ['user' => $userId],
            );
        }

        $this->sender->send(
            userId: $userId,
            message: $message,
        );
    }
}

What changed and why (as Claude would explain):

• Constructor property promotion eliminates the repetitive $this->x = $x pattern.
• readonly makes each dependency immutable after construction, preventing accidental reassignment.
• Named arguments in method calls improve readability, especially when calling methods with multiple parameters.
• #[Override] (new in PHP 8.3) explicitly signals that this method overrides a parent class method — if the parent method is renamed or removed, PHP will throw an error, catching bugs early.

Step 3: Understanding New PHP 8.3 Features with Claude

Claude is an exceptional teacher. You can ask it to explain any PHP 8.3 feature with examples tailored to your context.

Use Case: Understanding Typed Class Constants

Prompt to Claude:

"Explain PHP 8.3 typed class constants with a Symfony example. How are they different from untyped constants?"

Claude's Explanation and Example:

Before PHP 8.3, class constants had no enforced type:

// PHP 8.2 and earlier — no type enforcement
class OrderStatus
{
    const PENDING   = 'pending';
    const CONFIRMED = 42; // No error! Inconsistent type.
    const SHIPPED   = null; // Also allowed.
}

In PHP 8.3, you can now declare typed constants:

<?php

declare(strict_types=1);

// PHP 8.3 — typed class constants
class OrderStatus
{
    const string PENDING   = 'pending';
    const string CONFIRMED = 'confirmed';
    const string SHIPPED   = 'shipped';
    const string DELIVERED = 'delivered';
    const string CANCELLED = 'cancelled';
}

If you try to assign an incompatible value, PHP throws a fatal error at compile time rather than silently allowing a bug through.

In a Symfony controller:

<?php

use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\Routing\Attribute\Route;

class OrderController extends AbstractController
{
    #[Route('/orders/{id}/confirm', methods: ['POST'])]
    public function confirm(string $id, OrderRepository $repository): JsonResponse
    {
        $order = $repository->find($id);

        if ($order->status !== OrderStatus::PENDING) {
            return $this->json(['error' => 'Only pending orders can be confirmed.'], 422);
        }

        $order->status = OrderStatus::CONFIRMED;
        $repository->save($order);

        return $this->json(['status' => OrderStatus::CONFIRMED]);
    }
}

Now your constants are self-documenting and type-safe — Claude's explanation makes the concept concrete and immediately applicable.

Step 4: Debugging PHP 8.3 Code with Claude

Paste a broken snippet into Claude and get a precise diagnosis with a fix.

Use Case: Debugging a json_validate() Issue

PHP 8.3 introduced json_validate() — a dedicated function to check if a string is valid JSON without decoding it. Here's a subtle bug:

<?php

// Buggy code
function processWebhookPayload(string $raw): array
{
    if (!json_validate($raw, depth: 256, flags: JSON_THROW_ON_ERROR)) {
        throw new RuntimeException('Invalid JSON payload.');
    }

    return json_decode($raw, associative: true);
}

Prompt to Claude:

"This PHP 8.3 function using json_validate() has a bug. Can you find and fix it?"

Claude's Response:

The bug is in the flags parameter. json_validate() does not accept JSON_THROW_ON_ERROR — that flag is only valid for json_decode() and json_encode(). Passing it to json_validate() will either cause unexpected behavior or a warning. Additionally, json_validate() already returns false on invalid JSON, so there's no need for a throw flag. Here's the corrected version:

<?php

declare(strict_types=1);

function processWebhookPayload(string $raw): array
{
    // json_validate() accepts only depth and no flags in PHP 8.3
    if (!json_validate($raw, depth: 256)) {
        throw new RuntimeException('Invalid JSON payload.');
    }

    return json_decode($raw, associative: true, flags: JSON_THROW_ON_ERROR);
}

Now JSON_THROW_ON_ERROR is correctly placed on json_decode(), and json_validate() is called with only valid parameters.

This kind of fast, accurate debugging is where Claude Sonnet 4.6 shines — saving you the time of digging through PHP documentation.

Step 5: Writing Tests for PHP 8.3 Code

Claude can generate PHPUnit tests for your PHP 8.3 code, including edge cases you might overlook.

Prompt to Claude:

"Write PHPUnit 10 tests for the Money class we created earlier. Cover the happy path, adding different currencies (should fail), a negative amount (should fail), and an invalid currency code."

Claude's Output:

<?php

declare(strict_types=1);

use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\Attributes\Test;
use PHPUnit\Framework\Attributes\DataProvider;

final class MoneyTest extends TestCase
{
    #[Test]
    public function it_creates_a_valid_money_object(): void
    {
        $money = new Money(1999, 'USD');

        $this->assertSame(1999, $money->amount);
        $this->assertSame('USD', $money->currency);
    }

    #[Test]
    public function it_is_stringable(): void
    {
        $money = new Money(500, 'EUR');

        $this->assertSame('EUR 500', (string) $money);
    }

    #[Test]
    public function it_adds_two_money_objects_of_same_currency(): void
    {
        $price = new Money(1000, 'GBP');
        $tax   = new Money(200,  'GBP');
        $total = $price->add($tax);

        $this->assertSame(1200, $total->amount);
        $this->assertSame('GBP', $total->currency);
    }

    #[Test]
    public function it_throws_when_adding_different_currencies(): void
    {
        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage('Cannot add money with different currencies.');

        $usd = new Money(1000, 'USD');
        $eur = new Money(1000, 'EUR');
        $usd->add($eur);
    }

    #[Test]
    public function it_throws_for_negative_amount(): void
    {
        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage('Amount must be non-negative');

        new Money(-1, 'USD');
    }

    #[Test]
    #[DataProvider('invalidCurrencyCodes')]
    public function it_throws_for_invalid_currency_code(string $code): void
    {
        $this->expectException(InvalidArgumentException::class);

        new Money(100, $code);
    }

    public static function invalidCurrencyCodes(): array
    {
        return [
            'lowercase'          => ['usd'],
            'too short'          => ['US'],
            'too long'           => ['USDD'],
            'with numbers'       => ['U1D'],
            'empty string'       => [''],
        ];
    }

    #[Test]
    public function readonly_property_cannot_be_modified(): void
    {
        $money = new Money(100, 'USD');

        $this->expectException(Error::class);

        // @phpstan-ignore-next-line
        $money->amount = 999;
    }
}

Claude uses PHPUnit 10's attribute-based syntax (#[Test], #[DataProvider]) — the modern PHP 8.x style — and covers all meaningful edge cases.

Step 6: Integrating PHP 8.3 Features in a Symfony Project

Claude can also guide you through architectural decisions when using PHP 8.3 in a full Symfony application.

Prompt to Claude:

"In a Symfony 7 app, how should I use PHP 8.3's readonly classes for Doctrine DTOs to safely carry query results without risking accidental mutation?"

Claude's Guidance and Example:

<?php

declare(strict_types=1);

namespace App\ReadModel;

// PHP 8.3 readonly class — all properties are implicitly readonly
readonly class ProductSummary
{
    public function __construct(
        public int    $id,
        public string $name,
        public float  $price,
        public int    $stockCount,
    ) {}
}

In your Doctrine repository:

<?php

declare(strict_types=1);

namespace App\Repository;

use App\ReadModel\ProductSummary;
use Doctrine\ORM\EntityManagerInterface;

class ProductRepository
{
    public function __construct(private readonly EntityManagerInterface $em) {}

    /** @return ProductSummary[] */
    public function findSummaries(): array
    {
        return $this->em->createQuery(
            'SELECT NEW App\ReadModel\ProductSummary(p.id, p.name, p.price, p.stockCount)
             FROM App\Entity\Product p
             WHERE p.active = true
             ORDER BY p.name ASC'
        )->getResult();
    }
}

Why this pattern? Readonly classes (PHP 8.2+, refined in 8.3) guarantee your DTOs can never be accidentally mutated downstream — not in a Twig template, not in a service, not anywhere. This makes your read-model layer safe and predictable, and Doctrine's NEW keyword maps query results directly into your DTO constructor.

Putting It All Together: A Daily Workflow with Claude and PHP 8.3

Here's a practical workflow you can adopt:

1. Describe your feature — Tell Claude what you need in plain English.
2. Get a PHP 8.3-idiomatic scaffold — Claude generates modern, typed, readable code.
3. Ask for refactoring suggestions — Paste existing code and ask how to modernize it.
4. Request tests — Get comprehensive PHPUnit tests with edge cases included.
5. Paste errors or unexpected behavior — Claude diagnoses bugs and explains the fix.
6. Ask "why" — Claude explains every feature it uses, helping you internalize best practices.

Conclusion

PHP 8.3 is a significant step forward for the language, and Claude AI with Sonnet 4.6 is the ideal companion for making the most of it. From generating immutable value objects with readonly properties to debugging subtle json_validate() misuse, from typed class constants in Symfony controllers to readonly DTO classes in Doctrine — Claude can handle every dimension of your PHP 8.3 journey.

The key advantage Claude brings isn't just code generation. It's the combination of accurate, modern code plus clear explanation, which accelerates your learning and helps you write better PHP — not just faster PHP.

Whether you're preparing for a Symfony certification, upgrading a legacy codebase, or building a greenfield application, integrating Claude Sonnet 4.6 into your development workflow is one of the smartest investments you can make as a PHP developer in 2026.

Ready to start? Open claude.ai and paste your first PHP snippet. You might be surprised how much faster you ship — and how much more you learn along the way.