laravel-verification
affaan-m/everything-claude-code
Comprehensive verification pipeline for Laravel projects: env, linting, tests, security, and deployment readiness.
What is laravel-verification?
A structured verification loop for Laravel projects that runs environment checks, code linting, static analysis, tests with coverage, security audits, database migrations, and deployment readiness gates. Use before pull requests, after major changes, and pre-deployment to catch issues early across all layers.
- Environment and Composer validation to gate the pipeline
- Code linting with Pint and static analysis with PHPStan or Psalm
- Test execution with optional coverage reporting via Xdebug
- Security vulnerability scanning with composer audit
- Database migration preview and status verification
- Cache warming and deployment readiness checks
How to install laravel-verification
npx skills add https://github.com/affaan-m/everything-claude-code --skill laravel-verification- Laravel project with Composer installed
- PHP CLI available (or Laravel Sail for containerized environments)
- Pint and PHPStan (or Psalm) installed as dev dependencies
- Xdebug installed if running coverage reports
How to use laravel-verification
- 1.Run Phase 1 environment checks (php -v, composer --version, php artisan --version) and verify .env configuration
- 2.Run Phase 1.5 Composer validation and autoload optimization (composer validate, composer dump-autoload -o)
- 3.Run Phase 2 linting and static analysis (vendor/bin/pint --test, vendor/bin/phpstan analyse)
- 4.Run Phase 3 tests with coverage if needed (php artisan test or XDEBUG_MODE=coverage php artisan test --coverage)
- 5.Run Phase 4 security audit (composer audit) and Phase 5 migration checks (php artisan migrate --pretend, php artisan migrate:status)
- 6.Run Phase 6 deployment readiness (php artisan optimize:clear, php artisan config:cache, php artisan route:cache, php artisan view:cache)
- 7.Run Phase 7 queue and scheduler checks (php artisan schedule:list, php artisan queue:failed, optionally php artisan horizon:status)
Use cases
- Pre-pull-request verification for Laravel projects to catch issues before code review
- Post-refactor or dependency-upgrade validation to ensure nothing broke
- Pre-deployment checks for staging or production environments
- CI/CD pipeline integration with coverage reporting and security scanning
- Queue and scheduler health verification before release
- Laravel developers preparing code for review or deployment
- DevOps engineers setting up CI/CD pipelines for Laravel applications
- Teams requiring comprehensive pre-deployment verification
- Projects using queues, schedulers, or Horizon for background jobs
laravel-verification FAQ
Yes. The minimal flow includes environment, Composer, linting, static analysis, tests, audit, and migration checks. Adjust based on your needs, but environment and Composer checks should always run first.
Replace vendor/bin/phpstan analyse with vendor/bin/psalm in Phase 2. Both tools perform static analysis; use whichever your project is configured for.
Set XDEBUG_MODE=coverage and run php artisan test --coverage. Xdebug must be installed. This is safe for CI but slower locally.
No. The active queue verification (tinker dispatch + queue:work) should only run on staging or non-production environments. Use passive checks like php artisan queue:failed and php artisan schedule:list in production.
It shows the SQL that would be executed without actually running migrations. Use this to review destructive changes before applying them.
Full instructions (SKILL.md)
Source of truth, from affaan-m/everything-claude-code.
name: laravel-verification description: "Verification loop for Laravel projects: env checks, linting, static analysis, tests with coverage, security scans, and deployment readiness." metadata: origin: ECC
Laravel Verification Loop
Run before PRs, after major changes, and pre-deploy.
When to Use
- Before opening a pull request for a Laravel project
- After major refactors or dependency upgrades
- Pre-deployment verification for staging or production
- Running full lint -> test -> security -> deploy readiness pipeline
How It Works
- Run phases sequentially from environment checks through deployment readiness so each layer builds on the last.
- Environment and Composer checks gate everything else; stop immediately if they fail.
- Linting/static analysis should be clean before running full tests and coverage.
- Security and migration reviews happen after tests so you verify behavior before data or release steps.
- Build/deploy readiness and queue/scheduler checks are final gates; any failure blocks release.
Phase 1: Environment Checks
php -v
composer --version
php artisan --version
- Verify
.envis present and required keys exist - Confirm
APP_DEBUG=falsefor production environments - Confirm
APP_ENVmatches the target deployment (production,staging)
If using Laravel Sail locally:
./vendor/bin/sail php -v
./vendor/bin/sail artisan --version
Phase 1.5: Composer and Autoload
composer validate
composer dump-autoload -o
Phase 2: Linting and Static Analysis
vendor/bin/pint --test
vendor/bin/phpstan analyse
If your project uses Psalm instead of PHPStan:
vendor/bin/psalm
Phase 3: Tests and Coverage
php artisan test
Coverage (CI):
XDEBUG_MODE=coverage php artisan test --coverage
CI example (format -> static analysis -> tests):
vendor/bin/pint --test
vendor/bin/phpstan analyse
XDEBUG_MODE=coverage php artisan test --coverage
Phase 4: Security and Dependency Checks
composer audit
Phase 5: Database and Migrations
php artisan migrate --pretend
php artisan migrate:status
- Review destructive migrations carefully
- Ensure migration filenames follow
Y_m_d_His_*(e.g.,2025_03_14_154210_create_orders_table.php) and describe the change clearly - Ensure rollbacks are possible
- Verify
down()methods and avoid irreversible data loss without explicit backups
Phase 6: Build and Deployment Readiness
php artisan optimize:clear
php artisan config:cache
php artisan route:cache
php artisan view:cache
- Ensure cache warmups succeed in production configuration
- Verify queue workers and scheduler are configured
- Confirm
storage/andbootstrap/cache/are writable in the target environment
Phase 7: Queue and Scheduler Checks
php artisan schedule:list
php artisan queue:failed
If Horizon is used:
php artisan horizon:status
If queue:monitor is available, use it to check backlog without processing jobs:
php artisan queue:monitor default --max=100
Active verification (staging only): dispatch a no-op job to a dedicated queue and run a single worker to process it (ensure a non-sync queue connection is configured).
php artisan tinker --execute="dispatch((new App\\Jobs\\QueueHealthcheck())->onQueue('healthcheck'))"
php artisan queue:work --once --queue=healthcheck
Verify the job produced the expected side effect (log entry, healthcheck table row, or metric).
Only run this on non-production environments where processing a test job is safe.
Examples
Minimal flow:
php -v
composer --version
php artisan --version
composer validate
vendor/bin/pint --test
vendor/bin/phpstan analyse
php artisan test
composer audit
php artisan migrate --pretend
php artisan config:cache
php artisan queue:failed
CI-style pipeline:
composer validate
composer dump-autoload -o
vendor/bin/pint --test
vendor/bin/phpstan analyse
XDEBUG_MODE=coverage php artisan test --coverage
composer audit
php artisan migrate --pretend
php artisan optimize:clear
php artisan config:cache
php artisan route:cache
php artisan view:cache
php artisan schedule:list
Related skills
More from affaan-m/everything-claude-code and the wider catalog.
security-review
Security checklist and patterns for authentication, input validation, secrets, and sensitive features.
golang-patterns
Idiomatic Go patterns, best practices, and conventions for building robust, efficient, and maintainable applications.
coding-standards
Baseline coding conventions for naming, readability, immutability, and quality across projects.
frontend-patterns
React and Next.js patterns for components, state management, performance, and modern frontend practices.
backend-patterns
REST/GraphQL API design, database optimization, and server-side patterns for Node.js, Express, and Next.js.
golang-testing
Go testing patterns: table-driven tests, subtests, benchmarks, fuzzing, and TDD methodology.