Laravel Skills Directory: AI Agent Skills That Think Like a Laravel Developer

If you have spent time using Claude Code, Cursor, or another AI coding agent on a Laravel project, you have probably noticed a pattern: the agent knows PHP, it knows general web patterns, but it does not know your project’s conventions. It does not know you use Livewire components a specific way, that your team follows a particular pattern for service classes, or that you always write Pest tests in a certain structure. Every session starts from scratch.

The Laravel Skills directory at skills.laravel.cloud is a direct answer to this problem. Launched in February 2026 as an open directory of reusable AI agent skills for Laravel and PHP, it gives your agent a vocabulary it was missing.

What Are Agent Skills, Exactly?

Before diving into the directory itself, it helps to understand what an “agent skill” actually is. A skill is a lightweight, targeted knowledge module — a Markdown file containing detailed patterns, best practices, and examples for a specific domain — that your AI agent can load on demand.

The distinction between a skill and a general guideline (like a CLAUDE.md file) is important. Guidelines are loaded upfront at the start of every session. They contain broad conventions and rules that apply across your entire codebase. Skills are different: they activate only when you are working on a specific task. If you are writing a Livewire component, the Livewire skill loads. If you switch to writing a console command, the Livewire skill is no longer consuming your context window.

This on-demand loading is not just a technical detail — it has a real effect on code quality. When an agent has 50 pages of guidelines loaded upfront, relevant information gets diluted. When a precise, focused skill loads at the moment it is needed, the agent’s output reflects that specific knowledge much more consistently.

The Directory: What Is Available

The skills directory currently lists over 140 skills, a mix of official skills (marked with a badge and maintained by the Laravel team or package authors) and community contributions. Official skills cover the core Laravel ecosystem:

Eloquent — relationships, scopes, eager loading patterns, query optimization
Laravel Livewire — component structure, lifecycle hooks, the wire: API
Laravel Volt — single-file component conventions
Pest — dataset patterns, custom expectations, architecture tests
Sanctum / Passport — authentication flows and token management
Laravel Queues — job chaining, batching, failure handling
Inertia.js — the Laravel + Inertia contract for server-driven SPAs

Community skills extend the directory with third-party package support and opinionated workflow patterns. Because the directory is open, package maintainers can submit official skills for their own packages, and the quality bar on official skills tends to be high.

Getting Set Up with Laravel Boost

Skills from the directory are managed through Laravel Boost, which is the official MCP (Model Context Protocol) server for Laravel. Boost is a dev dependency you add to any Laravel 10, 11, or 12 application running PHP 8.2 or higher.

composer require laravel/boost --dev
php artisan boost:install

The boost:install command is interactive. It asks which features you want — guidelines, skills, or the full MCP server — and which AI coding environments you use (Claude Code, Cursor, Windsurf, GitHub Copilot, and others). Based on your selections, it generates the appropriate configuration files automatically.

For Claude Code users, this means a CLAUDE.md file is created at your project root with Laravel-specific guidelines pre-populated. The MCP server wiring is set up in .claude/settings.json. You do not need to manually configure either.

Once Boost is installed, adding skills from the directory is a single command:

php artisan boost:add-skill laravel/livewire
php artisan boost:add-skill laravel/pest
php artisan boost:add-skill laravel/eloquent

Each skill is installed as a file in your project under .agent/skills/. These files can be committed to version control so the whole team gets the same agent behavior, or added to .gitignore if you prefer to generate them fresh via boost:install on each machine.

How Skills Work in Practice

With the Livewire skill installed, the difference in agent behavior becomes visible quickly. Without the skill, asking Claude Code to generate a Livewire component results in generic output that may use deprecated APIs or miss your project’s conventions. With the skill, the agent knows the current Livewire API surface, understands the difference between wire:model and wire:model.live, and generates components that follow the patterns your project expects.

Here is a concrete example. Ask Claude Code to build a searchable table component:

// Without skill: agent might generate this (older Livewire 2 pattern)
class SearchTable extends Component
{
    public $search = '';
    
    public function updatedSearch()
    {
        // manual handling
    }
}

// With Livewire skill loaded: agent generates current Livewire 3 patterns
class SearchTable extends Component
{
    #[Url(as: 'q')]
    public string $search = '';

    public function updatedSearch(): void
    {
        $this->resetPage();
    }

    public function getRowsProperty()
    {
        return Product::query()
            ->when($this->search, fn ($q) => $q->search($this->search))
            ->paginate(25);
    }
}

The skill shifts output from plausible-looking code to production-ready code that reflects how Livewire 3 actually works.

Writing Your Own Skills

The real power of the directory is that it is community-driven. If your project uses a package that does not have an official skill, or if you have developed internal conventions you want to codify, you can write a skill and optionally submit it.

A skill file is Markdown with a structured format. Here is a minimal example for a hypothetical API resource convention:

# API Resource Conventions

## Response Structure
All API responses use Laravel's JsonResource with a consistent envelope:
- Success responses: `{ data: ..., meta: ... }`
- Error responses handled by the global exception handler in `app/Exceptions/Handler.php`

## Resource Classes
- Extend `App\Http\Resources\BaseResource` (not `JsonResource` directly)
- Always include `$this->whenLoaded()` for relationships
- Transformations happen in `toArray()` only — no business logic in resources

## Example
\`\`\`php
class OrderResource extends BaseResource
{
    public function toArray(Request $request): array
    {
        return [
            'id' => $this->id,
            'status' => $this->status,
            'total' => $this->total_formatted,
            'customer' => new CustomerResource($this->whenLoaded('customer')),
            'lines' => OrderLineResource::collection($this->whenLoaded('lines')),
        ];
    }
}
\`\`\`

Once you have a skill file, you can reference it in your agent’s guidelines or install it via Boost. The Laravel Skills GitHub repository at laravel/agent-skills has contribution guidelines if you want to share the skill with the community.

The Broader Picture: Context as Infrastructure

What the Laravel Skills directory represents is a shift in how we think about developer tooling. The AI agent is no longer a generic tool you point at a problem. It becomes a colleague that has been onboarded to your project’s conventions, your team’s preferred packages, and the current best practices for the ecosystem you are working in.

This is especially relevant as Laravel’s ecosystem has grown more opinionated in 2026. Livewire 3, Volt, Folio, Reverb, Pulse — each of these has its own patterns and APIs. Keeping an AI agent current on all of them without skills means either spending time correcting its output constantly or accepting generic code that drifts from what the community considers idiomatic.

The skills approach is a cleaner solution: curated, version-specific knowledge that activates when relevant and stays out of the way when it is not.

If you are using AI tooling in your PHP workflow, the setup cost for Laravel Boost and a few skills from the directory is about ten minutes. The payoff in reduced correction cycles and more idiomatic generated code compounds over every session after that.