Laravel Skills Directory: How to Use AI Agent Skills (And Build Your Own)

If you've been using Claude Code or Cursor with Laravel, you've probably felt the friction. Your AI agent doesn't know your coding conventions. It generates decent code, sure, but it's not your code. It doesn't follow your architecture patterns, your testing approach, or the way you structure Eloquent relationships.

Laravel just solved that problem.

skills.laravel.cloud launched this week as an open directory of reusable AI agent skills for Laravel and PHP developers. Think of it like a package registry, but instead of installing PHP packages, you're installing knowledge modules that teach your AI coding agent how to write better Laravel code. And it works with Claude Code, Cursor, Windsurf, Copilot, and basically every AI coding tool you're already using.

The directory already has 96 skills and it's growing fast. But the real power isn't just browsing and installing pre-made skills. It's building your own. Let me show you the full picture.

What Are Laravel Skills (And How Are They Different From Boost Guidelines?)

This is the first thing that confused me, so let me clear it up.

If you've already set up Laravel Boost and MCP Servers in your project, you're familiar with guidelines. Guidelines are composable instruction files that get loaded upfront into your agent's context. Every session, your agent reads all of them. They're like giving your agent a big handbook before it starts working.

Skills are different. They're targeted knowledge modules that agents activate on-demand when they're working on specific tasks. Your agent sees a list of available skills (just the name and description), and it decides which ones to load based on what you're asking it to do.

Here's why that matters: context window space is expensive. If you dump everything your agent needs to know into guidelines, you're burning tokens on Livewire patterns when you're building an API, or on testing conventions when you're working on migrations. Skills solve this by letting your agent load exactly what it needs, exactly when it needs it.

Quick comparison:

Guidelines load upfront into every session. They're best for core conventions that apply to everything, like your coding style or project structure rules. Skills load on-demand when the agent detects a relevant task. They're best for domain-specific knowledge, like "how to build Pest tests" or "how to use the AI SDK."

Both work together. Guidelines set the baseline. Skills go deep on specific topics.

Browsing the Laravel Skills Directory

Head to skills.laravel.cloud and you'll see the full collection. You can sort by newest or most installed, and there's a search bar at the top.

The directory has two types of skills. Official skills (marked with a star badge) come from the Laravel team and package maintainers. Community skills come from developers like you and me. Some of the most popular community skills right now include laravel-specialist by jeffallan with over 3,200 installs and eloquent-best-practices by iserter.

Here are the categories worth paying attention to:

Official Laravel Skills cover the core ecosystem. You'll find skills for Pennant (feature flags), the AI SDK, Fortify (authentication), and Inertia.js with React. These are maintained by the teams behind the packages, so they stay current with new releases.

Architecture and Best Practices skills teach your agent specific coding patterns. The laravel-best-practices skill covers controllers, models, migrations, and validation patterns. The laravel-tdd skill enforces test-driven development with Pest. These are opinionated by design, and that's the point.

Stack-Specific Skills target particular tech stacks. There's shadcn-vue for Vue/Nuxt with Reka UI, laravel-inertia-react for the Inertia + React combo, and full-stack guidelines for Laravel 11/12 applications.

The install counts give you a rough signal of quality, but don't ignore newer skills with fewer installs. The directory is only days old. Some of the best skills might have landed yesterday.

Installing Skills in Your Project

Prerequisites: you need Laravel Boost installed in your project. If you've followed my Laravel + Claude Code ecosystem guide, you already have it. If not:

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

The installer auto-detects your IDE and sets up the configuration. Now you can install any skill from the directory with a single command:

php artisan boost:add-skill <owner/repo>

For example, to install the official AI SDK development skill:

php artisan boost:add-skill laravel/ai-sdk-development

Or the community Eloquent best practices skill:

php artisan boost:add-skill iserter/eloquent-best-practices

That's it. The skill gets added to your project, and your AI agent can now use it whenever you're working on a related task. You don't need to explicitly invoke it. If you ask your agent to "add feature flags to the subscription system," it'll automatically load the Pennant skill (if installed) and follow those patterns.

Want to update your skills when new versions come out? Run:

php artisan boost:update

This refreshes all your installed skills and guidelines to their latest versions.

How Skills Actually Work Under the Hood

A skill is just a folder with a SKILL.md file at its root. That's it. No magic, no complex build process. The SKILL.md has two parts: YAML frontmatter that tells the agent when to use the skill, and markdown content with the actual instructions.

Here's a simplified example:

---
name: laravel-tdd
description: Test-Driven Development for Laravel using Pest PHP.
  Use when implementing any feature or bugfix. Write tests first,
  watch them fail, then write minimal code to pass.
---

# Test-Driven Development with Pest

## Workflow
1. Write a failing test first
2. Run the test and confirm it fails
3. Write the minimum code to make it pass
4. Refactor while keeping tests green

## Test Structure
Always use Pest's functional syntax...

The description field is the most important part. It's what the agent reads to decide whether to load the skill. A vague description like "helps with testing" won't trigger reliably. A specific description like "Test-Driven Development specifically for Laravel applications using Pest PHP. Use when implementing any Laravel feature or bugfix" will.

Skills use a three-level loading system to manage context efficiently. The metadata (name and description) is always in context, roughly 100 words. The main SKILL.md body loads when the skill activates. And any referenced files in subdirectories load only when the agent needs them.

This progressive disclosure approach keeps your context window lean. The agent sees that a TDD skill exists, but only loads the full 500 lines of instructions when you actually ask it to write tests.

The Skills That Are Actually Worth Installing

I've gone through the directory and here are my picks for the most useful skills right now, depending on your stack:

For every Laravel project:

• laravel-specialist (3.2k installs) is a solid general-purpose skill for Eloquent, API resources, and queue systems
• eloquent-best-practices covers query optimization, relationship management, and N+1 prevention
• php-best-practices enforces modern PHP 8.5+ patterns and SOLID principles

If you're building with the AI SDK:

• ai-sdk-development (Official) is essential. It covers agents, structured output, streaming, tools, and provider failover. If you've been following my AI SDK tutorial series, this skill makes your agent understand the SDK patterns natively.
• developing-with-ai-sdk adds the AI and LLM tags for broader coverage

If you use Inertia + React:

• inertia-react-development (Official) covers pages, forms, navigation, deferred props, and prefetching
• laravel-inertia-react adds integration patterns between Laravel and React

For testing:

• laravel-tdd enforces test-first development with Pest
• laravel-testing covers comprehensive testing patterns including mocking and factories

For full-stack guidelines:

• laravel-11-12-app-guidelines is a comprehensive guide for working across common Laravel stacks, including Docker Compose/Sail support, multiple frontend options, and Laravel Boost tooling

You don't need all of them. Pick the skills that match your stack and your workflow. Three to five well-chosen skills will make a bigger difference than twenty generic ones.

Building Your Own Laravel Skill

This is where it gets really interesting. The directory is community-powered, and creating a skill is surprisingly simple.

Step 1: Create the Skill Structure

A minimal skill needs one file:

my-laravel-api-skill/
└── SKILL.md

But a well-structured skill looks more like this:

my-laravel-api-skill/
├── SKILL.md              # Main instructions (required)
├── references/            # Detailed documentation
│   ├── architecture.md
│   └── code-examples.md
└── assets/
    └── templates/         # Ready-to-use code templates
        ├── Controller.php
        ├── FormRequest.php
        └── Action.php

The references/ directory holds deep-dive documentation that the agent only loads when needed. The assets/ directory holds templates and files the agent can copy directly into your project.

Step 2: Write the SKILL.md

Start with the frontmatter. The description is critical because it determines when your agent activates the skill:

---
name: my-api-conventions
description: Build REST APIs following our team's conventions.
  Use when creating controllers, form requests, API resources,
  or implementing CRUD endpoints. Triggers on tasks involving
  API routes, JSON responses, or endpoint architecture.
---

Then write the instructions. Be specific and opinionated. A skill that says "consider using DTOs" is useless. A skill that says "always use DTOs with typed properties and a static fromRequest() factory method" gives the agent something concrete to follow.

# API Development Conventions

## Controller Rules
- One controller per resource, max 5 methods
- Use invokable controllers for non-CRUD actions
- Always return API Resources, never raw models

## Request Validation
- Every endpoint gets its own FormRequest
- Use `prepareForValidation()` for data transformation
- Document validation rules with inline comments

## Response Format
Always wrap responses:

​```php
return ApiResource::make($model)
    ->response()
    ->setStatusCode(201);
​```

## For detailed architecture patterns
See `references/architecture.md`

Step 3: Test It Locally

Before publishing, test the skill in your project. For Claude Code, drop the skill folder into your project's .claude/skills/ directory:

mkdir -p .claude/skills/my-api-conventions
cp -r my-laravel-api-skill/* .claude/skills/my-api-conventions/

Now start a Claude Code session and ask it to create an API endpoint. If the skill triggers correctly, you'll see it referenced in the agent's output. If it doesn't trigger, your description probably needs to be more specific.

For Cursor users, the skill goes into your project's skill directory as configured by Boost.

Step 4: Publish to the Directory

To share your skill with the community, push it to a public GitHub repository. The repository structure should keep the skill source separate from repository documentation:

my-api-conventions-repo/
├── README.md           # For GitHub visitors
├── LICENSE
├── my-api-conventions/ # The actual skill folder
│   ├── SKILL.md
│   └── references/
│       └── architecture.md

Then submit it to skills.laravel.cloud. Once it's listed, anyone can install it with php artisan boost:add-skill your-username/my-api-conventions.

Tips for Writing Skills That Actually Work

After spending time with the directory and reading through the best-performing skills, here's what separates good skills from useless ones.

Be aggressively opinionated. Don't try to cover every possible approach. Pick one way of doing things and document it well. If your team uses Action classes instead of service layers, say that. If you prefer Pest over PHPUnit, enforce it. Skills aren't documentation. They're executable opinions.

Keep SKILL.md under 500 lines. Every word competes for your agent's context window. Move detailed patterns into references/ files that load only when needed. The main file should contain your core workflow and key rules.

Write descriptions that trigger correctly. Include specific task types: "Use when creating controllers, models, migrations" is better than "Use for Laravel development." Include package names if relevant. Include the problem the skill solves.

Show, don't tell. A complete code example is worth paragraphs of explanation. Include template files in assets/ that your agent can copy and adapt. Include example outputs so the agent knows what "good" looks like.

Test with real tasks. Install your skill locally and throw real work at it. Ask your agent to build features, fix bugs, write tests. You'll find gaps you never noticed from just reading the skill.

How This Fits Into the Bigger Picture

If you've been following the AI-agent friendly approach to Laravel development, skills are the natural next step. You've already got llms.txt exposing your app's structure. You've got Boost giving your agent deep application context. Now skills add the domain expertise layer.

The stack looks like this: Boost provides tools and application awareness (your database schema, routes, models). Guidelines set your baseline coding conventions. Skills inject specialized knowledge when the agent needs it. Together, your AI coding agent goes from "generic assistant that knows PHP" to "senior developer who understands your exact project."

And with Laravel Skills being community-driven, the quality will compound over time. The best patterns from thousands of Laravel developers, packaged into modular, installable knowledge. That's a big deal.

Frequently Asked Questions

Do I need Laravel Boost to use skills from the directory?

Yes. Skills from skills.laravel.cloud are installed through Boost using php artisan boost:add-skill. You need Boost as a dev dependency. If you're using Claude Code directly without Boost, you can still create and use local skills in .claude/skills/, but you won't have access to the directory's one-command install.

Can I use skills with editors other than Claude Code?

Yes. The directory works with Claude Code, Cursor, Windsurf, Copilot, and other AI coding environments. When you run boost:install, it detects your IDE and generates the right configuration files. The skill format follows the open Agent Skills specification at agentskills.io, so it's designed to be cross-platform.

Do skills conflict with each other?

Generally no. Skills load on-demand for specific tasks, so they're not all in context at once. If you install both a TDD skill and a different testing skill, the agent picks the most relevant one based on your request. That said, installing two skills with contradictory advice (like different API conventions) can confuse the agent. Pick one approach per domain.

How do I know which skills are actually good?

Install counts are a starting signal but not definitive since the directory is new. Check the GitHub repo for each skill. Look at the SKILL.md content. Is it specific and opinionated, or vague and generic? Does it include code examples? Is it actively maintained? The official skills are a safe bet for packages you use.

Can I use skills to enforce team coding standards?

This is one of the best use cases. Create a skill that captures your team's architecture patterns, naming conventions, testing approach, and code review checklist. Share the GitHub repo with your team, and everyone installs it with one command. Every developer's AI agent now follows the same conventions.

What's Next

The Laravel Skills directory is only days old and already has 96 skills. It's going to grow fast as the community contributes their patterns and workflows. The teams that start building and sharing skills now will have a real advantage as AI-assisted development becomes the default way of working.

If you haven't set up Boost yet, start there. If you already have Boost, go browse the directory and install skills for your stack. And if you've got coding patterns worth sharing, build a skill and publish it. The community will benefit, and so will your AI agent.

Need help building an AI-powered Laravel application or setting up your development workflow? Get in touch and let's talk about your project.