Laravel Boost 2.6.0: The New Testing Best Practices Skill and Smarter Agent Tooling

Laravel Boost 2.6.0 was released on August 25, 2026. This release adds a new Testing Best Practices skill and strengthens several parts of Boost’s MCP and skill tooling.

The update continues Laravel Boost’s focus on practical AI-assisted development. It gives agents better context, safer access to application data, and more reliable project automation.

For PHP developers using Claude Code, Cursor, Codex, or Gemini CLI, Boost is becoming an important part of the modern Laravel workflow.

Laravel is already a productive PHP web framework. Boost adds the project-specific context that AI agents need to work effectively inside it.

Install Laravel Boost 2.6.0

Boost is installed as a development dependency:

composer require laravel/boost --dev

Then run the installer:

php artisan boost:install

The installer detects your project and helps configure supported agents. It can install the MCP server, AI guidelines, and relevant skills based on your application and Composer dependencies.

Boost supports workflows with tools such as:

• Claude Code
• Cursor
• Codex CLI
• Gemini CLI
• GitHub Copilot
• Junie
• PhpStorm

The installer generates the configuration and context files required by the agents you select. Read the Laravel Boost documentation for editor-specific setup instructions.

After installation, update Boost resources when your Laravel application changes:

php artisan boost:update

You can also ask Boost to discover newly installed packages and offer their guidelines or skills:

php artisan boost:update --discover

This is useful after adding packages for authentication, payments, search, administration, or frontend development.

pest-testing: Better tests from AI agents

Laravel Boost 2.6.0 adds the Testing Best Practices skill, named pest-testing.

Skills are task-specific knowledge modules. Unlike broad guidelines, they are activated when an agent works in a particular area. This keeps the agent’s context focused and reduces unnecessary instructions.

The pest-testing skill gives an agent a clearer path when it needs to create or update tests. It helps the agent understand how Laravel projects commonly test:

• HTTP endpoints
• Validation rules
• Authentication and authorization
• Database behavior
• Eloquent models
• Jobs and events
• JSON responses
• Application workflows

That context matters when you ask an agent to build a REST API. Without it, an agent may generate tests that technically run but do not match the application’s style.

With the skill available, a request such as this becomes more useful:

Add feature tests for the order creation endpoint. Follow the existing Pest conventions and cover validation, authentication, and the JSON response shape.

The agent can use the skill alongside your existing test suite. It can inspect how your project names tests, whether it uses test() or it(), which factories are available, and how database state is refreshed between tests.

The result is not a replacement for developer review. It is better guidance at the moment when guidance is most useful.

For example, when building an API with Laravel, you may want tests that verify:

it('creates an order for an authenticated customer', function () {
    $customer = Customer::factory()->create();

    $response = $this
        ->actingAs($customer)
        ->postJson('/api/orders', [
            'product_id' => Product::factory()->create()->id,
            'quantity' => 2,
        ]);

    $response
        ->assertCreated()
        ->assertJsonPath('data.quantity', 2);
});

The exact structure should follow your application. The point of pest-testing is to help the agent discover and apply those patterns instead of inventing a separate testing style.

Laravel Boost already supports Pest-specific guidelines. Version 2.6.0 makes focused testing knowledge available through the skill system as well.

Safer database queries through MCP

Laravel Boost provides an MCP server that lets agents inspect parts of a running Laravel application. Available tools include application information, database schema inspection, logs, routes, configuration, documentation search, and database queries.

In version 2.6.0, the DatabaseQuery MCP tool now runs inside a guaranteed database-enforced read-only transaction.

This is an important safety improvement. A query generated by an AI agent should not be able to modify application data while the agent is inspecting records or debugging behavior.

The change strengthens the boundary at the database level. It does not rely only on the agent understanding that a query should be read-only.

You might ask an agent:

Check whether any pending orders have duplicate customer references.

The agent can inspect the live database state through the MCP tool while the read-only transaction prevents the query from changing that state.

You should still use sensible operational safeguards. Connect agents to local or staging databases when possible, apply least-privilege database credentials, and review any tool configuration before enabling it against production systems.

The release also fixes MySQL schema reads when ANSI_QUOTES is enabled. The MySQL table type is now quoted as a string literal, which avoids an SQL interpretation issue during schema inspection.

Together, these changes make Boost’s database awareness more dependable for debugging API behavior and planning changes.

More reliable skill management

Boost’s skill system lets you provide agents with focused instructions for your application. You can create a custom skill at a path such as:

.ai/skills/creating-invoices/SKILL.md

You can also add skills from other sources with:

php artisan boost:add-skill

Version 2.6.0 fixes two edge cases in this command.

First, boost:add-skill no longer risks deleting the entire skills directory when it encounters a repository-root SKILL.md. This protects projects that use a root skill file alongside a directory of other skills.

Second, the command now accepts any valid skill path shape. It also keeps the audit gate aligned with the path being added.

These fixes matter when teams share skills across repositories or adopt the Agent Skills format. A skill may live in a nested directory, a shared location, or a structure that does not match one narrow path assumption.

The practical result is simpler custom tooling. You can add domain knowledge for billing, inventory, reporting, or internal API conventions without worrying that a path layout will confuse the installer.

Cleaner MCP configuration

Boost can update MCP configuration files for supported agents. Version 2.6.0 fixes a comma-injection issue when adding an MCP server near trailing comments.

Configuration files often contain comments for developers:

{
    "mcpServers": {
        "existing-server": {
            "command": "example"
        }
        // Local development server
    }
}

Automated configuration writers need to preserve valid syntax and respect those comments. The fix keeps the separating comma out of trailing comments when Boost injects a new MCP server.

This is a small change, but configuration writers need to handle small details correctly. A malformed MCP file can prevent an agent from starting before any application code is touched.

A better search-docs path

Boost’s Search Docs MCP tool queries Laravel’s documentation knowledge base based on the packages installed in your application.

That helps agents avoid relying on generic model knowledge when working with version-specific Laravel features. The documentation API includes Laravel and package information, with results shaped around the project’s installed ecosystem.

Version 2.6.0 fixes the query list after filtering. Boost now re-keys the remaining queries correctly.

This prevents filtered query entries from retaining misleading or incorrect indexes. The result is more reliable mapping between a request and the documentation search performed for it.

For a PHP developer, this matters when an agent is deciding between several framework patterns. An agent working on validation, Sanctum authentication, database queries, or Pest tests should retrieve documentation that matches the project context.

Project rules capture your application

Laravel guidelines teach agents how to work with Laravel. Project rules teach them how to work with your application.

Project rules are stored in .ai/rules and should be committed to source control. They can describe decisions that are difficult to infer from code alone.

Examples include:

• All API controllers use a shared base controller.
• Money values are stored as integer cents.
• Every API response uses a specific resource format.
• Tenant scoping must be applied to all model queries.
• Feature tests use a particular factory setup.
• A domain action must be called instead of writing logic inside controllers.

You can record a rule by asking your agent to remember it. Boost uses the record-rule MCP tool and updates the project rules index.

The index maps file patterns to the rules that apply to them. An agent working on app/Http/Controllers/** can load controller rules without adding every application rule to every task.

This keeps instructions focused. It also makes them available to every agent and teammate working in the repository.

Use infer-conventions to bootstrap existing projects

New Laravel applications can define conventions early. Existing applications are more complicated.

They may contain years of decisions spread across controllers, models, tests, migrations, frontend code, and console commands. That is where the infer-conventions skill helps.

Ask an agent:

Use the infer-conventions skill.

Boost scans the application across areas such as:

• Validation
• Controllers
• Authorization
• Models
• Architecture
• Testing
• Frontend code
• Database design
• Console commands
• Shared traits and base classes

The skill documents what the application already does. It does not treat every framework default as a custom convention. It also avoids recording patterns that are inconsistent or already enforced by tools such as Pint or Rector.

Before writing rules, it presents the discovered conventions and supporting evidence for approval.

This is especially helpful when you use AI to build REST APIs with PHP in an established Laravel codebase. The agent can learn whether your project uses action classes, form requests, API resources, service layers, UUIDs, custom pagination, or a particular test layout.

The goal is not to make every Laravel application look the same. The goal is to help agents preserve the application’s existing shape.

A practical Boost workflow for Laravel APIs

A productive workflow can look like this:

1. Install Boost with composer require laravel/boost --dev.
2. Run php artisan boost:install.
3. Enable the Laravel Boost MCP server in your agent.
4. Run php artisan boost:update after dependency updates.
5. Ask infer-conventions to review an existing codebase.
6. Approve useful conventions as project rules.
7. Ask the agent to build an API endpoint.
8. Let pest-testing guide the feature tests.
9. Use database schema and read-only query tools during debugging.
10. Use Search Docs when framework or package behavior needs confirmation.

This workflow combines several of the most useful PHP developer tools in one project context. The agent can inspect the application, read current documentation, follow project conventions, write tests, and query development data safely.

Laravel Boost 2.6.0 is a focused release. Its changes improve testing guidance, database safety, configuration writing, skill management, and documentation lookup.

That is the direction Boost continues to take: less generic AI output, more Laravel-aware development that fits the code already in front of you.