Works with the AI tools you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+22 more

    PHP Engineering

    1

    Build, debug, and refactor production-ready PHP applications using modern 8.x patterns and strict typing.

    $5

    Secure checkout via Stripe

    30-day refund guarantee

    Converts to your local currency at checkout

    Security scanned
    PHP Engineering

    PHP Engineering

    Example session with this skill installed

    Refactor this legacy user registration snippet into a modern PHP 8 service. It currently uses a raw array for user data and handles validation, DB insertion, and email in one function.

    • Read your context and instructions
    • Compiled the php engineering

    I have refactored the registration logic into a dedicated service using PHP 8.3 features. The logic is now decoupled into a DTO for data integrity, a Service for orchestration, and uses constructor promotion for cleaner dependency injection.

    Refactored PHP 8 Engineering Solution

    namespace App\Services;

readonly class UserRegistrationRequest
{
    public function __construct(
        public string $email,
        public string $password,
        public string $name,
        public array $roles = ['user'],
    ) {}
}

interface UserService
{
    public function register(UserRegistrationRequest $data): User;
}

final class RegistrationService implements UserService
{
    public function __construct(
        private UserRepository $repository,
        private PasswordHasher $hasher,
        private EventDispatcher $events,
    ) {}

    /**
     * Handles the atomic registration process.
     * Throws ValidationException if data is malformed.
     */
    public function register(UserRegistrationRequest $data): User
    {
        $hashedPassword = $this->hasher->hash($data->password);
        
        $user = $this->repository->create([
            'email' => $data->email,
            'password' => $hashedPassword,
            'name' => $data->name,
            'roles' => $data->roles,
        ]);

        $this->events->dispatch(new UserRegistered($user));

        return $user;
    }
}

    Next steps

    1. Update your controller to type-hint UserService and pass the UserRegistrationRequest DTO.
    2. Run vendor/bin/phpunit to verify the service mock behavior.
    3. Apply static analysis via PHPStan or Psalm to confirm type coverage for the new DTO.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    PHP projects often suffer from bloated controllers, hidden side effects, and weak typing that makes long-term maintenance a nightmare. This skill enforces modern PHP 8.x standards to transform messy scripts into structured, testable, and secure applications.

    What it does

    • Architectural Refactoring translates business logic from controllers into dedicated service layers and domain objects.
    • Type Safety Enforcement replaces vague array-shaped data with DTOs, value objects, and typed collections.
    • Performance Optimization identifies database bottlenecks, eager loading issues, and redundant service resolutions.
    • Modernization upgrades legacy syntax to utilize PHP 8.x features for better readability and performance.
    • Security Hardening implements secure defaults for request validation, persistence, and serialization.

    How it works

    1. Stack Identification analyzes the project to detect if it is Laravel, Symfony, a standalone package, or legacy PHP.
    2. Environment Audit inspects PHP versions, Composer configurations, and existing static analysis tools.
    3. Logic Extraction decouples framework-specific code from core business rules to improve testability.
    4. Verification validates all changes against the existing test suite and static analysis benchmarks.

    Frameworks & tools

    Primary support for PHP 8.x, Laravel, Symfony, and Composer-based packages. It integrates with PHPUnit, static analysis tools, and standard PSR coding conventions.

    Why this beats prompting it yourself

    Generic prompts often produce outdated PHP 5/7 patterns or "array-driven" code that lacks IDE autocompletion. This skill specifically prioritizes strict typing and domain-driven boundaries, ensuring your code is ready for enterprise static analysis.

    Use cases

    • Migrating a legacy PHP 7.4 script to a modern PHP 8.3 service class.
    • Refactoring a 500-line Laravel controller into reusable DTOs and Services.
    • Optimizing Eloquent or Doctrine queries to fix N+1 performance issues.
    • Building a framework-agnostic PHP package with clean PSR compliance.

    Known limitations

    Does not perform automated server-level PHP version upgrades or manage server extensions. Requires an existing Composer setup for optimal dependency analysis.

    How to use

    Skills on Agensi run inside your AI agent. Copy the prompt, paste it into your agent, and it connects to Agensi and installs this skill for you. If a payment is needed, your agent shows it to you first.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill passes our trust checks below.

    Security scanned

    Passed our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    30-day refund

    Not a fit? Get your money back

    Trust & safety

    Security scanned

    Verified clean today

    • Passed all security checks, Safe to install

    Listedtoday

    What's inside

    Frequently Asked Questions