superpowers-laravel

Laravel brainstorming; use the laravel:brainstorming skill exactly as written

Request effective code reviews with specific focus areas and context

Create effective debugging prompts with complete error information and context

Learn how to provide effective context in prompts for accurate AI responses

Execute a Laravel plan in batches; use the laravel:executing-plans skill exactly as written

Refine AI-generated code through specific feedback and incremental validation

API surface evolution; use the laravel:api-surface-evolution skill exactly as written

Use API Resources and pagination; use the laravel:api-resources-and-pagination skill exactly as written

Compose UIs with Blade components; use the laravel:blade-components-and-layouts skill exactly as written

Detect runner and list command pairs; use the laravel:bootstrap-check skill exactly as written

Run Laravel quality checks; use the laravel:quality-checks skill exactly as written

Clean up controllers; use the laravel:controller-cleanup skill exactly as written

Write focused controller tests; use the laravel:controller-tests skill exactly as written

Daily Laravel checklist; use the laravel:daily-workflow skill exactly as written

Define and load relationships efficiently; use the laravel:eloquent-relationships skill exactly as written

Improve observability of failures; use the laravel:exception-handling-and-logging skill exactly as written

Store and serve files safely; use the laravel:filesystem-uploads skill exactly as written

Extract validation to Form Requests; use the laravel:form-requests skill exactly as written

Add small, pure helper functions; use the laravel:custom-helpers skill exactly as written

Horizon dashboards and metrics; use the laravel:horizon:metrics-and-dashboards skill exactly as written

Harden outbound HTTP calls; use the laravel:http-client-resilience skill exactly as written

Decouple using interfaces and DI; use the laravel:interfaces-and-di skill exactly as written

Nova resource patterns; use the laravel:nova:resource-patterns skill exactly as written

Add caching to reduce work; use the laravel:performance-caching skill exactly as written

Prevent N+1 queries; use the laravel:performance-eager-loading skill exactly as written

E2E Playwright patterns; use the laravel:e2e-playwright skill exactly as written

Enforce access via Policies; use the laravel:policies-and-authorization skill exactly as written

Use Laravel-specific vocabulary and patterns to get idiomatic framework code

Apply per-user throttle; use the laravel:rate-limiting skill exactly as written

Schedule tasks safely; use the laravel:task-scheduling skill exactly as written

Select only required columns; use the laravel:performance-select-columns skill exactly as written

Storage config strategy (S3/R2/MinIO/CDN); use the laravel:config-env-storage skill exactly as written

Select behavior via Strategy; use the laravel:strategy-pattern skill exactly as written

Start Laravel TDD loop with Pest/PHPUnit; use the laravel:tdd-with-pest skill exactly as written

Make multi-write flows atomic; use the laravel:transactions-and-consistency skill exactly as written

Learn how to structure prompts effectively for clear and complete responses

Define clear constraints for performance, security, testing, and architecture

Provide concrete examples to guide AI toward your project's conventions and style

Create a Laravel implementation plan; use the laravel:writing-plans skill exactly as written

Subagent that audits a controller class and proposes a refactor plan using Form Requests, Actions/DTOs, and single-action/resource controllers

Use API Resources with pagination and conditional fields; keep response shapes stable and cache-friendly

Remove unneeded Composer packages and assets to improve boot time, memory, and security surface

Evolve APIs safely using versioned DTOs/transformers, deprecations, and compatibility tests

Compose UIs with Blade components, slots, and layouts; keep templates pure and testable

Detect Sail/non‑Sail and print the right command pairs for your environment; verify dependencies and key services are reachable

Interactive design refinement tailored to Laravel projects; clarify domain, data, interfaces, testing, and quality gates while accounting for Sail/non‑Sail environments

Request effective code reviews—specify focus areas, provide context, ask for architectural feedback, reference Laravel conventions

Keep cyclomatic complexity low; flatten control flow, extract helpers, and prefer table-driven/strategy patterns over large switches

Portable storage configuration across S3/R2/MinIO with optional CDN—env toggles, path-style endpoints, and URL generation

Replace hardcoded values with constants, enums, and configuration for maintainability; use PHP 8.1+ enums and config files

Reduce controller bloat using Form Requests for auth/validation, small Actions/Services with DTOs, and resource/single-action controllers

Write focused controller tests using HTTP assertions; keep heavy logic in Actions/Services and unit test them

Create and register small, pure helper functions when they improve clarity; keep them organized and tested

Practical daily checklist for Laravel projects; bring services up, run migrations, queues, quality gates, and tests

Process large datasets efficiently using chunk(), chunkById(), lazy(), and cursor() to reduce memory consumption and improve performance

Create effective debugging prompts—include error messages, stack traces, expected vs actual behavior, logs, and attempted solutions

Write meaningful documentation that explains why not what; focus on complex business logic and self-documenting code

Generic E2E patterns with Playwright—state setup, seeds, test IDs, auth, environment, and Sail integration

Provide comprehensive context in prompts—files, errors, Laravel version, dependencies, and monorepo details—for accurate AI responses

Define clear relationships and load data efficiently; prevent N+1, use constraints, counts/sums, and pivot syncing safely

Use reportable/renderable exceptions, structured logs, and channel strategy for observability and graceful failures

Execute Laravel plans in small batches with checkpoints—TDD first, migrations safe, queues verified, and quality gates enforced

Store and serve files via Storage; set visibility, generate URLs, and handle streaming safely

Move validation and authorization into Form Requests; use rule objects, custom messages, and nested data handling to keep controllers slim

Operate Horizon with confidence—naming, tags, concurrency, failure handling, actionable metrics, and dashboards

Use the HTTP client with sensible timeouts, retries, and backoff; capture context and handle failures explicitly

Use interfaces and dependency injection to decouple code; bind implementations in the container

Build with i18n in mind from day one using Laravel translation helpers, JSON files, Blade integration, and locale management

Refine AI-generated code through specific feedback—point out errors, identify gaps, show desired changes, reference style guides

Use Laravel-specific vocabulary—Eloquent patterns, Form Requests, API resources, jobs/queues—to get idiomatic framework code

Safe database change patterns; when to modify vs add migrations; always pair models with migrations and factories; seeding guidance

Consistent Nova resources—fields, actions, metrics, lenses, filters, authorization—and how to evolve resources alongside schema changes

Use framework caches and value/query caching to reduce work; add tags, locks, and explicit invalidation strategies for correctness

Prevent N+1 queries by eager loading; enable lazy-loading protection in non-production; choose selective fields

Select only required columns to reduce memory and transfer costs; apply to base queries and relations

Enforce access via Policies and Gates; use authorize() and authorizeResource() to standardize controller protections

Use hexagonal architecture for external systems; define ports (interfaces) and per-provider adapters; select adapter at composition edge

Structure prompts for clarity—separate concerns, prioritize requests, specify acceptance criteria, and break work into testable increments

Unified quality gates for Laravel projects; Pint, static analysis (PHPStan/Psalm), Insights (optional), and JS linters; Sail and non-Sail pairs provided

Operate and verify queues with or without Horizon; safe worker flags, failure handling, and test strategies

Apply per-user and per-route limits with RateLimiter and throttle middleware; use backoffs and headers for clients

Keep routes clean and focused on mapping requests to controllers; avoid business logic, validation, or database operations in route files

Choose Sail automatically when available, fall back cleanly to host PHP/Composer/Node; paired command map for both environments

Define clear constraints—performance, security, testing, architecture, dependencies—so AI generates code that meets your project standards

Use the Strategy pattern to select behavior at runtime; bind multiple implementations to a shared interface

Schedule tasks with safety; use withoutOverlapping, onOneServer, and visibility settings for reliable cron execution

Apply RED-GREEN-REFACTOR with Pest or PHPUnit; use factories, feature tests for HTTP, and parallel test runners; verify failures before implementation

Stabilize workflows with Template Method or Strategy; extend by adding new classes instead of editing core logic

Wrap multi-write operations in transactions; use dispatchAfterCommit and idempotency patterns to ensure consistency

Provide concrete examples—existing code patterns, style samples, input/output pairs—to guide AI toward your project's conventions

Read first in Laravel repos; explains runner selection (Sail vs non-Sail), core workflows, and how to apply superpowers skills in Laravel projects without platform lock-in

Create an actionable Laravel implementation plan—bite-sized tasks with TDD-first steps, migrations, services, jobs, and validation points

1 hook across 1 event