# Laravel Starter Kit: a strict, fully typed skeleton for Laravel

> Laravel Starter Kit is a skeleton from Nuno Maduro that treats PHP as a strongly typed language, with every method and parameter typed, PHPStan at level 9, a 100 percent type coverage check, Rector and Pint wired in, and a Bun based frontend toolchain. It suits teams who want the strictness to be enforced by tooling rather than by convention.

**nunomaduro/laravel-starter-kit** — Laravel Starter Kit is an ultra-strict, type-safe Laravel skeleton engineered for developers who refuse to compromise on code quality.

- Repository: https://github.com/nunomaduro/laravel-starter-kit
- Website: https://youtube.com/@nunomaduro?sub_confirmation=1
- Stars: 887 · Forks: 127
- Language: Blade
- License: not declared
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/nunomaduro-laravel-starter-kit

## The claim is that PHP can be built like Rust or TypeScript

The positioning is unusually direct, and it explains the design decisions better than the feature list does. Laravel Starter Kit is an ultra-strict, type-safe Laravel skeleton engineered for developers who refuse to compromise on code quality, and it enforces rigorous development standards through tooling configuration and architectural decisions that prioritise type safety, immutability and fail-fast principles. The stated premise is that modern PHP has evolved into a mature, type-safe language, yet many Laravel projects still operate with loose conventions and optional typing. The closing line of the section is the thesis, that this is not just another Laravel boilerplate but a statement that PHP applications can and should be built with the same rigor as strongly typed languages like Rust or TypeScript. That is a claim about discipline rather than about the language, and the interesting part is that it is enforced mechanically, which is the subject of the rest of the configuration.

## Six properties, and the ones that can be checked

The reasons the kit exists are listed as a set of properties, and they split into those that are conventions and those that a tool can verify. Every method, property and parameter is explicitly typed, and there is a type coverage command that ensures 100 percent type coverage with Pest, so that one is checked rather than trusted. The zero tolerance for code smells is delivered by Rector and PHPStan at maximum strictness, with PHPStan running at level 9, and again there is a command for it. The immutable-first architecture is a design decision the code follows, with data structures favouring immutability to prevent unexpected mutations, and it is a convention rather than something a linter can prove. The fail-fast philosophy is the framing for the rest, with errors caught at compile-time rather than at run time. Automated code quality is the pre-configured tooling that ensures consistent code across a team. And the last two are the pragmatic ones, Bun for dependency management and what the readme calls just better Laravel defaults, which it credits to a separate Essentials project, with strict models, auto eager loading and immutable dates among them.

## Three siblings, and only one of them is Blade

The first thing to understand is that the repository you are looking at is one of three. The readme opens by listing them, and the distinction is the frontend stack rather than the backend. This one is the Blade version, and the other two are the Inertia and React version and the Inertia and Vue version, each in its own repository. That matters because the choice is not a preference, it determines what you are building on. A Blade application renders HTML on the server, an Inertia application is a single page application with a PHP backend and a JavaScript frontend, and the two need different tooling. The samples and the configuration in this repository are set up for the Blade case, with the Vite and Tailwind configuration and the resources directory holding the templates. If your team has already decided on Inertia with React or with Vue, this repository is the wrong starting point and one of the siblings is the right one. The reason the three exist separately rather than as a switch is that a skeleton that supports all three ends up supporting none of them particularly well.

## What you run to get started

The requirements are stated before the first command, and they are not minimal. You need PHP 8.4 or newer, Bun, and a code coverage driver such as xdebug. The application is created with Composer:

```bash
composer create-project nunomaduro/laravel-starter-kit --prefer-dist example-app
```

Then the setup inside the project directory, which includes a step that is specific to this kit:

```bash
cd example-app

# Setup project
composer setup

# Record the packages you trust with Laravel Vet
./vendor/bin/vet --init

# Start the development server
composer dev
```

The vet step is worth pausing on, because it is a dependency trust decision rather than a build step. Recording the packages you trust tells the vet tool which dependencies are acceptable, which is a supply chain control rather than a linting one. The development server command is a composed command, since composer dev is described as starting the Laravel server, the queue worker, log monitoring and the Vite development server concurrently, so one command brings up the whole stack. If you plan to use Pest's browser testing capabilities, there is an optional step that installs Playwright through Bun and then fetches its browsers, and the browser tests are the one part of the setup that needs a network download.

## The commands are the specification

The tooling section is the part of the readme that tells you what you are signing up for, because each command is a threshold that can fail your build. The development command starts the server, the queue worker, log monitoring and the Vite development server concurrently. The lint command runs Rector for refactoring, Pint for PHP formatting and Oxfmt for JavaScript and TypeScript formatting, and there is a dry-run variant of it for CI and CD pipelines so the same checks can run without rewriting files. The type coverage command ensures 100 percent type coverage with Pest. The types command runs PHPStan at level 9, described as maximum strictness. The unit test command runs Pest tests with a 100 percent code coverage requirement. The full test command runs the complete suite, which is linting, static analysis, type coverage and unit tests together. And there is a maintenance command that updates all PHP and Bun dependencies to their latest versions. The verification step at the end of the install says you should see 100 percent test coverage and all quality checks passing, which is a fair statement of the bar this skeleton sets.

## What the repository actually contains

The file list is the clearest evidence of the philosophy, because it is a Laravel application with the strictness tooling sitting alongside the application code. There is a phpstan.neon for the static analysis configuration and a rector.php for the refactoring rules, plus pint.json for the code style, a phpunit.xml for the test configuration, a vitest.config.mjs for the JavaScript side, a vite.config.ts and a bunfig.toml for the frontend build, and a boost.json for the Boost tooling. The application code itself is in the usual Laravel layout with app, bootstrap, config, database, resources, routes, storage and tests directories, and the .env.example shows the defaults, which are worth reading as a set of opinions rather than as boilerplate. The database connection is sqlite, and the session, queue and cache drivers are all set to database, the log channel is stack with deprecations silenced, the mailer is log, the filesystem disk is local and the broadcast connection is log. In other words the defaults keep the application self-contained with no external services required to run it, which is the same instinct that puts a coverage driver in the requirements.

## Conclusion

Laravel Starter Kit is a good fit for a team that has been burned by optional typing in PHP and wants the strictness baked into the skeleton rather than argued about in review, because every one of the checks is a command you can run and a threshold you cannot pass by accident. It is the wrong tool for a project on an older PHP version, since it requires PHP 8.4 or newer, and it is the wrong tool for a team that has no appetite for Rector rewriting your code, because the refactoring tool is part of the default lint command rather than an opt-in. It is also the wrong tool if your team does not know PHPStan, because level 9 is a wall for newcomers. Before adopting it, read the three sibling variants, since there is a Blade version, an Inertia and React version and an Inertia and Vue version, and pick the one matching your frontend. The project is under the MIT license according to the readme, the last push was on 2026-10-18, and the current release is v1.9.0 from 2026-09-27.

## FAQ

### What does the Laravel Starter Kit enforce out of the box?

It enforces 100 percent type coverage with every method, property and parameter explicitly typed, a type coverage check run with Pest, PHPStan at level 9 for static analysis, Rector and Pint for refactoring and formatting, and unit tests with a 100 percent code coverage requirement. The failing commands are the specification, and the readme says a successful run shows full coverage with all quality checks passing.

### Which versions of PHP and Laravel does the Laravel Starter Kit need?

The requirements are PHP 8.4 or newer, Bun, and a code coverage driver such as xdebug. The package is on Packagist as nunomaduro/laravel-starter-kit, and the frontend toolchain is configured through a package.json that uses Vite with Tailwind and a Bun devEngines entry pinning the package manager version.

### What is the difference between the Blade, Inertia React and Inertia Vue starter kits?

The frontend stack, not the backend. The Blade version is this repository, the Inertia and React version and the Inertia and Vue version live in separate repositories, and the readme lists all three at the top. The choice determines which one you start from, since the samples, the resources directory and the Vite configuration in this repository are set up for the Blade case.

### How do I create and run a Laravel Starter Kit application?

With composer create-project naming the package and the prefer-dist flag and a target directory, then inside the project run composer setup, initialise the vet trust list with the vendor bin vet init command, and start everything with composer dev, which runs the Laravel server, the queue worker, log monitoring and the Vite development server concurrently.

### What does composer dev do in the Laravel Starter Kit?

It starts the Laravel server, the queue worker, log monitoring and the Vite development server concurrently. There are also lint, test, test:lint, test:type-coverage, test:types, test:unit and update:requirements commands, and the full test command runs linting, static analysis, type coverage and unit tests together.

## Sources

- [Issues](https://github.com/nunomaduro/laravel-starter-kit/issues)
- [nunomaduro/laravel-starter-kit on GitHub](https://github.com/nunomaduro/laravel-starter-kit)
- [Project website](https://youtube.com/@nunomaduro?sub_confirmation=1)
- [README](https://github.com/nunomaduro/laravel-starter-kit/blob/main/README.md)
- [Releases](https://github.com/nunomaduro/laravel-starter-kit/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/nunomaduro-laravel-starter-kit