Laravel Pint --test: Check Code Style in CI Without Fixing

If you're using Laravel Pint in CI…

You’ve probably hit this confusion:

“How do I check code style without auto-fixing it?”

Because locally:

→ Pint fixes everything

But in CI:

→ you want to fail the build if code is not formatted

That’s where laravel pint test dry run comes in.

And yes — the docs don’t make this obvious.

What Does -test Actually Do in Laravel Pint?

This is the key flag:

./vendor/bin/pint --test

What It Does

• checks code formatting

• does NOT modify files

• exits with non-zero status if issues found

What That Means in CI

• clean code → build passes

• formatting issues → build fails

Real Insight

--test turns Pint from a formatter into a validator

Why You Should Use Pint in CI/CD

Code style is not just aesthetics.

It’s:

• consistency across teams

• easier code reviews

• fewer merge conflicts

What You Get

• Reviews focus on logic instead of spacing and brace style

• Fewer merge conflicts caused by formatting-only changes

• New developers match the team style from their first pull request

The Problem Without -test

If you run:

./vendor/bin/pint

In CI:

• it auto-fixes files

• CI environment doesn’t commit changes

• results become inconsistent

Result

→ unreliable pipelines

Correct Approach

Always use:

./vendor/bin/pint --test

Basic CI Example (GitHub Actions)

Here’s a clean setup:

name: Pint Check

on: [push, pull_request]

jobs:
  pint:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0   # full history, so --diff can compare with main

      - name: Setup PHP
        uses: shivammathur/setup-php@v2
        with:
          php-version: '8.4'   # use your app's PHP version

      - name: Install dependencies
        run: composer install --no-interaction --no-progress --prefer-dist

      - name: Run Pint (test mode)
        run: ./vendor/bin/pint --test

GitLab CI Example

pint:
  script:
    - composer install
    - ./vendor/bin/pint --test

Common Mistakes Developers Make

Running Pint Without -test

Leads to:

• silent fixes

• inconsistent CI

Ignoring Exit Codes

CI must fail if formatting fails.

Not Standardizing Rules

Different configs = chaos

Customizing Pint Rules (CI Friendly)

You can define rules in:

pint.json

Example

{
  "preset": "laravel",
  "rules": {
    "array_syntax": {
      "syntax": "short"
    }
  }
}

Best Practice

• keep rules minimal

• align with team standards

Pre-Commit Hook (Prevent CI Failures)

Instead of failing CI…

Fix issues before push.

Example

./vendor/bin/pint

Run locally before commit.

Better Workflow

• local → auto-fix

• CI → validate

Combining Pint with Other Tools

For full quality pipeline:

• Pint → code style

• PHPStan → static analysis

• PHPUnit → tests

Real Insight

Pint ensures readability.

Other tools ensure correctness.

Performance Tip (Speed Up CI)

Run Pint only on changed files:

./vendor/bin/pint --test --diff=origin/main

Result

• faster CI

• less resource usage

Where StackMivo Fits In

Here’s the modern advantage.

Instead of:

• fixing formatting manually

• relying on CI failures

You generate:

→ clean code from the start

What This Means

StackMivo:

• follows Laravel coding standards

• applies Pint-compatible formatting

• reduces CI failures

If you want to understand how this works, this guide on how StackMivo generates production grade Laravel code explains it in detail.

Real Workflow (Modern Laravel Teams)

Instead of:

• write code

• fail CI

• fix formatting

You:

• generate clean code

• validate in CI

• ship faster

CI Should Enforce, Not Fix

That’s the mindset shift.

• local → fix

• CI → enforce

Making Pint Failures Developer-Friendly (Actionable CI Output)

One of the biggest frustrations with Pint in CI is this:

→ it fails… but doesn’t clearly tell developers what to fix

That slows teams down.

The Problem

Default output:

• raw CLI logs

• hard to scan in large PRs

Result:

→ developers waste time finding issues

The Better Approach

Run Pint in verbose mode:

./vendor/bin/pint --test -v

-v lists every file that fails and shows the change Pint wants, so developers can see exactly what to fix.

Why This Matters

When the CI log shows the exact change, developers fix it in one push instead of guessing.

Even Better: Show Diff in CI

You can enhance visibility by running:

./vendor/bin/pint--test--diff

Why This Matters

Now developers see:

• exactly which file failed

• what needs to change

• before/after formatting

Real Impact

Teams that improve CI feedback loops:

→ reduce fix time by 30–50%

Pro Tip

Combine with PR comments (GitHub Actions tools):

→ auto-comment formatting issues directly on PR

Insight

CI should not just fail — it should guide developers to fix faster.

Enforcing Code Style at Scale (Monorepo & Multi-Team Strategy)

This is where most teams struggle.

Pint works great…

Until your codebase grows.

Problem

In larger teams:

• multiple developers

• multiple services

• inconsistent configs

Result:

→ formatting drift

Solution: Centralized Pint Strategy

1. Single Source of Truth

Keep one pint.json at root.

Avoid:

→ multiple configs

2. Enforce via CI Only (Not Optional)

Make Pint:

→ mandatory check

No bypass.

3. Version Lock Pint

Use fixed version:

composer require laravel/pint:^1.0

Why?

Different versions:

→ different formatting

4. Run Pint Only on Changed Files

In large repos:

gitdiff--name-only origin/main |grep .php | xargs ./vendor/bin/pint--test

Why It Helps

On a large repo, checking only changed files keeps the Pint step fast as the codebase grows.

5. Combine with Pre-Commit Hooks

CI enforcement is good.

But prevention is better.

Real Insight

The best teams don’t fix formatting in CI, they prevent bad formatting from reaching CI.

Running Pint is easy. Making it work well across a team is where most projects fail.

Laravel Pint CI Workflow (Fail → Fix → Pass)

Developer writes code
        │
        ▼
Runs locally (optional)
        │
        ▼
Push to GitHub / GitLab
        │
        ▼
CI Pipeline Starts
        │
        ▼
Run: pint --test
        │
        ▼
Is formatting correct?
   ┌───────────────┐
   │               │
   ▼               ▼
 YES             NO
 │                │
 ▼                ▼
Build Pass     Build Fails
 │                │
 ▼                ▼
Merge PR      Developer checks CI logs
                    │
                    ▼
          Run locally: pint
                    │
                    ▼
          Fix formatting issues
                    │
                    ▼
          Commit & push again
                    │
                    ▼
              CI runs again
                    │
                    ▼
               Build Pass 

What This Actually Teaches (Important)

This diagram clarifies something many teams get wrong:

Wrong Thinking

“CI will fix formatting”

Correct Workflow

• local → fix

• CI → validate

Optimized Team Workflow (Pro Version)

If you want to go one level deeper:

Developer writes code
        │
        ▼
Pre-commit hook runs Pint
        │
        ▼
Code already formatted 
        │
        ▼
Push to CI
        │
        ▼
CI runs pint --test
        │
        ▼
Always passes (no surprises)

Real Impact

Formatting gets fixed before the push, so the CI check rarely fails and reviews stay free of style comments.

How StackMivo Helps You Avoid Pint CI Failures Entirely

Here’s the reality:

Most teams don’t struggle with Pint.

They struggle with:

• inconsistent code style

• repeated CI failures

• wasted time fixing formatting

Traditional Workflow (What Happens Today)

1. Developer writes code

2. Pushes PR

3. CI runs Pint

4. Build fails

5. Developer fixes formatting

6. Push again

This loop:

→ wastes time

→ slows delivery

→ creates friction

StackMivo Workflow (What Changes)

With StackMivo:

1. You describe what you want

2. Code is generated

3. Code already follows Laravel standards

4. CI passes on first attempt

Why This Works

StackMivo doesn’t just generate code.

It generates:

• Laravel-convention-aligned structure

• clean formatting (Pint-compatible)

• consistent patterns across files

Real Impact

Generated code starts out Pint-compatible, so fewer pull requests fail the style check. Keep pint --test in CI anyway: it also catches hand-written changes.

What This Means Practically

Instead of:

→ fixing code after writing

You:

→ generate clean code from the start

Strategic Shift (Important)

This is the real mindset change:

Code quality is no longer something you enforce after development, it’s something you generate by default.

Where This Fits in Your Workflow

Combine:

• StackMivo → clean code generation

• Pint (-test) → CI validation

Result:

→ zero-friction code quality pipeline

The fastest teams don’t write better code, they start with better code.

Quick Summary

• use -test in CI

• fail builds on style issues

• fix locally

AI-Generated Clean Code

If you want:

• fewer CI failures

• consistent formatting

• faster development

Generate clean Laravel code with StackMivo