AI in Laravel: Laravel Boost, OpenCode and MCP from Scratch

▶

Before we begin, I want to make a necessary clarification about this section. Introducing AI into courses or books is always a challenge due to its ambiguous nature. Unlike traditional programming, where an input always produces the same output following a linear logic, AI works like a black box. You can give it the same instruction a thousand times and get a thousand different results.

That's why I ask you to manage your expectations: what you'll see here is not an exact science, but a possible path among many others.

My Approach: Workflow, Not "Model Theory"

I don't intend for this section to be an "Introduction to AI." I won't explain model types, how to run them locally, or the internal architecture of neural networks there's already endless content online for that. My goal is 100% practical and focused on Laravel.

I'm going to show you my personal workflow. I'll use tools like Google Antigravity, but that doesn't mean they're the only options. If you prefer to use Windsurf, Cursor, or the command-line interface of Gemini (Gemini CLI), you can do so perfectly fine. What matters is not the specific tool, but how you integrate AI into your daily work as a developer.

Laravel + AI: Laravel Boost and SDK

Laravel already offers powerful tools we want to take advantage of. We'll focus especially on how AI integrates with the modern Laravel ecosystem. I'll try to be concise I don't want this section to be larger than the rest of the course.

If you're interested in the technical details of each tool (like OpenCode), I invite you to research on your own. I won't stop to explain every command from scratch because that would take us away from the main goal: programming better with Laravel.

Solo Programming vs. Agent Teams

Nowadays it's very trendy to talk about "agent swarms" (analysts, refactorers, QA experts working in parallel). In my experience as an independent developer, that workflow is usually unnecessary for small or medium-sized projects.

My largest application, my own academy, has evolved from CodeIgniter 3 to Laravel, and even though it has a huge database and years of code, I don't need 5 agents running simultaneously. So the workflow I'll teach you is:

• Simple: Easy to implement today.
• Practical: Focused on the educational projects we're building.
• Realistic: Designed for the developer who works alone or in small teams.

The Challenge of "Programming Without Programming"

There's a risk in modern courses: extreme prompt engineering where it seems like AI does everything and the developer does nothing. That's not my style. I don't want you to think "you no longer need to learn how to program."

We'll use AI as a support tool to:

• Overcome the fear of new implementations.
• Improve how we write our prompts in natural language.
• Understand the context where AI really adds value without replacing our logic.

I hope this starting point is clear. Let's see how to boost your workflow without losing control of your code.

Tools and Software: My Pragmatic Selection

Let's detail the software we'll use. If you already have your own tools, you can use them, but to follow these demonstrations I recommend the ones I'll mention below.

This section is dynamic; unlike the rest of the course, where I follow my books to the letter, the AI world changes daily. I'm also still learning nobody is an absolute expert here because the information overwhelms us. My goal is to map out an easy path so that what took me weeks to learn, you can master in minutes and have a solid starting point.

OpenCode: The Coding Engine

I'll be using OpenCode. Why? Because right now it's one of the few coding agents that integrates perfectly with Laravel Boost, which is the core of what we're going to cover.

Why Not Other Options?

• Claude: It's excellent, but it's paid. This course is designed so you don't have to pay extra subscriptions. Also, in some countries (like mine) it's blocked and using a system-level VPN is a hassle.
• Gemini CLI: Although it's from Google, I feel it's still slightly behind OpenCode in terms of parallel agent execution and professional versatility.

OpenCode is free, accessible, and powerful. If you know how to use this tool, what you learn will translate almost 1-to-1 if you decide to switch to Claude or use MCPs (Model Context Protocol) in the future.

https://opencode.ai/

Google IDE (Antigravity): My New Favorite IDE

The next tool is Google IDX. Antigravity is an IDE built on top of VS Code, so you won't have any adaptation issues.

I trust this tool because it's from Google and, even though they sometimes cancel projects, IDX seems to be here to stay. In fact, I've adopted it so much that I barely open my local VS Code anymore. It's cross-platform, installs in two steps, and gives you a much richer and simpler workflow.

Installation and Configuration on Windows, Mac, and Linux

Installing IDE and OpenCode is straightforward: download the executable from their official page and follow the wizard.

For Linux users, I suggest being careful with global node installations (via sudo), as permissions can cause issues. If you use Mac, my personal recommendation is to install everything via Homebrew. It's the package manager par excellence (the "Chocolatey" of Windows) that I always use to install PHP, databases, or any service before Laravel Herd even existed.

$ curl -fsSL https://opencode.ai/install | bash

Or

$ brew install anomalyco/tap/opencode

Essential Extensions

Both in VS Code and Google Antigravity, go to the extensions section and search for OpenCode.

Although the extension is convenient for not having multiple floating windows, it sometimes "clashes" with native keyboard shortcuts (like Ctrl+P). If you feel it's limiting you, remember that you can always run OpenCode directly from the terminal, where it has its full potential.

Install the extension in both editors:

https://marketplace.visualstudio.com/items?itemName=sst-dev.opencode

That way, if your plan runs out in one or you prefer to switch environments without closing the project, you'll have everything ready to continue.

Laravel + AI: Understanding the Ecosystem (Boost vs. SDK)

The Laravel team never rests when it comes to adopting new technologies, and Artificial Intelligence has been no exception. If you search "Laravel AI" on Google, you'll see they've launched a powerful ecosystem. Although it may seem like there are many packages, it all comes down to two main tools: Laravel Boost and Laravel AI SDK.

How Do We Use AI Today?

Basically, there are two ways to interact with AI in our world as developers:

1. As a coding assistant: Tools that help us write code (like Cursor, Copilot, or Google IDX).
2. As part of our application: When we want our website to generate images, translate text, or respond to chats for our end users.

Laravel Boost: Your High-Quality Code Assistant

You're probably wondering: "If I already use Google IDX or VS Code extensions, why do I need a Laravel package for coding?".

The answer is simple: Context and Quality. Generic AIs sometimes get confused. For example, you ask for a view and they mix in old syntax, or try to install Tailwind v3 when we're already on v4. This happens because they're general models that don't deeply understand the specifics of a Laravel project (its routes, folder structure, Vite configurations, etc.).

Laravel Boost solves this. It's a specialized assistant that:

• Uses Skills (capabilities) and Guidelines (guides) specific to Laravel.
• Connects via MCP (Model Context Protocol) to better understand your project.
• Its single objective: Generate quality code that actually works in the current Laravel ecosystem without giving you outdated solutions.

Important note: This package is installed as a development dependency (--dev), because once your application is finished and in production, the "assistant" has done its job and doesn't need to be there anymore.

$ composer require laravel/boost --dev

Laravel AI SDK: Integrating AI into Your App

On the other hand, we have the Laravel AI SDK. This tool is not meant to help you code, but to make your application intelligent.

If you want your user to be able to:

• Generate an image of a "space donut" from a form.
• Automatically translate a comment.
• Interact with a chatbot that uses local or external models.

Then you use the SDK. It's a library that lets you fire prompts directly from your PHP code. Unlike Boost, this is a regular dependency of the application, as it will be part of the features your end users will enjoy.

In Summary

Even though both ultimately query a language model, functionally they are completely different worlds. In this section we will first focus on Laravel Boost, because before offering AI to our users, we need AI to help us finish the project efficiently!

Laravel Boost: Installation and Initial Configuration

Welcome to the world of epic Laravel names! Between the SDK, the Laravel AI Boost, and all the terminology, it feels like we're assembling a team of superheroes. So you don't get confused by all the names, I've prepared a detailed post on my blog where you can read all of this at your own pace if you prefer text over video.

We already have the basic tools installed (like Google Antigravity or VS Code), so now it's time to get our hands dirty with the package provided by the Laravel ecosystem.

1. Package Installation

We'll work on a "fresh" project. The first step is to install Laravel Boost via Composer. Remember this is a package exclusively for the development stage, so we must use the --dev flag:

$ composer require laravel/boost --dev

composer require laravel/ai-bus --dev

2. Configuration and Assets

Once the package is installed, we need to publish its configuration files and assets into our project. To do this, we run the package's own installation command:

$ php artisan boost:install  

php artisan bus:install

Note: If you see red messages in the terminal, don't panic. Sometimes Laravel uses vivid colors to indicate steps to follow (like reminding you to run npm run dev), but it doesn't always mean something went wrong:

Please set up Boost with [php artisan boost:install] first.
Script @php artisan boost:update --ansi handling the post-update-cmd event returned with error code 1

  ██████╗   ██████╗   ██████╗  ███████╗ ████████╗
  ██╔══██╗ ██╔═══██╗ ██╔═══██╗ ██╔════╝ ╚══██╔══╝
  ██████╔╝ ██║   ██║ ██║   ██║ ███████╗    ██║   
  ██╔══██╗ ██║   ██║ ██║   ██║ ╚════██║    ██║   
  ██████╔╝ ╚██████╔╝ ╚██████╔╝ ███████║    ██║   
  ╚═════╝   ╚═════╝   ╚═════╝  ╚══════╝    ╚═╝   
   ✦ Laravel Boost :: Install :: We Must Ship ✦ 
  Let's give Laravel a Boost
 ┌ Which Boost features would you like to configure? ───────────┐
 │ AI Guidelines                                                │
 │ Agent Skills                                                 │
 │ Boost MCP Server Configuration                               │
 └──────────────────────────────────────────────────────────────┘
 ┌ Which third-party AI guidelines/skills would you like to install? ┐
 │ laravel/fortify (guidelines, skills)                              │
 │ spatie/laravel-permission (skills)                                │
 └───────────────────────────────────────────────────────────────────┘
 ┌ Which AI agents would you like to configure? ────────────────┐
 │ Gemini CLI                                                   │
 │ OpenCode                                                     │
 └──────────────────────────────────────────────────────────────┘
Adding 8 guidelines to your selected agents
 ┌───────────┬────────────┬───────────┬──────────────┬─────────────────┐
 │ boost     │ foundation │ herd      │ laravel/core │ laravel/fortify │
 ├───────────┼────────────┼───────────┼──────────────┼─────────────────┤
 │ pest/core │ php        │ pint/core │              │                 │
 └───────────┴────────────┴───────────┴──────────────┴─────────────────┘
  OpenCode  ... ✓
  Gemini CLI... ✓
Syncing 6 skills for skills-capable agents
 ┌────────────────────────────────┬─────────────────────┬─────────────────────────┐
 │ cashier-stripe-development     │ fortify-development │ laravel-best-practices  │
 ├────────────────────────────────┼─────────────────────┼─────────────────────────┤
 │ laravel-permission-development │ pest-testing        │ tailwindcss-development │
 └────────────────────────────────┴─────────────────────┴─────────────────────────┘
  OpenCode  ... ✓
  Gemini CLI... ✓
Installing MCP servers to your selected Agents
  OpenCode  ... ✓
  Gemini CLI... ✓

Customizing Boost: Skills, Guidelines, and MCP

When you run the installation, the system will ask which components you want to activate. This is where the experience varies by operating system:

• On macOS and Linux: You'll see an interactive list where you can use arrow keys and the spacebar to select.
• On Windows: It may not be interactive. In that case, you'll need to type the names manually separated by commas (example: guidelines, skills, mcp).

What exactly are we activating?

• Guidelines: Style rules and best practices so the AI doesn't make things up.
• Skills: Specific capabilities so the assistant knows how to interact with Laravel features.
• MCP (Model Context Protocol): The "connector" that allows AI to understand the deep context of your application.

My recommendation: Select everything! The more tools the assistant has, the better it can help you.

Integration with Third-Party Packages

What's interesting about Laravel Boost is that it doesn't just know "plain" Laravel it detects what other packages you have installed. If your project uses:

• Laravel Permission (Spatie)
• Laravel Fortify
• Laravel Cashier

The assistant will detect it and offer skills and guides specific to those tools. That is, the AI won't give you a generic solution, but one tailored to the packages you're actually using.

 ┌ Which third-party AI guidelines/skills would you like to install? ┐
 │ laravel/fortify (guidelines, skills)                              │
 │ spatie/laravel-permission (skills)                                │
 └───────────────────────────────────────────────────────────────────┘

Agent Selection (OpenCode vs. Gemini)

The last step is to tell Laravel which "brain" you'll use to process requests. You'll see a list of compatible agents:

1. OpenCode: My recommended option for this course because it's free and very powerful for the workflow we're going to cover.
2. Gemini CLI / Google IDX: Also excellent free options.
3. Claude / OpenAI: They're outstanding, but tend to be paid or have geographic restrictions requiring a VPN.

Which Boost features would you like to configure? ───────────┐
 │ AI Guidelines                                                │
 │ Agent Skills                                                 │
 │ Boost MCP Server Configuration                               │
 └──────────────────────────────────────────────────────────────┘
 ┌ Which third-party AI guidelines/skills would you like to install? ┐
 │ laravel/fortify (guidelines, skills)                              │
 │ spatie/laravel-permission (skills)                                │
 └───────────────────────────────────────────────────────────────────┘
 ┌ Which AI agents would you like to configure? ────────────────┐
 │ › ◻ Amp                                                      │
 │   ◻ Claude Code                                              │
 │   ◻ Codex                                                    │
 │   ◻ Cursor                                                   │
 │   ◼ Gemini CLI                                               │
 │   ◻ GitHub Copilot                                           │
 │   ◻ Junie                                                    │
 │   ◼ OpenCode                                                 │
 └──────────────────────────────────────────────────────────────┘

Select whichever you prefer (in my case, OpenCode). Once you hit Enter, you're done! The assistant is configured and ready to start generating quality code.

Introduction to OpenCode: Your Terminal Agent

At this point you can use VS Code or its modern version, Google IDX (formerly Anti Gravity). The fundamental difference is minimal, except for IDX's sidebar that makes interacting with agents easier. But today we'll focus on OpenCode.

OpenCode is a CLI-based agent (Command Line Interface). Unlike other extensions that sometimes "freeze" or stop responding (as I've recently experienced with Gemini on Windows), OpenCode tends to be more stable and direct.

Commands and Shortcuts

Once installed, you can open it from your terminal simply by typing opencode.

• Navigation tip: Almost everything starts with a slash (/). If you type / and use the arrow keys or tab, you'll see the available options: agents, connectors, editors, and more.
• Watch out for shortcuts: In some environments, shortcuts like Ctrl + P can conflict with editor functions (like printing or searching files). Pay attention to this so you don't override functions.

Understanding MCPs and Models

If you type /mcps, you'll see the active connectors. Thanks to the configuration we did earlier, Laravel Boost should already appear perfectly integrated. It's similar to what happens with Laravel Sail: the system handles the complexity for us.

Which Model to Choose?

When you use /models, you'll see a list of options. The great advantage of this service is that it offers several free models.

• My recommendation: Don't overthink it. If you're unsure, ask the AI itself. I usually use Gemini 2.5 Flash; it's fast and, in my experience, handles complex problems better (like Stripe or Cashier migrations) than other free models like Llama or Big Pickle, which sometimes get confused with outdated syntax.

Planning Mode vs. Building Mode

This is one of the most important parts for your workflow:

1. Planning Mode: Use it for large tasks. The AI first analyzes, proposes a strategy, and if you agree, executes. It's ideal when you don't have a clear context or want to iterate an idea from scratch (e.g., "Build me a clothing website").
2. Building Mode: This is the one I use 90% of the time. It's for targeted changes: "Replace this method in this controller" or "Adapt this view to Tailwind v4". It's direct and to the point.

The Skills: Laravel Boost's Superpower

If you type /skills, you'll see the active "skills." The exciting part is that since this package is so new, the list grows constantly.

• Currently we have skills for Cashier, Fortify, and Spatie.
• This allows the AI to stop recommending outdated Tailwind 3 practices and start using Tailwind 4 and modern Laravel standards automatically.

/cashier-stripe-development
/fortify-development
/laravel-best-practices
/laravel-permission-development
/pest-testing
/tailwindcss-development

By selecting a specific skill before requesting a task, you give the AI the exact context it needs to not fail, especially with free models that are sometimes a bit lost.

What Are Skills and Guidelines?

We have Laravel Boost installed, but how does it work internally? If you explore the package folder (especially in OpenCode), you'll see a large collection of files. These files use Markdown (.md) format, the same we use for GitHub README files. Laravel uses this format because it's a language that both humans and AIs understand perfectly.

Although they look like simple text files, they're the master instructions to keep the AI from hallucinating. They're divided mainly into two concepts:

1. Skills (Capabilities)

Imagine a Skill as a specific capability to perform an expert action. For example: being a master in Tailwind CSS, an expert in Fortify, or a specialist in Spatie Permissions.

• How are they activated? You don't have to manually invoke them every time. These files have a "trigger" keyword in their description. When you ask the AI: "Create a design with Tailwind", the AI detects the keyword and automatically activates the Tailwind skill.
• What are they for? To make the AI stop using old patterns. For example, the Tailwind skill orders it: "Don't use Tailwind 3, use version 4; don't use JS configuration files, use the new theme system". These are golden rules to keep the code modern and functional.

2. Guidelines (Standards or Rules)

Unlike skills, Guidelines (which you'll sometimes see in folders like rules or practices) are general coding standards.

• Fundamentals: These are standards for how you should code. For example: "Always use CamelCase for functions", "Avoid the N+1 query problem", or "Don't use numeric status codes like 200, use Laravel's descriptive constants".
• Real Examples: The best part of guidelines is that they include code blocks showing "What's WRONG" vs. "What's RIGHT." This is vital, because an example is worth a thousand words for an AI.

Comparison Table: Guidelines vs. Skills

So you don't get confused, here's the key difference:

If you have questions about a specific file, ask the AI! Copy the content of the .md and say: "Explain this skill to me". It will explain it in a friendly and direct way.

The idea is to get used to using AI to understand AI. I won't always be there to explain every update, but your "invocation" will be. Keep specific conversations in Gemini or ChatGPT for each topic and you'll see how context helps you move forward fast.

AGENTS.md

For all these agents and skills to work, they need an entry point, similar to main.js in Flutter projects or index.php in Laravel.

In the Laravel Boost ecosystem, the AGENTS.md file acts as the "super agent" or highest level one. It's the one that controls the rest. When you ask a question, the system doesn't go directly to a random skill; it first reads this main file that defines which agents, skills, and guidelines (guidelines) are available.

Custom Configuration

If for any reason you want to disable guidelines or remove a specific MCP, you can do it in the configuration files (like opencode.js). These files are the "master switch" that connects your editor with the internals of Laravel. You don't need to worry about the internal code; just understand that they're the rules of the game so the AI doesn't get lost.

Without Laravel Boost vs. With Laravel Boost

We ran a real test: asking about errors in the project logs (prompt: "I have log errors in the project"). Look at the quality difference:

1. Generic AI (no context): Started talking about the User model, security, and migrations for no reason. It didn't understand the context and "hallucinated" a standard response.

   1. I understand you're having errors in your Laravel project logs. To help you precisely, I would need you to share the last lines of the log file, which is normally found at:
      storage/logs/laravel.log
      However, reviewing the code in your ProfileController.php and based on the Laravel 13 structure you mention in the README.md, here are the most common points that tend to generate errors in that specific functionality and how you could fix them:
      1. Undefined relationship in the Model
      In your controller you use $user->profile. For this to work, you need to make sure that in your App\Models\User model the relationship is defined.
      Common error: Property [profile] does not exist on this collection instance or Call to undefined method User::profile().

2. Laravel Boost (with OpenCode): Upon detecting the word "logs", the specific error-reading skill was automatically activated.

   1. laravel-boost_read-log-entries [entries=20]
      Thinking: I have the error logs. There are several errors I need to summarize:
      1. createToken error - UserController.php:25 - The User model does not have the createToken() method. This means the User model is not using the HasApiTokens trait from Laravel Sanctum.
      2. mapInto error - CategoryController.php:27 - There's a problem with the use of mapInto() in the CategoryController. It seems an API Resource is being used incorrectly.

Boost's result was superior because:

• It analyzed the real file: It read storage/logs/laravel.log directly.
• It summarized precisely: It identified real errors (like the API Token one we mentioned earlier).
• It offered solutions: Not only did it say what was wrong, but it presented a table with the fixes and offered the Build button to apply the changes instantly.

Ninja Reflection: The Stone vs. The Kunai

As they say in Naruto: a skilled ninja can win a battle using a stone against a kunai.

The same thing happens here. The Gemini 2.5 Flash model (the stone) with Laravel Boost instructions was far more effective than a supposedly superior model that had no project context. Boost gives models "superpowers" so they work with the precision of a Laravel expert.

If you have a production error, don't spend three hours reading endless logs. Ask Boost to analyze them, give you the summary, and generate the fix. You save time and avoid a headache.

MCP: The Nervous System of Your AI

To understand what an MCP (Model Context Protocol) is, imagine a USB drive or an external hard drive. If your computer had no USB ports, how would you get the information out? It would have to invent a way to read the files, power them, and understand their structure every time. It would be a nightmare.

MCP is that "USB port." It's the connector that allows the AI (the brain) to access data outside its training, such as:

• Your local database (MySQL/PostgreSQL).
• Real-time error logs.
• Even your browser!

Practice: The Browser Error vs. The "Guessing" AI

We ran a stress test by triggering a JavaScript error (alert misspelled as alert) in one of the views:

resources/views/dashboard/post/index.blade.php

<script>
    aler
</script>

And we compared two approaches (prompt: I have a browser error, detect it and fix it):

1. Generic AI (No MCP): Went crazy. It started saying there were errors in files that were perfectly fine and, worst of all, tried to "fix" modern Laravel code using old documentation from 2024 or early 2025. Since it can't see the browser, it makes up the problem to try to comply.

1. Hi. After reviewing the code in your project, I've detected that the main error you're probably seeing in the browser (likely a MassAssignmentException or that the data simply isn't being saved) is due to the use of PHP Attributes to define $fillable and $hidden in the models.
2. Although PHP 8+ supports attributes, Eloquent's core in Laravel still uses protected properties (protected $fillable) for mass assignment management. By using attributes, Laravel ignores those definitions, blocking any attempt to save data via updateOrCreate or create.
3. Also, in the User model, you have a dangerous duplication: the setPasswordAttribute method together with the cast 'password' => 'hashed'. This will cause the password to be encrypted twice, making it impossible to log in.

1. Laravel Boost + Browser MCP: This is where the magic happens. By telling it "Use Boost to read the browser errors", the AI doesn't guess. It activates the connector, "looks" at your Chrome or Edge console, detects the exact alarmal and gives you the solution in 20 seconds.

1. Thinking: The user wants me to check browser logs to find and fix an error.
   ⚙ laravel-boost_browser-logs [entries=20]
   Thinking: The error shows aler is not defined. This is a typo - it should be alert instead of aler. Let me find the blog view file and fix it.
   Error found: aler is not defined - missing the letter t in alert. Searching for the file:
   ✱ Grep "\baler\(" 
   Thinking: Let me search for aler in all files to find the typo.
   ✱ Grep "aler" (7 matches)
   Thinking: Found the typo in /Users/andrescruz/Herd/larafirststep/resources/views/components/blog/post/index.blade.php at line 37. It says aler instead of alert. Let me read that file to fix it.
   → Read resources/views/components/blog/post/index.blade.php [offset=30, limit=15]
   Thinking: I see - line 37 has aler which is incomplete. Let me check what it was supposed to be. It seems like the code was cut off. The user probably meant to write some alert functionality. Let me fix this by removing the incomplete code since it doesn't seem to be working properly anyway.
   ← Edit resources/views/components/blog/post/index.blade.php
   <div class="mt-12">
   {{ $posts->links() }}
   </div>
   <script>
   aler
   </script>
   </div>
   Thinking: Fixed! The incomplete aler script tag has been removed. The error was caused by a typo where alert was truncated to aler.
2. Fixed. The error was a typo: aler instead of alert on line 37 of the index.blade.php file. The incomplete code was removed.

The Pizza Analogy: Why Use MCP?

Imagine you open a pizza place because AI took our programming jobs (just kidding, hopefully!).

• Without MCP: Every time a customer orders a pizza, you have to go buy the flour, milk the cow for the cheese, and plant the tomatoes. It takes 3 hours per customer.
• With MCP: You already have the suppliers connected. The customer orders, you activate the connector, and you already have the ingredients ready to make the pizza quickly and with quality.

In code it's the same: if the AI has to "build" the database connection or read thousands of log lines manually, it spends 90% of its energy (tokens) on that and only 10% giving you the solution. With MCP, 90% of its power focuses on solving your problem (as an illustrative example that doesn't have to apply literally in the real world).

The most important thing I want you to take away is that Laravel Boost doesn't change how you program, it makes it efficient. It doesn't matter if you use the simplest "generic" model or the latest Gemini; if you give it the right tools (Skills and MCP), it will give you senior-level answers.

As we saw with Sasuke and Itachi: it's not the weapon, it's how you use what you have. An AI connected to your real workflow will always beat a super-powerful AI that's "blind" to what's happening in your terminal or browser.

Workflow: Git as Your Safety Net

Before firing commands at the AI, a word of advice: always sync with Git.

Especially when working with targeted or experimental changes, do a git commit. If the AI "goes crazy" or you don't like the change, a simple git checkout or git reset --hard brings you back to life in seconds. Don't rely on your memory or manually undoing changes; let Git be your life insurance while AI tinkers with the code.

Invoking Skills: Implicit vs. Explicit Use

You know the path now: we've seen agents, directives (guidelines) and connectors (MCP). But there's a key difference in how to ask for things:

1. Implicit Use: You ask for something general and the AI, based on the context and what it has installed, decides what to use.
2. Explicit Use: This is when you tell it: "Use this specific skill". In OpenCode, you can type /skills and select Laravel Best Practices.

Why do this? Because if you ask for a general review, the AI will use its base knowledge (which may be outdated). But if you force it to use the Laravel best practices skill, you're making it read the golden rules we defined in the project's Markdown files.

Case Study: Comprehensive Project Review

We ran the stress test, selected the Laravel Best Practices skill: "Do a review of my project following best practices":

# Laravel Best Practices
Best practices for Laravel, prioritized by impact. Each rule teaches what to do and why. For exact API syntax, verify with `search-docs`.

The AI went into "ninja sensor" mode and started scanning the entire codebase. Even though it made me look a bit bad (damn you, AI!), it detected some very interesting things:

• Hardcoding: Found routes and values written "hardcoded" that should be dynamic.
• Controller Logic: Detected that in the UserController we were using an auth()->user() that we hadn't finished implementing correctly.
• Component Order: Suggested reversing the order of some titles and conditions to make the code more readable (even if it's sometimes hard to see it that way).

Doing this review manually on a large project would take hours. The AI did it in seconds. Sure, it found "high priority" errors that almost made me delete the video, but that's exactly why we installed Laravel Boost: so that the generated code is of high quality and not just "code that works."

Expanding Horizons: Third-Party and Custom Skills

To wrap up this part on Skills with Laravel Boost, there's a vital point: you're not limited to the ones that come by default. Even though we already have several implemented in Markdown files (and you know you can edit or update them to your liking), the system is completely open.

We know that the Laravel team is a bit like Apple: they like having their own unique, well-polished ecosystem. So it makes sense that Laravel Boost is an independent tool that does its own "forking." But beyond that, there's a world of third-party skills.

• Explore and download: There are repositories and pages (like skills.md and similar ones) where the community shares their own configurations. It doesn't matter if they're focused on Laravel or general programming; you can integrate them into your workflow.
• Installation: Usually, you just need to use a command to add them. Since they're Markdown files, the AI processes them the same way, whether provided by Boost or from external sources.

Create Your Own "Specialty"

If you can't find what you're looking for, you can create your own Skill. No need to reinvent the wheel, but you can generalize your workflows.

• How to do it? You can create the .md file manually following the structure we've already seen, or better yet, ask the AI to do it! Tell it: "Generate me a skill for handling specific Google integrations in this project".
• Automatic configuration: When you ask the AI to install or configure a skill, it will take care of referencing it in files like AGENTS.md so the agent knows it now has that new "skill" available.

Conclusion

At the beginning of the book we were making general prompts to overcome the fear. But now that the project has started and has a structure, a style, and clear dependencies, you need to be specific.

Don't ask for "help"; ask it to use the Pest skill for testing or the Tailwind one for components. The more specific the tool you invoke, the more professional the result.

Although, depending on what you want to do, it does NOT mean you can't use a generic prompt it all depends on what you want to achieve.

Skills are not just a trend; they're the way we'll interact with AI from now on. Whether using the ones specific to the Laravel ecosystem, third-party ones, or your own, the goal is the same: precision and quality.

With this we wrap up this theoretical-practical section on Laravel Boost. Get ready, because in the next section we'll dive into the world of Testing.

We're not going to invest 7 hours of manual testing. We're going to use everything we've learned so that, in about 40 minutes, AI helps us leave the project bulletproof. Now that's going to be fun!