Laravel Boost 2.0: AI That Finally Understands Your Laravel Code

If you’ve ever watched an AI assistant confidently generate Laravel code that completely ignores framework conventions, you know the frustration. Raw facades instead of dependency injection. Query builders where Eloquent relationships belong. Controllers that look like they were written for a different framework entirely.

Laravel Boost 2.0 solves this problem by giving AI assistants something they’ve desperately needed: context. Real, deep understanding of your Laravel application’s structure, your database schema, your routes, and the idiomatic patterns that make Laravel code clean and maintainable.

After integrating Laravel Boost into my Yojahny CRM project - a Laravel 12 application with Inertia.js, Vue 3, and complex business logic - I’ve seen firsthand how it transforms AI-assisted development from “helpful but needs heavy editing” to “nearly production-ready on first generation.”

This comprehensive guide covers everything you need to know about Laravel Boost 2.0: the new skills system, the powerful MCP server with 15+ tools, AI guidelines that teach agents Laravel best practices, and practical tips for getting the most out of AI-assisted Laravel development.

Who This Guide Is For

This guide is designed for:

Laravel developers frustrated with AI assistants that don’t understand framework conventions
Teams adopting AI coding tools (Claude Code, Cursor, GitHub Copilot) who want Laravel-specific intelligence
Developers building Laravel 10, 11, or 12 applications who want to accelerate development with AI assistance
Technical leads evaluating AI development tools for Laravel projects
Full-stack developers working with Laravel backends and Inertia/Livewire frontends

You should be comfortable with Laravel basics (routing, controllers, Eloquent) and have some experience with AI coding assistants. No prior Boost experience required - we’ll start from installation.

What is Laravel Boost?

Laravel Boost is Laravel’s official package for AI-assisted development. It’s not just another code generation tool - it’s an MCP (Model Context Protocol) server that provides AI agents with deep insight into your application’s structure, along with composable guidelines and skills that teach agents how to write idiomatic Laravel code.

Think of it as giving your AI assistant a Laravel certification and access to your application’s internals.

Three Core Components

MCP Server - 15+ specialized tools that let AI agents query your database, inspect routes, read logs, execute Tinker commands, and understand your application structure
AI Guidelines - Composable instruction files loaded upfront that teach agents Laravel best practices, Livewire patterns, Pest testing conventions, and more
Agent Skills - On-demand knowledge modules (new in v2.0) that provide detailed implementation patterns for specific domains like Livewire components or Inertia forms

Supported AI Tools

Laravel Boost works with all major AI coding assistants:

Claude Code (Anthropic’s CLI tool)
Cursor (AI-first code editor)
GitHub Copilot (VS Code integration)
Codex (OpenAI’s CLI)
Gemini CLI (Google’s assistant)
Junie (JetBrains integration)

The MCP protocol ensures consistent behavior across all these tools - your Laravel application context travels with your AI assistant regardless of which editor you use.

What’s New in Laravel Boost 2.0

Version 2.0, released January 26, 2026, introduces the Skills system - the most significant upgrade since Boost’s initial release. Here’s what changed:

The Skills Revolution

In v1.x, all context was loaded through guidelines - comprehensive instruction files that taught AI agents about Laravel ecosystem packages. The problem? Loading guidelines for Livewire, Inertia, Pest, Tailwind, and a dozen other packages simultaneously consumed massive amounts of context tokens, even when you only needed help with one specific area.

Skills solve this elegantly. They’re lightweight, on-demand knowledge modules activated only when working on specific domains. Instead of loading everything upfront, AI agents now load focused skills when they’re relevant.

Guidelines vs Skills: Understanding the Difference

Aspect	Guidelines	Skills
When Loaded	Upfront, always in context	On-demand, when relevant
Purpose	Core conventions, foundational rules	Detailed implementation patterns
Token Usage	Higher (always present)	Lower (loaded selectively)
Reliability	Guaranteed in agent memory	Must activate explicitly
Best For	Framework fundamentals	Task-specific knowledge

Practical example: When writing a Pest test, you’d previously have Livewire guidelines consuming context even though you’re not touching Livewire code. Now, only the pest-testing skill loads, giving the agent more focused knowledge and more room for your actual code context.

New `boost:add-skill` Command

Version 2.0 introduces a powerful command for fetching skills from GitHub repositories:

# Install skill from GitHub repo
php artisan boost:add-skill owner/repo

# Install from full URL
php artisan boost:add-skill https://github.com/owner/repo

# Install specific skill path
php artisan boost:add-skill owner/repo/.ai/skills/custom-skill

This enables the Laravel community to share specialized skills for packages, custom workflows, and domain-specific patterns.

Cleaner Architecture

The generated CLAUDE.md files are now significantly smaller - around 292 lines compared to 500-700 lines in v1.x. This reduction comes from moving detailed implementation patterns into skills while keeping only foundational rules in guidelines.

First-Class Sail Support

When Boost detects Laravel Sail in your project, agent instructions automatically switch to Sail-specific commands. Instead of php artisan migrate, agents use sail artisan migrate. This eliminates the common frustration of AI-generated commands that work locally but fail in Sail environments.

Installation Guide

Getting started with Laravel Boost takes under two minutes.

Requirements

Laravel 10, 11, or 12
PHP 8.1 or higher

Basic Installation

# Install the package
composer require laravel/boost --dev

# Run the installation wizard
php artisan boost:install

The installation wizard asks which AI agents you use and generates the appropriate configuration files.

Agent-Specific Configuration

For Claude Code:

claude mcp add -s local -t stdio laravel-boost php artisan boost:mcp

For Cursor:

Open command palette (Cmd+Shift+P or Ctrl+Shift+P)
Search for “open MCP Settings”
Toggle on laravel-boost

For GitHub Copilot (VS Code):

Command palette → “MCP: List Servers”
Navigate to laravel-boost → Press Enter
Select “Start server”

For Gemini CLI:

gemini mcp add -s project -t stdio laravel-boost php artisan boost:mcp

Keeping Boost Updated

AI guidelines and skills should stay synchronized with your installed package versions. Add this to your composer.json for automatic updates:

{
  "scripts": {
    "post-update-cmd": [
      "@php artisan boost:update --ansi"
    ]
  }
}

Or run manually after updating packages:

php artisan boost:update

MCP Server: 15+ Tools for AI Agents

The MCP server is where Laravel Boost’s power becomes tangible. It exposes specialized tools that give AI agents real-time access to your application’s internals.

Available Tools

Tool	What It Does
Application Info	Returns PHP/Laravel versions, installed packages, Eloquent models
Database Query	Executes queries against your database
Database Schema	Reads complete database schema including relationships
List Routes	Inspects all registered routes with middleware
List Artisan Commands	Shows available Artisan commands
Get Config	Retrieves config values using dot notation
Search Docs	Queries Laravel’s semantic documentation API
Tinker	Executes arbitrary code in your application context
List Available Config Keys	Shows all configuration keys
List Available Env Vars	Returns environment variable keys
Get Absolute URL	Converts relative URIs to absolute URLs
Last Error	Reads the most recent application error
Read Log Entries	Returns the last N log entries
Browser Logs	Reads browser-side logs and errors
Database Connections	Inspects configured database connections

Why This Matters

Without MCP tools, AI assistants make assumptions about your application. With them, they can:

Query your actual schema before suggesting migrations
See your routes before generating controllers
Understand your models before writing relationships
Execute test code to verify suggestions work

In my Yojahny CRM project, the Database Schema tool was invaluable. When asking Claude Code to add a new feature to the project’s nine-stage lifecycle engine, it first queried the schema to understand the existing projects, tasks, and notification_logs tables before generating code that actually fit the existing architecture.

Manual MCP Configuration

If automatic setup doesn’t work, add this to your .mcp.json:

{
    "mcpServers": {
        "laravel-boost": {
            "command": "php",
            "args": ["artisan", "boost:mcp"]
        }
    }
}

AI Guidelines: Teaching Agents Laravel Conventions

Guidelines are composable instruction files that load upfront to provide AI agents with foundational knowledge about Laravel ecosystem packages.

Built-in Guidelines

Laravel Boost includes guidelines for the entire Laravel ecosystem:

Package	Supported Versions
Laravel Framework	core, 10.x, 11.x, 12.x
Livewire	core, 2.x, 3.x, 4.x
Flux UI	core, free, pro
Inertia React/Vue	core, 1.x, 2.x
Pest	core, 3.x, 4.x
Tailwind CSS	core, 3.x, 4.x
Pint	core
PHPUnit	core
Folio	core
Volt	core
Pennant	core
And more…

Guidelines are version-aware - agents receive instructions appropriate for your exact package versions. If you’re on Livewire 4.x, agents won’t suggest deprecated Livewire 2.x patterns.

Creating Custom Guidelines

Add custom guidelines to .ai/guidelines/ in your project root:

.ai/guidelines/
├── project-conventions.md
├── api-design-rules.md
└── testing-standards.blade.php

Guidelines can be Markdown or Blade templates. Blade templates support dynamic content:

## Project Conventions

This project uses {{ config('app.name') }} conventions.

### Database Naming
- Tables use snake_case plural names
- Foreign keys follow `{table}_id` pattern
- Pivot tables alphabetize: `project_user`, not `user_project`

@if(class_exists(\App\Models\Project::class))
### Project Model
The Project model uses a nine-stage lifecycle enum for status tracking.
@endif

Overriding Built-in Guidelines

To customize Boost’s default behavior, create a file matching its path structure:

# Override Inertia React v2 form guidance
.ai/guidelines/inertia-react/2/forms.blade.php

Your override completely replaces the built-in guideline, giving you full control over what agents learn about that topic.

Agent Skills: On-Demand Knowledge Modules

Skills are v2.0’s headline feature - lightweight knowledge modules that load only when needed.

Available Skills

Skill	Package
`fluxui-development`	Flux UI
`livewire-development`	Livewire
`inertia-react-development`	Inertia React
`inertia-vue-development`	Inertia Vue
`pest-testing`	Pest
`tailwindcss-development`	Tailwind CSS
`folio-routing`	Folio
`volt-development`	Volt
`wayfinder-development`	Wayfinder
`pennant-development`	Pennant
`mcp-development`	MCP

Activating Skills

Skills don’t load automatically - you need to tell your AI assistant when to use them. This is intentional: it keeps context focused and ensures the right knowledge loads at the right time.

Be explicit in your prompts:

"Activate the pest-testing skill and help me write feature tests
for the ProjectController."

"Using the livewire-development skill, create a real-time search
component for the projects list."

"Activate inertia-vue-development. I need to build a form with
proper validation error handling."

Creating Custom Skills

Skills live in .ai/skills/{skill-name}/SKILL.md:

---
name: crm-development
description: Build features for the Yojahny CRM project workflow system.
---

# CRM Development Skill

## When to use this skill
Use this skill when working with:
- Project lifecycle state transitions
- Client portal features
- Notification dispatch
- Invoice generation

## Project Status Enum
Projects follow a nine-stage lifecycle:
- Draft → Proposal Sent → Accepted → In Progress → Staging Review
- → Staging Approved → Production Ready → Delivered → Paid

## Code Patterns

### Status Transitions
Always use the ProjectService for status transitions:

```php
$projectService->transitionTo($project, ProjectStatus::InProgress);

Never update status directly on the model.

Notifications

Use the notification logging system:

$project->logNotification(
    recipient: $client->email,
    channel: 'email',
    type: 'project_status_updated'
);


### Third-Party Package Skills

Package authors can ship skills with their packages by adding:

resources/boost/skills/{skill-name}/SKILL.md


When users install the package and run `boost:update`, the skill becomes available.

## Documentation API: 17,000+ Pieces of Laravel Knowledge

Laravel Boost includes a powerful documentation API with semantic search capabilities. This isn't just text search - it uses embeddings to find conceptually relevant documentation even when your query doesn't match exact keywords.

### Supported Documentation

| Package | Versions |
|---------|----------|
| Laravel Framework | 10.x, 11.x, 12.x |
| Livewire | 1.x, 2.x, 3.x, 4.x |
| Filament | 2.x, 3.x, 4.x, 5.x |
| Inertia | 1.x, 2.x |
| Flux UI | 2.x Free, 2.x Pro |
| Pest | 3.x, 4.x |
| Tailwind CSS | 3.x, 4.x |
| Nova | 4.x, 5.x |

### How It Works

When you ask an AI assistant a Laravel question, it can use the **Search Docs** MCP tool to query this API. The semantic search finds relevant documentation even for conceptual questions:

- "How do I handle race conditions in Laravel?" → Finds atomic locks, database transactions, queue job documentation
- "Best way to structure a multi-tenant app" → Finds scopes, middleware, tenant identification patterns

Guidelines and skills automatically instruct agents to use this API, so you don't need to manually tell them to search documentation.

## Pro Tips for Maximum Effectiveness

After weeks of using Laravel Boost on production projects, here are the patterns that make the biggest difference:

### 1. Be Explicit About Skill Activation

Don't assume agents will load the right skill automatically. Start complex tasks with explicit activation:

“Activate the pest-testing skill. I need to test the portal code validation with rate limiting - the validation logic is in PortalController@validateCode.”


### 2. Let Agents Query Your Application First

Before asking for code generation, let the agent understand your application:

“Before writing this feature, query the database schema for the projects and tasks tables, and list the routes under the admin prefix.”


This prevents AI from making assumptions that conflict with your existing architecture.

### 3. Reference Existing Patterns

Point agents to existing code that demonstrates your patterns:

“Look at App\Services\NotificationService for our notification pattern. Create a similar service for invoice generation.”


### 4. Use Custom Skills for Project Conventions

For projects with unique patterns (like the [Yojahny CRM's](/projects/yojahny-crm) nine-stage lifecycle), create custom skills that document your specific conventions. This is more effective than explaining patterns in every prompt.

### 5. Automate Boost Updates

Don't let your AI guidelines fall behind your packages:

```json
{
  "scripts": {
    "post-update-cmd": [
      "@php artisan boost:update --ansi"
    ]
  }
}

6. Combine MCP Tools for Complex Tasks

The best results come from chaining MCP tool usage:

"First, use the database schema tool to understand the invoice table
structure. Then check the routes for existing invoice endpoints.
Finally, generate an InvoiceResource that follows Laravel JSON
resource best practices."

Real-World Results: Yojahny CRM Case Study

To illustrate Laravel Boost’s impact, here’s how it transformed development on my Yojahny CRM project.

Before Boost

When asking Claude Code to add a notification retry feature, it generated:

A notification system that didn’t integrate with my existing NotificationService
Database migrations with column names that didn’t match my naming conventions
Controllers that bypassed my service layer architecture

I spent more time adapting AI-generated code than writing it from scratch.

After Boost

With Laravel Boost installed and custom skills documenting my CRM conventions:

AI queries my actual schema before suggesting changes
Generated code follows my service layer pattern
Notifications integrate with my existing logging system
Inertia components match my Vue/TypeScript patterns

The difference is dramatic: AI-generated code now requires minor adjustments rather than major rewrites.

Specific Improvements

Task	Before Boost	With Boost
Add new project status	45 min editing AI output	10 min minor tweaks
Create Pest test suite	Generated PHPUnit instead	Correct Pest syntax
Inertia form component	Wrong validation pattern	Proper useForm usage
Service layer method	Put logic in controller	Used service pattern

Troubleshooting Common Issues

MCP Server Not Connecting

If your AI assistant can’t connect to the MCP server:

Verify Boost is installed: composer show laravel/boost
Check the MCP command works: php artisan boost:mcp --help
Ensure your .mcp.json has the correct configuration
Restart your AI assistant/editor

Skills Not Loading

If skills don’t seem to affect AI output:

Be explicit: “Activate the {skill-name} skill for this task”
Verify skill exists: ls .ai/skills/
Run php artisan boost:update to regenerate skills

Outdated Guidelines

If AI suggests patterns from older Laravel versions:

Run php artisan boost:update
Check your composer.json post-update script is configured
Verify package versions match guideline versions

Context Limits Hit

If AI seems to “forget” Laravel patterns mid-conversation:

Use skills instead of loading all guidelines
Start new conversations for unrelated tasks
Be more specific about which packages are relevant

Conclusion: Laravel Leading AI-Assisted Development

Laravel Boost 2.0 represents the most sophisticated integration between a web framework and AI coding assistants available today. By providing real application context through MCP tools, foundational knowledge through guidelines, and task-specific expertise through skills, it solves the fundamental problem of AI assistants generating generic code that ignores framework conventions.

Key Takeaways

Install Laravel Boost to give AI assistants real understanding of your Laravel application
Use the new skills system for focused, context-efficient AI assistance
Leverage MCP tools to let AI query your actual database, routes, and configuration
Create custom skills for project-specific conventions and patterns
Be explicit about skill activation in your prompts for best results
Keep Boost updated to ensure guidelines match your package versions

The Bottom Line

Laravel Boost makes AI assistants “speak Laravel.” Instead of fighting against AI that doesn’t understand your framework, you work with AI that generates code following the same patterns you’d write yourself.

For production Laravel development, this is no longer optional - it’s essential. The productivity gains from AI that understands your codebase compound over every feature, every bug fix, every refactor.

Next Steps

Install Laravel Boost in your Laravel 10, 11, or 12 project
Configure for your AI assistant (Claude Code, Cursor, etc.)
Create custom skills for your project conventions
Experience the difference in AI code quality

Continue Learning

Want to see Laravel Boost in action on a real project? Check out:

Yojahny CRM - Laravel 12 + Inertia.js CRM with complex workflows
Laravel Best Practices Guide - Patterns that work well with AI assistance

Interested in Laravel development for your project? Let’s discuss how modern Laravel architecture and AI-assisted development can accelerate your next build.

Sources:

LARAVEL BOOST 2.0: AI THAT FINALLY UNDERSTANDS YOUR LARAVEL CODE

[TAGS]

[SHARE]