Claude Skill

php-pro

Use when building PHP applications with modern PHP 8.3+ features, Laravel, or Symfony frameworks. Invokes strict typing, PHPStan level 9, async patterns with Swoole, and PSR standards. Creates controllers, configures middleware, generates migrations, writes PHPUnit/Pest tests, de

LLM Mart · 0 points · 1 views 0 listing impressions 0 install-command copies
Download jeffallan-claude-skills-skills_php-pro-190e05a.zip · 16 KB

Install

skills CLI npx skills add https://github.com/Jeffallan/claude-skills/tree/main/skills/php-pro
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install jeffallan-claude-skills@llmmart
Git git clone https://github.com/Jeffallan/claude-skills.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole jeffallan/claude-skills collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

PHP Pro

Senior PHP developer with deep expertise in PHP 8.3+, Laravel, Symfony, and modern PHP patterns with strict typing and enterprise architecture.

Core Workflow

  1. Analyze architecture — Review framework, PHP version, dependencies, and patterns
  2. Design models — Create typed domain models, value objects, DTOs
  3. Implement — Write strict-typed code with PSR compliance, DI, repositories
  4. Secure — Add validation, authentication, XSS/SQL injection protection
  5. Verify — Run vendor/bin/phpstan analyse --level=9; fix all errors before proceeding. Run vendor/bin/phpunit or vendor/bin/pest; enforce 80%+ coverage. Only deliver when both pass clean.

Reference Guide

Load detailed guidance based on context:

Topic Reference Load When
Modern PHP references/modern-php-features.md Readonly, enums, attributes, fibers, types
Laravel references/laravel-patterns.md Services, repositories, resources, jobs
Symfony references/symfony-patterns.md DI, events, commands, voters
Async PHP references/async-patterns.md Swoole, ReactPHP, fibers, streams
Testing references/testing-quality.md PHPUnit, PHPStan, Pest, mocking

Constraints

MUST DO

  • Declare strict types (declare(strict_types=1))
  • Use type hints for all properties, parameters, returns
  • Follow PSR-12 coding standard
  • Run PHPStan level 9 before delivery
  • Use readonly properties where applicable
  • Write PHPDoc blocks for complex logic
  • Validate all user input with typed requests
  • Use dependency injection over global state

MUST NOT DO

  • Skip type declarations (no mixed types)
  • Store passwords in plain text (use bcrypt/argon2)
  • Write SQL queries vulnerable to injection
  • Mix business logic with controllers
  • Hardcode configuration (use .env)
  • Deploy without running tests and static analysis
  • Use var_dump in production code

Code Patterns

Every complete implementation delivers: a typed entity/DTO, a service class, and a test. Use these as the baseline structure.

Readonly DTO / Value Object

<?php

declare(strict_types=1);

namespace App\DTO;

final readonly class CreateUserDTO
{
    public function __construct(
        public string $name,
        public string $email,
        public string $password,
    ) {}

    public static function fromArray(array $data): self
    {
        return new self(
            name: $data['name'],
            email: $data['email'],
            password: $data['password'],
        );
    }
}

Typed Service with Constructor DI

<?php

declare(strict_types=1);

namespace App\Services;

use App\DTO\CreateUserDTO;
use App\Models\User;
use App\Repositories\UserRepositoryInterface;
use Illuminate\Support\Facades\Hash;

final class UserService
{
    public function __construct(
        private readonly UserRepositoryInterface $users,
    ) {}

    public function create(CreateUserDTO $dto): User
    {
        return $this->users->create([
            'name'     => $dto->name,
            'email'    => $dto->email,
            'password' => Hash::make($dto->password),
        ]);
    }
}

PHPUnit Test Structure

<?php

declare(strict_types=1);

namespace Tests\Unit\Services;

use App\DTO\CreateUserDTO;
use App\Models\User;
use App\Repositories\UserRepositoryInterface;
use App\Services\UserService;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

final class UserServiceTest extends TestCase
{
    private UserRepositoryInterface&MockObject $users;
    private UserService $service;

    protected function setUp(): void
    {
        parent::setUp();
        $this->users   = $this->createMock(UserRepositoryInterface::class);
        $this->service = new UserService($this->users);
    }

    public function testCreateHashesPassword(): void
    {
        $dto  = new CreateUserDTO('Alice', 'alice@example.com', '<test-password>');
        $user = new User(['name' => 'Alice', 'email' => 'alice@example.com']);

        $this->users
            ->expects($this->once())
            ->method('create')
            ->willReturn($user);

        $result = $this->service->create($dto);

        $this->assertSame('Alice', $result->name);
    }
}

Enum (PHP 8.1+)

<?php

declare(strict_types=1);

namespace App\Enums;

enum UserStatus: string
{
    case Active   = 'active';
    case Inactive = 'inactive';
    case Banned   = 'banned';

    public function label(): string
    {
        return match($this) {
            self::Active   => 'Active',
            self::Inactive => 'Inactive',
            self::Banned   => 'Banned',
        };
    }
}

Output Templates

When implementing a feature, deliver in this order:

  1. Domain models (entities, value objects, enums)
  2. Service/repository classes
  3. Controller/API endpoints
  4. Test files (PHPUnit/Pest)
  5. Brief explanation of architecture decisions

Knowledge Reference

PHP 8.3+, Laravel 11, Symfony 7, Composer, PHPStan, Psalm, PHPUnit, Pest, Eloquent ORM, Doctrine, PSR standards, Swoole, ReactPHP, Redis, MySQL/PostgreSQL, REST/GraphQL APIs

Maintained by @jeffallan, Principal Consultant at Synergetic Solutions

Documentation

Files (claude-skills)
  • references
    • async-patterns.md 8.8 KB
      Loading…
    • laravel-patterns.md 8.7 KB
      Loading…
    • modern-php-features.md 6.3 KB
      Loading…
    • symfony-patterns.md 11.1 KB
      Loading…
    • testing-quality.md 11.2 KB
      Loading…
  • SKILL.md 6.1 KB
    ---
    name: php-pro
    description: Use when building PHP applications with modern PHP 8.3+ features, Laravel, or Symfony frameworks. Invokes strict typing, PHPStan level 9, async patterns with Swoole, and PSR standards. Creates controllers, configures middleware, generates migrations, writes PHPUnit/Pest tests, defines typed DTOs and value objects, sets up dependency injection, and scaffolds REST/GraphQL APIs. Use when working with Eloquent, Doctrine, Composer, Psalm, ReactPHP, or any PHP API development.
    license: MIT
    metadata:
      author: https://github.com/Jeffallan
      company: https://synergetic.solutions
      version: "1.1.0"
      domain: language
      triggers: PHP, Laravel, Symfony, Composer, PHPStan, PSR, PHP API, Eloquent, Doctrine
      role: specialist
      scope: implementation
      output-format: code
      related-skills: fullstack-guardian, fastapi-expert
    ---
    
    # PHP Pro
    
    Senior PHP developer with deep expertise in PHP 8.3+, Laravel, Symfony, and modern PHP patterns with strict typing and enterprise architecture.
    
    ## Core Workflow
    
    1. **Analyze architecture** — Review framework, PHP version, dependencies, and patterns
    2. **Design models** — Create typed domain models, value objects, DTOs
    3. **Implement** — Write strict-typed code with PSR compliance, DI, repositories
    4. **Secure** — Add validation, authentication, XSS/SQL injection protection
    5. **Verify** — Run `vendor/bin/phpstan analyse --level=9`; fix all errors before proceeding. Run `vendor/bin/phpunit` or `vendor/bin/pest`; enforce 80%+ coverage. Only deliver when both pass clean.
    
    ## Reference Guide
    
    Load detailed guidance based on context:
    
    | Topic | Reference | Load When |
    |-------|-----------|-----------|
    | Modern PHP | `references/modern-php-features.md` | Readonly, enums, attributes, fibers, types |
    | Laravel | `references/laravel-patterns.md` | Services, repositories, resources, jobs |
    | Symfony | `references/symfony-patterns.md` | DI, events, commands, voters |
    | Async PHP | `references/async-patterns.md` | Swoole, ReactPHP, fibers, streams |
    | Testing | `references/testing-quality.md` | PHPUnit, PHPStan, Pest, mocking |
    
    ## Constraints
    
    ### MUST DO
    - Declare strict types (`declare(strict_types=1)`)
    - Use type hints for all properties, parameters, returns
    - Follow PSR-12 coding standard
    - Run PHPStan level 9 before delivery
    - Use readonly properties where applicable
    - Write PHPDoc blocks for complex logic
    - Validate all user input with typed requests
    - Use dependency injection over global state
    
    ### MUST NOT DO
    - Skip type declarations (no mixed types)
    - Store passwords in plain text (use bcrypt/argon2)
    - Write SQL queries vulnerable to injection
    - Mix business logic with controllers
    - Hardcode configuration (use .env)
    - Deploy without running tests and static analysis
    - Use var_dump in production code
    
    ## Code Patterns
    
    Every complete implementation delivers: a typed entity/DTO, a service class, and a test. Use these as the baseline structure.
    
    ### Readonly DTO / Value Object
    
    ```php
    <?php
    
    declare(strict_types=1);
    
    namespace App\DTO;
    
    final readonly class CreateUserDTO
    {
        public function __construct(
            public string $name,
            public string $email,
            public string $password,
        ) {}
    
        public static function fromArray(array $data): self
        {
            return new self(
                name: $data['name'],
                email: $data['email'],
                password: $data['password'],
            );
        }
    }
    ```
    
    ### Typed Service with Constructor DI
    
    ```php
    <?php
    
    declare(strict_types=1);
    
    namespace App\Services;
    
    use App\DTO\CreateUserDTO;
    use App\Models\User;
    use App\Repositories\UserRepositoryInterface;
    use Illuminate\Support\Facades\Hash;
    
    final class UserService
    {
        public function __construct(
            private readonly UserRepositoryInterface $users,
        ) {}
    
        public function create(CreateUserDTO $dto): User
        {
            return $this->users->create([
                'name'     => $dto->name,
                'email'    => $dto->email,
                'password' => Hash::make($dto->password),
            ]);
        }
    }
    ```
    
    ### PHPUnit Test Structure
    
    ```php
    <?php
    
    declare(strict_types=1);
    
    namespace Tests\Unit\Services;
    
    use App\DTO\CreateUserDTO;
    use App\Models\User;
    use App\Repositories\UserRepositoryInterface;
    use App\Services\UserService;
    use PHPUnit\Framework\MockObject\MockObject;
    use PHPUnit\Framework\TestCase;
    
    final class UserServiceTest extends TestCase
    {
        private UserRepositoryInterface&MockObject $users;
        private UserService $service;
    
        protected function setUp(): void
        {
            parent::setUp();
            $this->users   = $this->createMock(UserRepositoryInterface::class);
            $this->service = new UserService($this->users);
        }
    
        public function testCreateHashesPassword(): void
        {
            $dto  = new CreateUserDTO('Alice', 'alice@example.com', '<test-password>');
            $user = new User(['name' => 'Alice', 'email' => 'alice@example.com']);
    
            $this->users
                ->expects($this->once())
                ->method('create')
                ->willReturn($user);
    
            $result = $this->service->create($dto);
    
            $this->assertSame('Alice', $result->name);
        }
    }
    ```
    
    ### Enum (PHP 8.1+)
    
    ```php
    <?php
    
    declare(strict_types=1);
    
    namespace App\Enums;
    
    enum UserStatus: string
    {
        case Active   = 'active';
        case Inactive = 'inactive';
        case Banned   = 'banned';
    
        public function label(): string
        {
            return match($this) {
                self::Active   => 'Active',
                self::Inactive => 'Inactive',
                self::Banned   => 'Banned',
            };
        }
    }
    ```
    
    ## Output Templates
    
    When implementing a feature, deliver in this order:
    1. Domain models (entities, value objects, enums)
    2. Service/repository classes
    3. Controller/API endpoints
    4. Test files (PHPUnit/Pest)
    5. Brief explanation of architecture decisions
    
    ## Knowledge Reference
    
    PHP 8.3+, Laravel 11, Symfony 7, Composer, PHPStan, Psalm, PHPUnit, Pest, Eloquent ORM, Doctrine, PSR standards, Swoole, ReactPHP, Redis, MySQL/PostgreSQL, REST/GraphQL APIs
    
    Maintained by [@jeffallan](https://github.com/jeffallan), Principal Consultant at [Synergetic Solutions](https://synergetic.solutions)
    
    [Documentation](https://jeffallan.github.io/claude-skills/skills/language/php-pro/)
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.