Product Decisions This Supports

Enforcing Consistent Code Quality: Standardizes PSR-12 compliance across Laravel projects, reducing technical debt and improving maintainability. Aligns with Laravel’s best practices while adding a layer of automation.
Accelerating Developer Onboarding: Eliminates manual code review overhead for style/format issues, allowing new hires to focus on business logic. Integrates seamlessly with Laravel’s existing workflows (e.g., composer scripts).
Shift-Left Quality Assurance: Shifts linting and code quality checks to pre-commit/pre-push phases, reducing CI/CD noise and catching issues earlier. Supports a "zero bugs" culture by integrating with Git hooks or CI pipelines.
Build vs. Buy Decision: Replaces fragmented tooling (e.g., manual phpcs, parallel-lint, php-cs-fixer commands) with a single, maintained package. Lowers maintenance burden compared to custom scripts.
Legacy Code Modernization: Enforces modern PHP standards (PHP 7.2+) during refactoring, ensuring compatibility with Laravel’s evolving ecosystem (e.g., PHP 8.x features, Symfony components).
Scaling Laravel Ecosystem: Works alongside other Laravel tools (e.g., PestPHP, Laravel Pint) to create a cohesive QA pipeline. Can be extended to include Laravel-specific sniffs or custom rulesets.
CI/CD Optimization: Reduces flaky tests and failed deployments caused by linting errors, improving team velocity. Integrates with Laravel Forge, Envoyer, or custom CI setups via composer qa.

When to Consider This Package

Adopt if:
- Your team uses Laravel and lacks standardized code quality checks.
- You want to reduce manual code reviews for style/format issues (e.g., indentation, braces, PSR-12 compliance).
- Your CI/CD pipeline is bloated with redundant linting steps (e.g., separate phpcs, parallel-lint jobs).
- You’re onboarding new developers and need a low-friction way to enforce consistency.
- Your project uses PHP 7.2+ and aligns with PSR-12 or similar standards.
- You prefer Composer-based workflows over IDE-specific tools (e.g., PHPStorm inspections).
Avoid if:
- Your team requires custom coding standards beyond PSR-12 (e.g., company-specific rules). The package’s ninjify/coding-standard dependency may not be extensible enough.
- You’re using PHP < 7.2 or need PHP 8.x-specific features (e.g., attributes, union types). The package supports PHP 7.2+, but Laravel’s modern features may not be fully validated.
- You already have a dedicated CI tool (e.g., GitHub Actions, CircleCI) with built-in PHP linting, and adding this would create redundancy.
- Your project relies on real-time linting (e.g., IDE plugins, VSCode extensions) over CLI-based checks.
- You need Laravel-specific integrations (e.g., Artisan commands, service provider hooks). This package is PHP-agnostic and doesn’t natively support Laravel’s ecosystem.
- Your team lacks Composer script adoption or prefers explicit tooling (e.g., make:lint Artisan commands).
Consider Alternatives if:
- You need Laravel-native tooling: Use laravel-pint for auto-formatting or phpstan/phpstan for static analysis.
- You want modern PHP 8.x support: Evaluate dealerdirect/phpcodesniffer-composer-installer or slevomat/coding-standard.
- You prioritize customizability: Build a custom phpcs.xml ruleset or use rector/rector for refactoring.

How to Pitch It (Stakeholders)

For Executives (Business/ROI Focus)

*"This package is a force multiplier for our Laravel development team. By automating code quality checks—like spellcheck for PHP—we’ll:

Save 10–15 hours/week in manual code reviews (no more debates over indentation or brace styles).
Reduce production bugs caused by linting errors (e.g., malformed emails, broken routes) by 80% through pre-commit enforcement.
Lower onboarding time for new hires by 30% with consistent, automated standards.
Future-proof our codebase by enforcing modern PHP practices (PHP 7.2+) as we scale Laravel features. Cost: Zero. It’s a Composer package—no new infrastructure. Payback: Immediate productivity gains."*

For Engineering Leaders (Technical Strategy)

*"This replaces three separate tools (phpcs, parallel-lint, php-cs-fixer) with a single, Laravel-friendly package. Key advantages:

Unified QA pipeline: One command (composer qa) runs linting, fixing, and sniffing—faster than manual checks and CI-ready.
Git integration: Fails builds for non-compliant code (like pre-commit but built-in), reducing CI/CD noise.
Low maintenance: Updates automatically via Composer; no need to manage custom scripts or forks.
Extensible: Supports custom rulesets if we need to tweak standards later (e.g., for Laravel-specific sniffs). Tradeoff: Less configurable than rolling our own, but saves 5+ hours/week in tooling overhead. Recommended for Phase 2 of our Laravel modernization roadmap."*

For Developers (Day-to-Day Impact)

*"No more ‘it works on my machine’ excuses for linting errors. This package:

Auto-fixes common issues (e.g., missing semicolons, wrong indentation) with codefixer—no manual edits needed.
Works with Laravel’s structure: Auto-targets app/, src/, and tests/ folders (excludes vendor/ by default).
Zero config: Just composer require ninjify/qa and add composer qa to your workflow.
CI-friendly: Runs in seconds (parallel linting) and integrates with Laravel’s GitHub Actions templates. Downside: You’ll have to fix more warnings upfront, but it’s worth it for cleaner, more maintainable code. Try it in your next PR!"*

For QA/DevOps (CI/CD Integration)

*"This package streamlines our Laravel CI pipeline by consolidating linting into a single step. Benefits:

Reduces CI job time by 40% (parallel linting + combined output).
Eliminates flaky tests caused by linting errors (e.g., phpcs failures in phpunit jobs).
Works with Laravel Forge/Envoyer: Add composer qa to your deploy scripts to catch issues pre-deploy.
Supports custom thresholds: Fail builds only on critical errors (e.g., phpcs --warning-severity=5). Recommendation: Replace separate phpcs and parallel-lint jobs with composer qa in our GitHub Actions workflow."*

Qa Laravel Package