Model Context Protocol

Overview When you work with Claude Code, you often rely on MCP tools and skills to handle specialized tasks like front-end design or database management. However, a common frustration arises when the model finishes a task but leaves you wondering if it actually utilized the specific tools you requested. Understanding which tools were active is critical for debugging and ensuring your prompts trigger the right automation. This tutorial explores how to create a custom slash command to audit tool usage from your previous prompt. Prerequisites To follow along, you should have Claude Code installed and a basic understanding of how to use its terminal interface. Familiarity with the concepts of MCP (Model Context Protocol) and "skills"—which are essentially reusable tool instructions—will help you understand the output of this command. Key Libraries & Tools * Claude Code: The command-line interface and development tool from Anthropic. * Model Context Protocol (MCP): An open standard that enables AI models to connect to external tools and data sources. * Frontend-Design Plugin: An official plugin used for generating UI components and layouts. Creating the Audit Slash Command You can define custom commands globally in your configuration file. This allows you to call them at any time during a session. To create the `tools_used` command, add the following to your `user.claude.commands` file: ```json { "tools_used": "List MCP tools and Claude skills used in the last user prompt." } ``` This command works by instructing the model to review the immediate conversation history and identify which external functions were invoked. Because Claude Code treats slash commands and skills similarly under the hood, this command can effectively look back at the trace of the last execution. Practical Example: Verifying Design Skills Imagine you run a prompt to generate a new dashboard using Laravel. You expect the Frontend-Design Plugin to handle the CSS. After the task completes, simply run: ```bash /tools_used ``` The output will provide a clear breakdown of used versus unused tools. If the skill appears in the "not used" section, you know you need to adjust your prompt—perhaps by explicitly mentioning the skill name or providing clearer context for the design requirements. Syntax Notes & Best Practices Anthropic engineers have noted that slash commands and skills are practically interchangeable in the current architecture. This is why a slash command might appear as a "skill" in its own output report. To increase the likelihood of a tool being used, ensure your prompt uses keywords directly associated with that tool's definition. Keep your audit commands simple and direct to avoid polluting the context window with unnecessary verbosity.

Overview: The Context Gap in AI Development Standard AI models often stumble when working with Laravel because they lack two critical components: up-to-date documentation and framework-specific context. Generic agents rely on static training data, which means they are unaware of the latest features like request batching in Laravel 12. Laravel Boost bridges this gap by providing Model Context Protocol (MCP) servers and tailored guidelines directly to your AI agent, transforming it from a general coder into a framework expert. Prerequisites To follow this guide, you should be comfortable with the Artisan CLI and have a basic understanding of Composer package management. You will also need an AI-capable code editor such as Cursor or Claude Code. Key Libraries & Tools - **Laravel Boost**: The core package that provides tools and context to AI agents. - **Claude Code**: A command-line AI agent from Anthropic that integrates with MCP servers. - **Pest**: A testing framework for PHP included in the automated guidelines. - **Tailwind CSS**: A utility-first CSS framework supported by Boost's styling guidelines. Installation and Configuration After adding the package via Composer, you initialize the environment using a specialized Artisan command. This process generates specific guidelines by scanning your `composer.json` to see exactly which versions of tools like PHP or Alpine.js you are using. ```bash php artisan boost:install ``` During setup, you select your preferred editor and agent. Boost then injects best practices into your workspace, ensuring the AI adheres to the latest community standards and version-specific syntax. The Power of MCP Tools Once connected to the Model Context Protocol server, your agent gains "superpowers" through specialized tools: - **Search Docs**: Allows the AI to query the live Laravel documentation for brand-new features. - **Database Query**: Enables the agent to check record counts or table structures directly. - **Tinker**: Lets the AI run Laravel Tinker commands to test logic without creating temporary files. - **Browser Logs**: Helps the agent read error logs to debug issues autonomously. Syntax Notes & Best Practices Boost focuses on **version-aware syntax**. If your project uses Laravel 12, the AI will prioritize new hooks and features over deprecated Laravel 11 patterns. It also enforces strict testing standards for Pest, ensuring your generated tests are modern and readable. Tips & Gotchas Always ensure your MCP server is actually connected in your editor settings. If the AI claims it doesn't know about a feature, check if the `search_docs` tool is active. Using the **Tinker tool** is significantly safer than letting an AI create random PHP scripts, as it prevents leftover "junk" files from cluttering your production-ready codebase.

Overview of Modern Location Development Building mapping applications traditionally requires a constant context-switch between the IDE, documentation, and the Mapbox console. You might be writing JavaScript in one window while jumping to a dashboard to create a new access token or adjust a map style in another. This fragmented workflow slows down the creative process. The Mapbox DevKit MCP server solves this by bringing the entire Mapbox ecosystem directly into the developer's conversation with an AI agent. By implementing the Model Context Protocol (MCP) created by Anthropic, developers can now grant AI coding assistants—like Claude Code—the ability to perform complex location-based tasks. This isn't just about code completion. It's about giving an LLM the specific tools it needs to generate styles, manage authentication, and process geographic data like GeoJSON without leaving the terminal. This approach, often called "vibe coding," allows for rapid prototyping through natural language, where the agent handles the heavy lifting of API orchestration. Prerequisites and Technical Foundation To effectively use the Mapbox DevKit MCP server, you should have a solid footing in modern web development. Familiarity with TypeScript is helpful if you plan to extend the server, though not strictly required for general use. You will need a Mapbox account and a primary access token with specific scopes enabled. Crucially, you must be comfortable using command-line interface (CLI) tools. The server operates best when paired with an MCP-compatible client. While Claude Code is the primary example used in many demonstrations, the protocol is open-source, meaning any tool that supports the Model Context Protocol standard can interact with these tools. You should also understand the basics of JWT (JSON Web Tokens), as the server uses them to identify your Mapbox username and validate permissions for API calls. Key Libraries and Architecture The Mapbox DevKit MCP server is built on a modern stack designed for safety and speed. The architecture relies on three primary pillars: * **mcpdk**: This is the official Anthropic SDK for building MCP servers. It handles the low-level protocol communication and tool registration, allowing developers to focus on tool logic rather than connection management. * **TypeScript**: The entire codebase uses TypeScript to ensure type safety. This reduces runtime errors when the LLM attempts to pass arguments to various tools. * **Zod**: The server utilizes Zod schemas for runtime validation. These schemas serve a dual purpose: they validate the data coming from the LLM and provide the metadata (descriptions) that the LLM uses to understand how to call the tool. Code Walkthrough: Token Creation Logic Understanding how a tool is structured is key to mastering the DevKit. Let's look at the implementation of the token creation tool, which inherits from a base Mapbox API class. The structure follows a strict pattern to ensure the LLM knows exactly what inputs are required. Defining the Schema Every tool starts with a schema. This schema defines the parameters the LLM can manipulate. For a token, we need notes, scopes, and potentially an expiration time. ```typescript import { z } from 'zod'; const CreateTokenSchema = z.object({ note: z.string().describe("A description of the token's purpose"), scopes: z.array(z.string()).describe("The Mapbox scopes to grant the token"), allowedUrls: z.array(z.string()).optional().describe("Restrict token to specific URLs"), expires: z.string().optional().describe("ISO 8601 timestamp for token expiration") }); ``` The `.describe()` methods are the most critical part here. They act as the "documentation" for the AI. When the agent reads the tool's manifest, it sees these descriptions and uses them to decide which user input should map to which JSON field. Implementing the Tool Logic The implementation class handles the actual HTTP request to the Mapbox API. It uses a base tool class to handle boilerplate like JWT extraction and error logging. ```typescript export class CreateTokenTool extends MapboxApiBaseTool { name = "create_token"; description = "Creates a new Mapbox public access token with specified scopes."; async execute(input: z.infer<typeof CreateTokenSchema>) { const username = this.getUsernameFromToken(); const url = `https://api.mapbox.com/tokens/v2/${username}`; const response = await fetch(url, { method: 'POST', headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${this.accessToken}` }, body: JSON.stringify(input) }); if (!response.ok) throw new Error("Failed to create token"); return await response.json(); } } ``` This pattern separates the interface (the schema) from the implementation (the API call). The `execute` function only runs if the input matches the Zod schema, providing a robust layer of protection against malformed LLM outputs. Syntax Notes and Conventions When working within the MCP ecosystem, certain conventions help maintain compatibility. The Mapbox implementation follows the snake_case naming convention for tool names (e.g., `create_style`, `list_tokens`), which is the standard expected by most MCP clients. A notable pattern in the DevKit is the use of "Style Helpers." Instead of forcing the LLM to guess the entire Mapbox Style Specification, the server provides a helper that breaks down style creation into high-level features like "buildings," "roads," and "water." This abstraction makes it much easier for the LLM to generate valid styles without getting lost in the deep nesting of the GL JS style JSON format. Practical Examples: The "Halloween Night" Workflow Imagine you are building a holiday-themed landing page. Instead of manually picking hex codes for a dark map, you can prompt your coding agent: "Create a Halloween-themed style and apply it to my local index.html." 1. **Style Generation**: The agent calls the `style_helper` tool. It identifies that "Halloween" implies dark backgrounds, orange labels, and purple accents. It sends these preferences to the Mapbox Styles API. 2. **Visualization**: The agent then calls `preview_style`, which returns a URL. The agent can even open your browser automatically so you can inspect the "vibe." 3. **Local Integration**: Once the style is created, the agent searches your local directory for an HTML file. It finds the `mapboxgl.Map` initialization and updates the `style` property with the new Style URL it just generated. 4. **Refinement**: If the map is too dark, you simply say, "Make the labels more readable." The agent updates the existing style in-place. This iterative loop happens in seconds rather than minutes. Tips and Gotchas Security is paramount when working with AI and API keys. The Mapbox DevKit MCP server intentionally blocks the creation of secret scopes through the LLM. You should never pass your secret keys into an LLM prompt; instead, provide them as environment variables when starting the server. This ensures the AI can use the key to perform actions without ever needing to expose the key itself in its output. Another common mistake is providing overly large GeoJSON files to the preview tool. Browsers have URL length limits, and since the preview tool often encodes the data directly into the URL for instant visualization, extremely large datasets may fail to load. For large data, it is better to use the Mapbox Tiling Service (MTS) tools, which are currently being integrated into the roadmap, to convert raw data into optimized vector tiles.

The Modern Laravel Ecosystem: More Than Just a Framework Software development moves at a breakneck pace, and staying current requires more than just reading documentation; it demands a constant dialogue with the tools and the people building them. During a recent intensive session, the Laravel team provided a deep look into the current state of the ecosystem, focusing on the massive relaunch of Laravel Forge, the introduction of managed Laravel VPS, and the strategic push into Artificial Intelligence with the Model Context Protocol (MCP). These updates represent a shift from providing just a framework to offering a full-spectrum infrastructure and intelligence layer for modern web applications. The philosophy behind these updates remains consistent: reducing the cognitive load on developers. Whether it is the simplified server provisioning through the new Forge interface or the standardized way for Large Language Models (LLMs) to interact with application data via MCP, the goal is to get from "idea" to "shipped" with as few obstacles as possible. This approach has solidified Laravel as a dominant force in the PHP world, proving that the language is not just surviving but thriving in high-performance, modern environments. Rethinking Infrastructure with Laravel VPS and Forge For years, Laravel Forge has been the gold standard for painless server management, but it always required developers to bring their own third-party credentials from providers like Digital Ocean or Hetzner. The launch of Laravel VPS changes this dynamic fundamentally. By partnering directly with Digital Ocean, Laravel now offers a managed provisioning service where the server is billed and managed directly through the Forge dashboard. This removes the friction of managing multiple accounts, API keys, and billing cycles across different platforms. From a technical perspective, these VPS instances are optimized specifically for the Laravel stack. During a live demonstration, a full application was provisioned and deployed in under three minutes. This speed is not just about convenience; it is about developer flow. When you can spin up a $5-a-month instance that includes Ubuntu, Nginx, MySQL, and Redis without ever leaving the Laravel Forge UI, the barrier to entry for new projects effectively vanishes. For teams, the introduction of the multiplayer terminal in these VPS instances allows real-time collaboration directly in the browser, a feature that hints at a more integrated, collaborative future for server management. Standardizing AI Integration with Laravel MCP The most forward-looking addition to the toolkit is Laravel MCP. As AI agents become more integrated into our workflows, they need a standardized way to "understand" and interact with the applications we build. The Model Context Protocol, originally developed by Anthropic and now supported by OpenAI, provides this bridge. The new Laravel package allows developers to quickly turn their applications into MCP servers, exposing tools, prompts, and resources to LLMs. Consider the practical implications: instead of building a custom API for every potential AI integration, you define an MCP server within your Laravel app. An LLM like Claude or ChatGPT can then connect to that server to perform tasks—like summarizing links, posting updates, or querying specific database records—using a standard protocol. This moves Laravel beyond being a simple web framework and positions it as a sophisticated data provider for the next generation of AI-driven software. Tools like the Locket demo application showcase how easily these servers can be implemented, allowing AI to interact with application logic as if it were a native component. Real-Time Scalability and the Power of Reverb One of the persistent challenges in web development is managing real-time communication at scale. The discussion underscored the importance of Laravel Reverb, a first-party WebSocket server that is now the backbone for real-time updates within Laravel Cloud and the new Laravel Forge. Because Laravel Reverb is built to be Pusher-compatible, it allows for a seamless transition for developers who are used to the Pusher API but want to bring their infrastructure in-house for better performance or cost management. During the session, the real-time build logs and deployment status updates in Laravel Cloud were highlighted as a prime example of Reverb in action. The scalability of this tool is a significant milestone for the ecosystem. It proves that PHP can handle long-lived connections and high-concurrency WebSocket traffic without the need for complex Node.js or Go sidecars. For developers building chat apps, live dashboards, or collaborative tools, Reverb offers a battle-tested, first-party solution that integrates perfectly with the rest of the Laravel stack. Education and Best Practices: The Learn Platform Technology is only as good as the developers who can use it. Recognizing the steep learning curve for newcomers, the team highlighted the Laravel Learn platform. This initiative focuses on bite-sized, project-based learning that bridges the gap between theoretical knowledge and practical application. The courses currently cover PHP fundamentals and the Laravel Bootcamp, with upcoming modules expected to tackle Eloquent and database management. Best practices remain a core focus, especially regarding security. The recent addition of two-factor authentication to all Laravel starter kits—including Livewire and Inertia—demonstrates a commitment to "secure by default" development. By baking these complex features into the boilerplate code, Laravel ensures that even junior developers are shipping applications that meet modern security standards. This educational focus extends to the community as well, with the team encouraging local meetups through Meetups.laravel.com to foster a global network of experts and learners. The Future of Frontend: Inertia and Beyond The frontend landscape for Laravel continues to evolve with significant updates to Inertia. New components for infinite scrolling and enhanced form handling are streamlining the developer experience for those who prefer building with Vue or React. The announcement of Wayfinder also hints at a more sophisticated way to manage types and routing between the PHP backend and JavaScript frontend, potentially solving one of the long-standing friction points in full-stack development. Whether you are using Inertia for a highly interactive SPA or Livewire for a more traditional PHP-centric approach, the ecosystem is providing first-party tools that make both paths viable. This flexibility is a key differentiator for Laravel. It doesn't force developers into a single architectural pattern but instead provides the best possible tooling for whichever path they choose. As Laravel 13 approaches, the focus on developer experience (DX) and performance remains the North Star, ensuring the framework remains the first choice for developers who value speed, security, and stability.

The Art of Early Stage Investing in a Liquid Market Akash Bajwa, Principal at Earlybird Venture Capital, views the current venture landscape as a collision between decades of institutional wisdom and a frantic new reality. Earlybird, founded in 1997, prides itself on being the longest-standing early-stage fund in Europe. This longevity provides a unique vantage point: the ability to analogize the current AI wave with the mobile and cloud shifts of previous decades. However, the old playbooks are being rewritten in real-time. The "art" of investing now requires a delicate balance between rigorous data-driven sourcing and a qualitative, almost artisanal assessment of founders who are breaking all previous patterns. The shift is visceral. In the Cloud SaaS era, experience was the ultimate currency. Investors sought founders in their 30s and 40s who understood the labyrinthine systems of record like ERP and CRM. Today, the premium has shifted toward neuroplasticity. Young, scrappy builders who have no prior "SaaS baggage" are often better equipped to build AI-native architectures because they don't have to unlearn the legacy form factors of the last twenty years. This creates a cognitive dissonance for veteran operators who must now compete with founders learning at a velocity that traditional corporate structures simply cannot match. Velocity Over Credentials in the Founder Stack When evaluating the next generation of outlier founders, Akash Bajwa emphasizes "learning rate" over CV credentials. In a market where ChatGPT reached a billion monthly users in three years, the window of opportunity for slow, methodical validation has slammed shut. Velocity—defined as speed with a clear direction toward demand—is the primary indicator of success. The teams that win are those uncovering customer insights and iterating on their wedge products faster than the competition, often revising their core assumptions on a weekly basis. This need for speed does not negate the value of domain expertise, particularly in vertical AI. For startups targeting offline industries—like Briefcase, which focuses on the accounting sector—the ability to speak the language of the buyer remains critical. However, the technical requirement for a CTO has evolved. It is no longer just about building a stable product; it is about being "close to the bare metal." Founders like those at Briefcase and Spatial succeed because they obsessively track the bleeding edge of research, such as new releases from DeepSeek, and understand how to apply those scientific breakthroughs to specific business workflows immediately. The Infrastructure Trap and Ephemeral Pain Points One of the most dangerous areas for modern investors is the infrastructure layer. Akash Bajwa identifies a recurring pattern he calls the "Red Herring" in AI investing. Many startups are building solutions for pain points that are temporary or ephemeral. A prime example is the recent fervor around vector databases. While pure-play vector databases saw massive initial growth, incumbents like MongoDB quickly integrated vector search capabilities, effectively bundling the startup's entire value proposition into an existing suite. The "Red Wedding" of AI—where OpenAI or Anthropic release a feature that kills dozens of startups overnight—is now a recurring seasonal event. Startups building tiny middleware solutions, such as those aggregating Model Context Protocol (MCP) tools, are at high risk. If a problem is immediately adjacent to the core roadmap of a well-funded lab, that lab has every incentive to solve it. To survive, infrastructure companies must focus on areas that labs find dilutive or non-core, such as model-agnostic routing or highly specialized security frameworks that require deep enterprise trust beyond what a horizontal provider offers. Vertical AI and the Battle for Pilot Conversion The real opportunity for disruption lies in rethinking human-computer interaction at the application layer. The "Innovator's Dilemma" is particularly acute for incumbents who are reluctant to migrate their massive customer bases to new, AI-native UIs. While an incumbent might add a chatbot as a sidecar, a startup can build an entire experience around voice, dictation, or ambient assistance. This is why Earlybird backed Spatial, which tackles the 3D modality—a space where physics-aware worlds require scientific breakthroughs that horizontal labs haven't yet commoditized. Defensibility in vertical AI comes from the engineering effort required to move a client from a pilot to full production. In high-stakes fields like legal or finance, the gap between 90% and 99% accuracy is the difference between a toy and a tool. Companies like Harvey or Leyra thrive not just because they have data, but because they have invested in the specific evals, guardrails, and prompt augmentation necessary for their vertical. Even when Anthropic announces finance-specific features, the sheer depth of vertical-specific AI engineering required to handle sensitive internal data warehouses often keeps specialized startups ahead of the horizontal giants. Implications for the Future of Enterprise Software We are moving toward an "agent economy" where software traffic will be increasingly redistributed from humans to agents. This shift demands a total redesign of product form factors. The winners will be those who nail "time to value" in one specific scope before earning the right to expand. Akash Bajwa points to the "Hollywood production" vs. "Lean Startup" methodology, firmly siding with the latter in the age of AI. Releasing a viral demo, as Cluey did, allows a team to build a community and a feedback loop that informs the roadmap in real-time, rather than building in a silo for years only to find the market has moved. The future of venture capital in Europe depends on identifying these high-velocity teams early. As the asset class institutionalizes, the ability to marry data-driven sourcing with an intuitive understanding of founder-market fit will separate the longest-standing funds from the tourists. The objective remains the same: find the problem, build the solution, and ignite the market before the labs decide it’s their turn to play.

The New Frontier of AI-Native Development The relationship between developers and their code is undergoing a fundamental transformation. We are moving past the era of simple auto-completion and into a world where AI agents act as full-fledged pair programmers. Ashley Hindle, leading the AI initiatives at Laravel, describes this shift not as a replacement of the developer's craft, but as an expansion of their capabilities. The challenge remains that while Large Language Models (LLMs) are becoming increasingly sophisticated, they often lack the specific, up-to-date context of a framework's evolving ecosystem. They might know PHP, but they might not know the breaking changes in the latest version of Pest or the specific architectural nuances of a Filament project. This is where Laravel Boost enters the scene. It is not an LLM itself; rather, it is a sophisticated bridge. By providing a composer package that injects guidelines, tools, and version-specific documentation directly into the AI agent's context, it eliminates the "hallucination gap" that occurs when an AI relies on stale training data. The goal is simple: make the AI agent a more competent contributor by giving it the same reference materials a human developer would use. This approach moves development from "vibe coding"—relying on the AI's best guess—to a deterministic, high-quality workflow grounded in the actual state of the codebase and the framework. The Architecture of Context: Ingestion and Vector Search To understand how Boost works, we must look at the ingestion pipeline that powers its documentation search. Unlike static documentation, the information fed to an AI agent needs to be formatted for retrieval. Ashley Hindle explains that the team uses Laravel Cloud to host an API that serves as the central nervous system for documentation. The pipeline downloads markdown files from GitHub APIs and processes them through a recursive text splitter. This "chunking" is vital because an AI cannot ingest a 50-page manual in one go and expect to find a specific method signature accurately. These chunks are then vectorized using OpenAI embedding models and stored in PostgreSQL via PGVector. Interestingly, the team does not rely solely on vector search. They employ a hybrid approach that includes Postgres full-text search with GIN indexes. This dual-layer strategy ensures that both semantic meaning (found through embeddings) and specific syntax or keyword matches (found through full-text search) are captured. For a developer, this means when the AI searches for a specific Inertia.js helper, it finds the exact documentation snippet relevant to their specific version, rather than a generic or outdated example. Mastering the Model Context Protocol (MCP) A core technical pillar of Boost is the Model Context Protocol (MCP). Think of MCP as a standardized way for an AI agent to "talk" to a server and use its features. Ashley Hindle uses a physical analogy: if the AI is the brain, MCP provides the hands. It allows the agent to ask, "What are you capable of?" and receive a list of tools—such as searching documentation, scanning a `composer.lock` file, or checking Tailwind CSS configurations. The brilliance of the MCP implementation in Boost lies in its invisibility. When a developer installs Boost, it auto-detects system-installed IDEs and agents like Cursor, Claude Code, or PHPStorm and configures the MCP server automatically. The AI agent then decides when to call these tools based on the user's prompt. If you ask the AI to write a test, it sees the `search_docs` tool in its inventory, notices you have Pest installed, and retrieves the latest Pest documentation before writing a single line of code. This autonomous decision-making by the AI, guided by the tool descriptions provided by Boost, creates a seamless experience where the developer doesn't have to manually prompt the AI to "look at the docs." Guidelines vs. Tools: The Art of Nudging There is a subtle but critical distinction between providing an AI with a tool and providing it with a guideline. A tool is a functional capability, while a guideline is a set of behavioral rules. Ashley Hindle discovered during development that tools alone weren't enough. An AI might have access to documentation but still write code in an old style. By providing specific guidelines—often delivered via `claude.md` or `custom-instructions` files—Boost "nudges" the AI to follow modern conventions. These guidelines are dynamically generated based on the project's specific dependencies. If a project uses Livewire, Boost includes Livewire guidelines; if it uses React, it swaps them. This prevents context bloat, ensuring the AI isn't distracted by irrelevant rules. Furthermore, Boost is designed to respect the "existing conventions" of a codebase. Guidelines often tell the AI to look at sibling controllers or existing patterns first. This ensures that the AI doesn't just write "perfect" Laravel code, but code that actually fits the specific project it is working in. The team is currently working on an override system that allows developers to provide their own custom blade files for guidelines, ensuring that team-specific standards take precedence over defaults. The Economics of Tokens and Efficiency A common concern with AI-assisted development is the cost and token usage. Adding thousands of lines of documentation and guidelines to every request sounds expensive. However, Ashley Hindle argues that Boost often pays for itself. While the guidelines might add roughly 2,000 tokens to a request—a small fraction of the 200,000+ context windows in modern models like Claude 3.5 Sonnet—they significantly reduce the number of failed attempts. When an AI has the correct context, it gets the code right on the first try. Without Boost, a developer might go through five or six back-and-forth prompts to correct the AI's hallucinations, consuming far more tokens in the long run. Additionally, many providers now support prompt caching. Because the Boost guidelines remain consistent across a session, they are frequently cached at the API level, often resulting in a 90% discount on those tokens. The efficiency isn't just financial; it's temporal. The developer stays in the "flow state" because they aren't constantly acting as a human debugger for the AI's mistakes. Future Horizons: Benchmarks and Package Integration The roadmap for Laravel Boost is ambitious. One of the most significant upcoming projects is "Boost Benchmarks." Ashley Hindle is building a comprehensive suite of projects and evaluations to move beyond "gut feel" testing. This will allow the team to statistically prove that one version of Boost is, for example, 20% more accurate at fixing bugs in Filament than the previous version. It will also provide data on which LLMs—be it Claude, GPT-4o, or Gemini—perform best with specific Laravel tasks. Another major shift is the move toward a package-contributed guideline system. The Laravel team cannot write and maintain guidelines for every package in the ecosystem. The goal is to create an API that allows package creators—like Spatie—to include their own Boost-compatible guidelines within their repositories. When a developer runs `boost install`, the system will detect these third-party packages and automatically pull in the author-approved AI instructions. This decentralization will ensure that the entire PHP ecosystem can become AI-native, with every package providing the necessary context for agents to use it effectively. As context windows continue to expand toward the millions, the bottleneck will no longer be how much the AI can remember, but how accurately we can feed it the truth.

Overview Laravel Boost is a local Model Context Protocol (MCP) server designed to bridge the gap between your Laravel application and AI coding agents. While standard AI models often guess at your project structure, Boost provides a direct window into your database schema, application configuration, and log files. This context transforms generic code suggestions into precise, project-aware solutions. Prerequisites To follow this tutorial, you should have a baseline understanding of the PHP ecosystem and Laravel framework. You will need Composer installed globally and a modern AI-integrated IDE or CLI agent such as Claude Code, Cursor, or PHPStorm. Key Libraries & Tools * **Laravel Boost**: The core package providing the MCP server and specialized guidelines. * **Claude Code**: An AI agent capable of executing terminal commands and modifying files. * **Tinker**: An interactive REPL for Laravel, used by Boost to safely test PHP code snippets. * **MCP Server**: A standardized protocol that allows AI agents to use external tools and data sources. Code Walkthrough Installing the package requires a simple dev-dependency addition via Composer. ```bash composer require laravel/boost --dev php artisan boost:install ``` During installation, the tool prompts you to select your preferred editor and agent. This process generates specific configuration files, such as `.claudemdrules` or `cursor.rules`, which contain tailored instructions for the AI regarding your Laravel version and testing framework. Boost also enables a set of powerful tools. For example, when debugging an **N+1 query issue**, the AI can utilize the `search-docs` tool to find the most recent documentation for Laravel 12. It can then suggest implementing Automatic Eager Loading: ```php // In AppServiceProvider.php public function boot(): void { Model::shouldBeStrict(! $this->app->isProduction()); // Laravel 12 feature for automatic eager loading Model::preventsLazyLoading(! $this->app->isProduction()); } ``` Syntax Notes Boost relies heavily on **Markdown-based guidelines**. It scans your project for a custom `AI-guidelines` directory and injects your specific business logic or coding standards into the AI's prompt. This ensures the agent follows your unique architectural patterns rather than just generic boilerplate. Practical Examples 1. **Database Seeding**: Ask your agent to "add a new feature to the database," and it will use Tinker to create models, categories, and relationships without you writing a single line of SQL. 2. **Error Resolution**: If your application crashes due to a missing `APP_KEY`, the agent can read the Laravel logs directly and perform the fix automatically. Tips & Gotchas Always verify the MCP server status in your IDE. If the agent seems "blind" to your database, ensure the server is running and you have granted permission for the agent to use the `database-schema` and `tinker` tools.