Overview: Why Your AI Agent Needs a Boost AI models like Claude and GPT-4 are powerful, but they arrive at your codebase as strangers. They possess a massive, static library of internet-scale training data, but they lack the specific, real-time context of your unique Laravel application. This gap often leads to what developers call "hallucinations"—code that looks correct but fails to follow your team's conventions or uses deprecated patterns. Laravel Boost is designed to solve this context deficiency. It acts as a bridge, packaging your application's routes, configuration, and coding standards into a format that AI agents can ingest and act upon. With the release of Boost 2.0, the focus has shifted from merely providing static instructions to implementing dynamic **Skills** and the **Model Context Protocol (MCP)**. This evolution allows developers to manage the "Context Window"—the finite memory of an AI model—with surgical precision, ensuring the agent only sees what it needs to see to complete a specific task. Prerequisites: Setting the Stage To effectively implement Laravel Boost 2.0, you should have a baseline understanding of the following: * **Modern PHP & Laravel**: Familiarity with PHP 8.2 and Laravel 12 is essential, as Boost 2.0 has moved away from supporting older versions to utilize the latest framework features. * **AI Coding Tools**: You should be using an AI-capable editor or agent such as Claude Dev, Cursor, GitHub Copilot, or Windsurf. * **Command Line Basics**: You will need to interact with the terminal to run Artisan commands for installation and synchronization. Key Libraries & Tools * **Laravel Boost**: The core package that manages guidelines, skills, and the MCP server for AI integration. * **Laravel MCP**: A foundational package that implements the Model Context Protocol, allowing external systems (like your app) to communicate with AI models. * **Composer**: Used for managing dependencies and third-party AI skills. * **MCP Inspector**: A utility for debugging the connection between your editor and the MCP server. Code Walkthrough: Installation and Configuration Setting up Laravel Boost 2.0 is a methodical process. It begins with a standard installation and moves into configuring how the AI interacts with your files. Step 1: Installation Run the following command in your project root: ```bash composer require laravel/boost --dev php artisan boost:install ``` During installation, the CLI will prompt you to select which AI agents you are using (e.g., Cursor, Claude). This is critical because each agent looks for context in different locations—Cursor uses `.cursorrules`, while others might look for `agents.md`. Step 2: Synchronizing Skills and Guidelines Whenever you update your configuration or add custom rules, you must run the update command to rebuild the context files that the AI reads: ```bash php artisan boost:update ``` This command scans your `AI/guidelines` and `AI/skills` directories, composing a unified markdown file (like `claudedev.md`) that represents the current state of your project's rules. Step 3: Customizing Business Logic One of the most powerful features of Boost 2.0 is the ability to inject custom business context. You can publish the configuration file to unlock this: ```bash php artisan vendor:publish --tag=boost-config ``` Inside `config/boost.php`, you can add a `purpose` key. This is where you tell the AI exactly what the app does—for example, "This project is a logistics platform for tracking international shipping containers." ```php return [ 'purpose' => 'A financial dashboard for tracking cryptocurrency tax compliance.', 'coding_style' => 'Spatie', // ... other config ]; ``` Syntax Notes: The Architecture of a Skill A **Skill** in Boost 2.0 is a specialized markdown file that the AI can "invoke" only when needed. This prevents the context window from being cluttered with irrelevant information. The syntax follows a specific pattern: ```markdown Name: Inertia Vue Development Description: Use this skill when building or modifying Vue components within the Inertia.js stack. Implementation Guidelines - Always use the <script setup> syntax. - Utilize Tailwind CSS for all styling. - Ensure all components are stored in the resources/js/Pages directory. ``` The AI reads the `# Description` to decide if the skill is relevant to your current prompt. If you ask to fix a CSS bug, it will pull in the **Tailwind Skill** but ignore the **Database Skill**, saving thousands of tokens. Practical Examples: Real-World Agent Workflows Automated Refactoring with Verification Don't just ask an AI to refactor code; ask it to verify its work using the tools provided by Laravel Boost. A high-level prompt might look like this: "Refactor the `OrderController@store` method to use a Form Request. Use the **Laravel Skill** for validation patterns. Once completed, use the **Tinker Tool** via MCP to create a test order and ensure the database record is created correctly." Documentation Ingestion If you are using a new package that the AI hasn't been trained on, you can use the `search_docs` tool provided by the Boost MCP server. The agent can query the latest Laravel documentation in real-time to find the correct syntax for Laravel 12 features like Pest integration or the newest Inertia helpers. Tips & Gotchas: Navigating the AI Frontier * **The Context Trap**: Be careful not to put too much in your `guidelines`. If your `agents.md` file becomes 10,000 lines long, the AI will lose the thread of your conversation. Move specific package logic into **Skills** so they are only loaded on demand. * **Plan Mode First**: Always use "Plan Mode" in your AI editor before letting it write code. This allows the agent to outline its approach based on the Boost guidelines before it commits to a file structure. * **Sync Often**: If you change a route name or a config value, run `php artisan boost:update`. If you don't, the AI will be working from a "ghost" version of your app's previous state. * **Override Wisely**: Boost comes with sensible defaults for Tailwind and Pest. However, if your team has a unique way of writing tests, create a custom file in `AI/skills/pest.md` to override the default Laravel Boost behavior.
Vehicle
Companies
Laravel (6 mentions) highlights Vehicle in technical presentations like 'Benchmarks, Bots, and Best Practices' at Laracon US 2025 to discuss framework optimization.
- Jan 28, 2026
- Aug 21, 2025
- Jul 31, 2025
- Oct 29, 2024
- Sep 10, 2024
The Legacy Paradox and the Developer Condition Software development is a constant battle against entropy. Every line of code we write today becomes the technical debt of tomorrow. This cycle creates a specific psychological state among programmers: the desire to burn it all down and start fresh. Caleb Porzio, the creator of Livewire and Alpine.js, defines legacy code not by its age or the version of its framework, but by the resentment it inspires in the developer. We often find ourselves trapped in the "Legacy Coder" lifestyle. This involves working with outdated build tools like webpack version zero or local environments stuck in Vagrant or Homestead. When you open your editor to build a new feature, you don't find a clean slate; you find a tangled web of dependencies and "god files" that do too much. This creates a stark contrast between the serene, minimalist workspaces we see on social media and the actual state of our codebases, which feel cluttered and overwhelming. This resentment is the primary driver for the big, bad rewrite. Unearthing Dormant Concepts Through Rewrites Why are rewrites so seductive? Beyond the chance to use modern technology, the most significant value of a rewrite is the ability to express concepts that have been lying dormant in your code. When you first build an application, you have a basic understanding of the domain. As the product evolves, patterns emerge—shapes of logic, conditionals, and dependencies that repeat throughout the system. In a legacy system, these patterns are often scattered across multiple files or buried inside massive classes. A rewrite allows you to identify these emergent concepts and give them a formal name, a specific file, and a dedicated test suite. During the transition from Livewire V2 to Livewire V3, Caleb discovered that the "Component" concept in his JavaScript was actually a junk drawer. By rewriting, he was able to deconstruct that god class into modular folders where every feature—like form objects or file uploads—lives in its own isolated directory. This modularity ensures that the core framework remains lean while features can be added or removed without side effects. The Bitter Reality of the "New System" Despite the excitement of a blank canvas, rewrites are notoriously dangerous. The phrase "it's the new system" is often used by frustrated users to describe a product that feels worse, lacks features, or is simply unfamiliar. Rewrites almost always take significantly longer than anticipated. Caleb notes that even for a relatively small codebase like Alpine, a rewrite can take a year. For Livewire, the process spanned a year and a half and three separate attempts before a stable version emerged. Business stakeholders often struggle to see the value in a rewrite. From their perspective, the current UI works fine. They see a massive financial investment aimed at simply returning to the same functional state the app is currently in. This requires an immense amount of trust between developers and product owners. If that trust is broken by a project that misses deadlines and ships with regressions, the relationship can be permanently damaged. The goal should never be to rewrite for the sake of "shiny object syndrome," but to solve deep-seated architectural problems that prevent the business from moving forward. Strategies for Avoiding the Burn-Down Before committing to a total rewrite, developers should exhaust every other option. The first line of defense is simplicity. Selling simplicity to stakeholders—reducing the number of features rather than adding new ones—can often solve the problems that make a codebase feel like legacy. Choosing lasting tools is another critical factor. Laravel is a prime example of a framework that has stood the test of time. An app written in Laravel eight years ago still feels remarkably similar to one written today because the core conventions have remained stable. Modularity is the bridge between a messy monolith and a total rewrite. By adopting a Single File Principle or a feature-based folder structure, you can isolate parts of your application. This allows for "isolated refactoring," where you can delete and rewrite a single folder's logic without affecting the rest of the system. This approach provides the benefits of a fresh start without the risk of a full-scale cut-over. Furthermore, fostering a culture of accountability through pair programming and rigorous code reviews ensures that quality is baked into the daily workflow, preventing the accumulation of the very resentment that leads to rewrite requests. Execution: Testing and Rollout Methods If a rewrite is unavoidable, the most critical prerequisite is a robust test suite. Cypress or other acceptance testing tools allow you to verify the behavior of the system from the outside in. When Caleb rewrote Alpine, he used a suite of browser tests that didn't care about the internal implementation. This "insurance policy" allowed him to trash the old code and rewrite it from scratch, knowing that if the tests passed, the functionality was preserved. When it comes to launching the new version, there are three primary strategies. The **Cut-Over** is the traditional method but is often the most painful due to data migration and feature parity issues. The Strangler Fig pattern involves slowly replacing parts of an old app with a new one, often using a load balancer to route traffic. However, this can result in a "Frankenstein app" that stays in a half-finished state for years. Caleb advocates for the **One More Thing** approach, popularized by Basecamp. This involves launching the rewrite as a brand-new version (e.g., Livewire V3) while keeping the old version alive. This makes business sense because the new version can be marketed as a fresh product with highly requested features, attracting new users while allowing existing ones to migrate at their own pace. This aligns the technical desire for a clean codebase with the business need for growth. The Final Verdict Rewriting a codebase is a high-stakes gamble that requires more than just technical skill; it requires emotional maturity and business alignment. While the allure of the "clean desk" is strong, the reality is often a long, arduous journey through edge cases and missed deadlines. By focusing on modularity, testing, and choosing stable tools like Laravel, developers can often stave off the need for a total rewrite. However, when the resentment becomes too great and the architectural debt too heavy, a strategic, versioned rewrite can propel a project to new heights of adoption and maintainability. The key is to remember that code is for people—both the users who interact with the UI and the developers who must live inside the logic every day.
Jan 30, 2024