The Mobile Dilemma for Backend Engineers For years, backend web developers faced a steep mountain when attempting to build mobile applications. Moving away from PHP meant learning entirely new paradigms, environments, and languages. Today, the landscape is highly fragmented. Laravel developers, in particular, now have three viable paths for mobile development: React Native, Flutter, and the emerging NativePHP. Each option demands a different trade-off between the developer's existing skillset and current market demands. Three Paths with Distinct Paradigms These three frameworks approach mobile development from fundamentally different angles: * **React Native**: Powered by TypeScript and the Expo framework, this option targets web developers who already know JavaScript. It compiles to native components, making it a powerful, highly popular choice. * **Flutter**: Relying on Dart, Google's framework operates as its own distinct ecosystem. In Flutter, almost everything is a widget. It offers high performance but requires learning a completely unique language and paradigm. * **NativePHP**: The most exciting development for backend purists. This framework lets you compile a standard Laravel application—complete with Livewire or Vue.js—directly into an Android or iOS build. You write standard controller logic, render blade views with Tailwind CSS, and let the framework handle the mobile compilation. The Job Market Gap While NativePHP offers the lowest barrier to entry for a PHP developer, the job market tells a different story. Job data on platforms like Upwork reveals a massive commercial gap. React Native leads the market in sheer volume, closely followed by Flutter. In contrast, dedicated job postings for NativePHP are virtually non-existent. Deciding Your Stack If your goal is immediate marketability or client work, React Native remains the safest bet. If you want a highly performant, custom UI and do not mind learning Dart, Flutter is an exceptional choice. However, for solo developers and Laravel purists looking to ship an internal tool or a SaaS companion app quickly, NativePHP represents an incredibly fast path to production without leaving your comfort zone.
Tailwind CSS
Products
Dec 2020 • 1 videos
Lighter month. Laravel covered Tailwind CSS across 1 videos.
Jan 2021 • 1 videos
Lighter month. Laravel covered Tailwind CSS across 1 videos.
Jul 2023 • 1 videos
Lighter month. Laravel covered Tailwind CSS across 1 videos.
Aug 2023 • 1 videos
Lighter month. ArjanCodes covered Tailwind CSS across 1 videos.
Jul 2024 • 1 videos
Lighter month. Laravel covered Tailwind CSS across 1 videos.
Sep 2024 • 2 videos
Steady coverage of Tailwind CSS. Laravel contributed to 2 videos from 1 sources.
Oct 2024 • 1 videos
Lighter month. Laravel covered Tailwind CSS across 1 videos.
Feb 2025 • 4 videos
High activity month for Tailwind CSS. Laravel among the most active voices, with 4 videos across 1 sources.
Mar 2025 • 2 videos
Steady coverage of Tailwind CSS. Laravel contributed to 2 videos from 1 sources.
Jul 2025 • 1 videos
Lighter month. AI Engineer covered Tailwind CSS across 1 videos.
Aug 2025 • 4 videos
High activity month for Tailwind CSS. Laravel among the most active voices, with 4 videos across 1 sources.
Sep 2025 • 2 videos
Steady coverage of Tailwind CSS. Codex Community and Laravel contributed to 2 videos from 2 sources.
Nov 2025 • 2 videos
Steady coverage of Tailwind CSS. Laravel Daily contributed to 2 videos from 1 sources.
Dec 2025 • 4 videos
High activity month for Tailwind CSS. Laravel Daily, Codex Community, and Laravel among the most active voices, with 4 videos across 3 sources.
Jan 2026 • 4 videos
High activity month for Tailwind CSS. Laravel and Laravel Daily among the most active voices, with 4 videos across 2 sources.
Feb 2026 • 5 videos
High activity month for Tailwind CSS. Laravel Daily, AI Coding Daily, and Laravel among the most active voices, with 5 videos across 3 sources.
Mar 2026 • 2 videos
Steady coverage of Tailwind CSS. AI Coding Daily and Laravel Daily contributed to 2 videos from 2 sources.
May 2026 • 2 videos
Steady coverage of Tailwind CSS. AI Coding Daily and Laravel Daily contributed to 2 videos from 2 sources.
Jun 2026 • 3 videos
Steady coverage of Tailwind CSS. Laravel Daily contributed to 3 videos from 1 sources.
- Jun 30, 2026
- Jun 23, 2026
- Jun 2, 2026
- May 13, 2026
- May 2, 2026
Overview of Visual Annotations Explaining visual changes to an AI agent often involves a clunky workflow of screenshots, manual uploads, and imprecise descriptions. Instruckt changes this by allowing developers to annotate DOM elements directly in the browser. Instead of guessing class names or describing a button's location, you click the element, add a note, and generate a markdown prompt that contains the exact technical context Claude Code needs to execute the change. This precision reduces the "hallucination" factor when AI attempts to style UI components. Prerequisites To follow this workflow, you should be comfortable with basic Laravel development and Tailwind CSS. You also need an AI agent capable of processing markdown context, such as Claude Code. Familiarity with Composer for package management is required for the installation steps. Key Libraries & Tools - **Instruckt-Laravel**: The specific adapter for Laravel applications. - **Instruckt Core**: A framework-agnostic JavaScript core that handles the annotation logic. - **Claude Code**: The CLI-based AI agent that receives the markdown feedback to modify the source code. - **Blade Components**: The templating engine used to inject the annotation toolbar. Implementation Walkthrough Installing the tool requires a quick pull via Composer. Run the following command in your terminal: ```bash composer require joshcirre/instruckt-laravel ``` Once installed, you must register the visual toolbar. In a Laravel environment, you typically place the Blade component at the bottom of your global layout file (e.g., `app.blade.php` or `welcome.blade.php`): ```html <x-instruckt /> ``` This tag renders a floating toolbar on your frontend. When you enter "Annotate" mode, the tool identifies the underlying Tailwind CSS classes and HTML structure of whatever you click. After adding notes, click "Copy Annotations as Markdown." You then paste this directly into your AI terminal. The agent sees a structured list of targeted elements and your specific instructions, allowing it to swap links or adjust font sizes with perfect accuracy. Syntax and Conventions The tool relies on the `x-instruckt` Blade component pattern, which is standard for modern Laravel packages. It intelligently scrapes Tailwind CSS classes from the DOM. If you are using Livewire, Instruckt offers specialized adapters to ensure the toolbar persists across reactive state changes. Tips & Gotchas Always wrap your Instruckt component in an environment check. You likely don't want the annotation toolbar appearing in production. Use a conditional check like `@env('local')` to ensure it only loads during development. If the agent fails to find an element, ensure your classes aren't being obfuscated by a minifier during the build process, as Claude Code needs those class strings to locate the correct line in your source files.
Mar 8, 2026Overview AI models like Claude and GPT have reached a point where they can generate functional code with minimal prompting. However, "functional" is not synonymous with "production-ready." Default configurations often miss project-specific nuances, especially within the Laravel ecosystem. By implementing custom guidelines, developers can move beyond generic code generation to enforce architectural integrity, automated testing, and specific framework requirements like Filament themes. Prerequisites To implement these strategies, you should have a solid grasp of the Laravel framework and the Filament TALL stack. Familiarity with AI agentic workflows—specifically using tools like Claude Code or Laravel Boost—is essential for integrating markdown-based rule files into your development cycle. Key Libraries & Tools * **Laravel**: The primary PHP framework used for web application development. * **Filament**: An admin panel and TALL stack toolkit for Laravel. * **Claude Code**: An AI agent designed to interact directly with your local codebase. * **Laravel Boost**: A tool for managing and applying custom developer guidelines to AI prompts. Code Walkthrough To enforce specific standards, you must create a `.md` file (e.g., `guidelines.md`) that the AI agent reads before generating code. Below is a conceptual example of how to structure a rule for Filament smoke tests. ```markdown Testing Rules - For every new Filament Resource, you MUST generate a Pest or PHPUnit smoke test. - The test must verify that the list, create, and edit pages return a 200 status code. ``` When the AI processes this, it checks its output against the directive. Without this specific prompt, models often skip testing to speed up generation, leaving you with technical debt. Another critical rule involves Tailwind CSS integration within Filament custom pages: ```markdown Filament Custom Themes - If a custom Blade view includes Tailwind classes, automatically generate a custom Filament theme. - Register the theme in the Panel Provider to ensure CSS is compiled correctly. ``` Syntax Notes Custom guidelines rely on clear, imperative language. Use strong verbs like "MUST," "ALWAYS," or "NEVER." Structure these in Markdown format within specialized files like `CLAUDE.md` or `agents.md`. AI agents prioritize these local instructions over their general training data, allowing you to override default behaviors such as PHP Facade usage in favor of helper functions. Practical Examples A common real-world application is the enforcement of Enums across a project. Instead of allowing the AI to use hard-coded strings for statuses, a guideline can mandate that all status fields utilize a specific Enum directory. This ensures that when the AI generates a Filament table, it automatically implements the `HasLabel` and `HasColor` interfaces, providing a consistent UI without manual refactoring. Tips & Gotchas Avoid over-complicating your guidelines with minor stylistic preferences. High-noise guidelines can overwhelm the model's context window, leading it to ignore more critical instructions like security protocols or test generation. Focus your custom rules on high-impact areas: test enforcement, complex framework configurations, and project-specific architectural patterns.
Mar 1, 2026Overview Laravel Blaze is a high-performance Blade compiler designed to eliminate the rendering overhead that plagues modern, component-heavy Laravel applications. As developers move away from global Bootstrap styles toward granular Tailwind%20CSS components, the number of Blade components on a single page has exploded. A typical dashboard might render thousands of nested components, leading to server-side bottlenecks where rendering alone takes hundreds of milliseconds or even seconds. Caleb%20Porzio developed Laravel%20Blaze to solve this specifically for the Flux UI library, though it works with any anonymous Blade component. By utilizing advanced compiler techniques like **memoization** and **code folding**, Blaze can reduce rendering times by over 90%, turning a 1.5-second render into a 6-millisecond flash. It accomplishes this by bypassing the heavy lifting Laravel's core engine usually performs—such as container lookups and view resolution—and transforming components into highly optimized PHP functions. Prerequisites To get the most out of this tutorial, you should have a solid foundation in the following: - **Laravel Basics**: Understanding the request lifecycle and service providers. - **Blade Components**: Familiarity with anonymous components, props, and slots. - **PHP Performance Concepts**: A basic understanding of how `opcache` works and why file system lookups are expensive compared to in-memory operations. - **Composer**: Ability to manage packages via the PHP dependency manager. Key Libraries & Tools - Laravel%20Blaze: The core package that provides the optimized compiler and optimization directives. - Livewire: While not strictly required, Blaze is built by the Livewire team and integrates seamlessly with its reactive patterns. - Flux: A UI component library that heavily utilizes Blaze to maintain high performance despite its complex Tailwind%20CSS structure. - **The Blaze Profiler**: A built-in debugging tool that visualizes component render times and folding status. Code Walkthrough: Implementing Blaze Installation and Basic Setup First, pull the package into your project using Composer. Although it is developed by the Livewire team, it is a standalone Laravel package. ```bash composer require livewire/blaze ``` Once installed, you must opt-in your components to the Blaze compiler. You do this by adding the `@blaze` directive at the very top of your component file. ```php {{-- resources/views/components/button.blade.php --}} @blaze <button {{ $attributes }}> {{ $slot }} </button> ``` When you add `@blaze`, the package intercepts the standard Blade compilation. Instead of Laravel generating a file that performs dozens of `app()->make()` and `view()->exists()` calls at runtime, Blaze generates a plain PHP function. This function accepts props and slots as arguments and returns a string, bypassing the overhead of the Laravel Container entirely. Level 2: Component Memoization If your page renders the same component multiple times with the exact same attributes (like a status badge or a specific icon), you can enable **memoization**. This caches the rendered HTML in memory during a single request. ```php {{-- resources/views/components/status-pill.blade.php --}} @blaze @memo(true) <span class="pill-{{ $type }}"> {{ $label }} </span> ``` By adding `@memo(true)`, Blaze creates a static cache key based on the component name and the serialized props. If you render this component 500 times with the same `type` and `label`, PHP only executes the logic once. The other 499 instances are simple string lookups from an internal array. Level 3: Code Folding and Partial Folding The most aggressive optimization is **Code Folding**. This attempts to "pre-render" the component at compile time rather than runtime. If a component is entirely static, Blaze replaces the component call in your parent view with the actual HTML string during the compilation phase. ```php {{-- resources/views/components/icon.blade.php --}} @blaze @fold(true) <svg ...> ... </svg> ``` When Blaze sees this icon in a parent view, it executes the Blade logic once, takes the resulting HTML, and hardcodes that HTML into the cached PHP file. This effectively deletes the component's runtime cost. For components with dynamic parts, Blaze uses **Partial Folding**. It uses a tokenized parser to identify dynamic variables, replaces them with placeholders, renders the static shell, and then re-inserts the dynamic PHP logic into the resulting string. This allows for nearly static performance even when passing a dynamic `$label` to a button. Syntax Notes: The Tokenized Parser Unlike standard Blade, which uses Regex to find and replace tags, Blaze utilizes a custom **Tokenized Parser**. 1. **Tokenization**: It breaks the source code into a flat list of tokens (Tag Open, Tag Name, Attribute, String, Variable). 2. **AST Construction**: It assembles these tokens into an **Abstract Syntax Tree (AST)**. This tree understands that a `flux:button` contains a `flux:icon` as a child. 3. **Transformation**: Blaze traverses the AST. If it finds a component marked for folding, it executes the render logic. 4. **Code Generation**: It spits out the final, optimized PHP file. This structured approach is what allows Blaze to "know" which parts of a component are safe to hardcode and which must remain dynamic. Practical Examples: Boosting a Dashboard Consider a dashboard with 1,000 table rows, each containing an avatar, a status badge, and an action dropdown. - **Without Blaze**: Laravel performs 3,000+ container lookups and merges thousands of attribute bags. This can easily take 150-200ms. - **With Blaze + Memoization**: The avatar and status badge (often repeated) are memoized. The action dropdown is optimized into a function call. Total render time drops to ~15ms. - **With Blaze + Folding**: The SVG icons within the dropdown are folded away. They no longer exist as PHP logic at runtime. Total render time drops to <10ms. Tips & Gotchas - **Static vs. Dynamic State**: Code folding is a "sharp knife." If your component relies on global state (like `auth()->user()`) but you don't pass that state as a prop, the component might fold based on the user who triggered the compilation. Always ensure folded components are pure functions of their props. - **The Profiler**: Use `BLAZE_DEBUG=true` in your `.env`. This adds a floating button to your UI that breaks down exactly how many milliseconds each component took and why it was (or wasn't) folded. - **The @unblaze Directive**: If you have a specific block within a blazified component that must remain dynamic and escape the optimized compiler's logic, wrap it in `@unblaze`. This is useful for validation errors or CSRF tokens that must be unique per render. - **Anonymous Only**: Currently, Blaze only optimizes anonymous Blade components. Class-based components are not yet supported due to the complexity of their lifecycles and constructor logic.
Feb 24, 2026Overview NativePHP v3 revolutionizes how web developers approach mobile app creation. Instead of learning Swift or Kotlin, you can now compile a standard Laravel project into native on-device code. This technique bridges the gap between web development and mobile ecosystems, allowing PHP and Laravel to run directly on iOS and Android devices without a constant server connection. Prerequisites To get started, you should have a solid grasp of the Laravel framework and basic terminal usage. Familiarity with Tailwind CSS is highly recommended since your web project must be mobile-responsive before conversion. While older versions required Xcode or Android Studio, the new version allows you to skip these entirely for initial development and testing. Key Libraries & Tools * **NativePHP Mobile v3**: The core framework that wraps Laravel for mobile devices. * **Jump App**: A specialized mobile bridge that allows you to preview your app instantly without compiling full binaries. * **SQLite**: The default on-device database used for local storage. * **Livewire**: A full-stack framework for Laravel that handles dynamic UI updates without writing complex JavaScript. Code Walkthrough Installation and Deployment First, pull the package into your existing Laravel project. No extensive configuration files are necessary for the initial jump. ```bash composer require nativephp/mobile:^3.0 php artisan native:jump ``` When you run the `native:jump` command, the system builds your assets, creates a ZIP archive, and generates a QR code. Scanning this code with the Jump App on your phone (provided both are on the same Wi-Fi) launches the app locally. Local Database Management Because mobile apps often lack constant internet, data should live in SQLite. In NativePHP, migrations take center stage for data seeding because typical seeders don't run automatically on the device. ```php public function up(): void { Schema::create('quizzes', function (Blueprint $table) { $table->id(); $table->string('title'); $table->timestamps(); }); // Seed data directly in the migration for mobile persistence DB::table('quizzes')->insert([ ['title' => 'Laravel Basics'], ['title' => 'NativePHP Advanced'], ]); } ``` Syntax Notes * **Viewport Management**: Ensure your `app.blade.php` includes proper viewport meta tags with `initial-scale=1` to prevent zooming issues. * **Utility-First Layouts**: Use Tailwind CSS classes like `w-full`, `min-h-screen`, and generous padding (`px-6`, `py-5`) to ensure touch targets are accessible for mobile users. Practical Examples This setup is ideal for local-first applications like quiz apps, offline calculators, or internal company tools that need to function without a persistent API connection. By using SQLite within migrations, you ensure every user starts with the necessary datasets pre-loaded on their device. Tips & Gotchas One common pitfall is attempting to use MySQL or PostgreSQL. NativePHP enforces SQLite usage for security, preventing developers from accidentally hardcoding sensitive database credentials into a distributed mobile binary. Additionally, always ensure your testing device and development machine share the same Wi-Fi network, or the Jump App will fail to download the bundle.
Feb 24, 2026The Battle for Laravel Supremacy Anthropic recently dropped Sonnet 4.6, a model touted to rival Opus 4.6 in raw intelligence while maintaining the speed advantage of the Sonnet line. To cut through the marketing fluff, I ran both models through a rigorous battery of tests across seven Laravel projects, including React, Vue, and Livewire starter kits. The results reveal a fascinating trade-off between speed-to-market and deep architectural adherence. Performance Metrics: Speed and Token Economy The data paints a clear picture of operational efficiency. Running all seven tasks took 39 minutes with Opus, while Sonnet finished in just 26 minutes. More importantly, the token usage disparity is massive. On a Claude Max plan, Opus consumed 37% of the session limit compared to Sonnet's much leaner profile. If you are building rapidly or working within tight API budgets, Sonnet presents a compelling economic case without sacrificing core functionality. Code Quality: Cutting Corners vs Best Practices While both models produced working code, their philosophies differ. Opus functions like a senior architect; it implemented the latest Inertia.js features and object-oriented validation rules. Sonnet, conversely, occasionally "cut corners" by using older, string-based validation syntax. However, Sonnet unexpectedly outperformed Opus in UI implementation. It integrated Flux library components and icons more effectively, whereas Opus often defaulted to standard Tailwind%20CSS tables. Final Verdict: Choosing Your Daily Driver For 95% of standard development tasks—CRUD generation, UI styling, and routine refactoring—Sonnet 4.6 is the clear winner. It is faster, cheaper, and its "short-cuts" rarely impact the final product's viability. Reserve Opus 4.6 for high-complexity architectural shifts or mission-critical debugging where you need a model that consults the latest documentation rather than relying on its first instinct.
Feb 18, 2026Overview Generating PDFs in PHP has long been a source of frustration, often requiring heavy server-side dependencies like Chrome, Node.js, or complex Docker configurations. The release of Laravel-PDF v2 by Spatie changes this by introducing a Cloudflare browser rendering driver. This allows developers to offload the entire rendering process to the edge, removing the need for local binary installations while maintaining high-fidelity output from Blade templates. Prerequisites To follow this guide, you should have a baseline understanding of Laravel and environment configuration. You will need a Cloudflare account with the Browser Rendering API enabled. No local Chromium or Puppeteer installation is required on your server. Key Libraries & Tools - **Spatie Laravel-PDF v2**: The primary package for generating PDFs from Blade views. - **Cloudflare Browser Rendering API**: The backend engine that handles the heavy lifting of HTML-to-PDF conversion. - **Tailwind CSS**: Used via CDN or Vite for styling the documents. Code Walkthrough To start, configure your `.env` file with your Cloudflare credentials and set the driver to `cloudflare`: ```env LARAVEL_PDF_DRIVER=cloudflare CLOUDFLARE_ACCOUNT_ID=your_id CLOUDFLARE_API_TOKEN=your_token ``` Within your controller, you can use the fluent API to stream or download a PDF directly from a Blade view. The package handles the API communication behind the scenes: ```python use Spatie\LaravelPdf\Facades\Pdf; public function download() { return Pdf::view('invoices.show', ['data' => $data]) ->name('invoice.pdf') ->download(); } ``` Syntax Notes The Spatie package utilizes a clean, descriptive syntax that mirrors Laravel's built-in view responses. It supports method chaining for adding metadata or choosing between inline display and forced downloads. Tips & Gotchas When setting up your Cloudflare API token, ensure the permissions are set to **Account > Browser Rendering > Edit**. A common mistake is selecting 'Read' only, which will cause the API request to fail during the generation process. Additionally, while this method simplifies DevOps, monitor your Cloudflare Workers usage to avoid unexpected costs, as the service operates on a paid tiered model.
Feb 13, 2026Modern web development demands highly interactive interfaces without the overhead of complex JavaScript frameworks. Livewire continues to bridge this gap, and its version 4 release introduces refined patterns that streamline the Laravel developer experience. By examining practical implementations, we can see how the framework balances performance with developer happiness. Dynamic Three-Level Dependent Dropdowns A common challenge in UI design is managing cascading data, such as selecting a country, state, and then a city. In Livewire v4, this is handled elegantly through updated hooks and computed properties. When a user selects a parent entity, the `updated` method triggers a refresh of the child datasets. By utilizing `wire:model.live`, the state synchronization occurs in real-time. For terminal nodes that don't trigger further UI changes, standard `wire:model` suffices, reducing unnecessary network requests while maintaining data integrity. Structured Multi-Step Form Logic Complex data entry often requires splitting forms into logical steps to avoid overwhelming the user. Livewire facilitates this by managing the `currentStep` state on the server. Developers can implement custom validation rules for each specific step, ensuring data is clean before the user progresses. The use of Tailwind CSS classes tied to the step state allows for dynamic visual feedback, such as disabling future steps or highlighting completed ones, creating a guided narrative for the end-user. Advanced Invoice Management with Real-Time Totals Building an invoice generator requires handling dynamic arrays of products and synchronized calculations. This pattern involves an `invoiceProducts` array where each entry tracks quantity and price. By leveraging computed properties for subtotal and grand total calculations, the UI stays in sync without manual event listeners. Livewire v4 handles the complex object mapping required to add or remove items from the collection while ensuring taxes and totals are recalculated instantly as inputs change. Component Communication in E-commerce Carts Isolated components often need to talk to one another, such as a product list updating a shopping cart counter. Version 4 utilizes an elegant event dispatching system. When a product is added, a global event is fired, which the cart component "listens" for to trigger a refresh. This decoupling allows developers to build modular, reusable pieces of UI that remain synchronized across the entire page layout. The Power of the Island Function and Autosave One of the most impressive additions is the `island` function, which allows specific parts of a component to refresh independently. For content creators, an autosave feature for drafts is vital. By combining an island with `wire:poll`, developers can trigger a background save every 10 seconds. This ensures that only the necessary draft logic executes, preserving the main input state and providing the user with a "Saved at" timestamp for peace of mind. Mastering these five patterns—cascading logic, multi-step flows, dynamic arrays, inter-component events, and background polling—provides a robust foundation for building high-performance Laravel applications that feel as snappy as a dedicated SPA.
Feb 5, 2026Overview: The Context Gap in AI Development AI agents have changed how we write code, but they often struggle with the nuances of specific frameworks. Standard models like Claude 3.5 Sonnet or GPT-4o possess vast general knowledge but lack the hyper-specific context of your local Laravel project. This lead to hallucinations, outdated syntax, or the AI suggesting patterns that conflict with your application's architecture. Laravel Boost solves this by acting as a bridge. It injects project-specific metadata, documentation, and "skills" directly into your AI agent's reasoning loop. Instead of manually feeding documentation to a chat window, Boost automates the context delivery. Version 2.0 introduces a major shift from a monolithic guideline approach to a modular, "skills-first" architecture. This reduces context bloat, saves on token costs, and makes the AI significantly more accurate by only providing the information it needs at that exact moment. Prerequisites To follow this guide and implement Boost 2.0, you should be comfortable with the following: * **PHP 8.2+:** Boost 2.0 has officially dropped support for PHP 8.1. * **Laravel 11 or 12:** Older versions like Laravel 10 are supported only by legacy versions of Boost (v1.x). * **Composer:** Basic knowledge of managing PHP dependencies. * **AI Coding Agents:** Familiarity with tools like Cursor, Claude Code, GitHub Copilot, or Juni. Key Libraries & Tools * **Laravel Boost:** The core CLI tool and package that manages AI context and skills. * **Laravel MCP:** A package for building Model Context Protocol servers, allowing AI agents to interact with your app's internal state (routes, database schemas, etc.). * **Remotion:** A React-based framework for programmatic video creation, often used as a demonstration of complex AI skill integration. * **Prism:** A Laravel package for working with LLMs, used to demonstrate how documentation can be bundled directly into vendor folders for AI consumption. Code Walkthrough: Installing and Configuring Boost 2.0 Setting up Boost 2.0 is a methodical process. It begins with the Laravel installer and moves into a randomized, aesthetically pleasing configuration CLI. 1. Installation First, ensure your Laravel installer is up to date to access the built-in Boost prompts during new project creation. If you are adding it to an existing project, use Composer: ```bash composer require laravel/boost --dev ``` 2. Initialization Run the install command to start the interactive configuration. ```bash php artisan boost:install ``` This command triggers a CLI interface featuring randomized gradients—a touch of "developer joy" added by Pushpak Chhajed. You will be prompted to select which features to configure: AI Guidelines, Agent Skills, or the MCP server. 3. Selecting Your AI Agent Boost 2.0 simplifies agent selection. Instead of choosing both an IDE and an agent, you now choose the specific agentic tool you use daily, such as Claude Code or Cursor. Boost will then automatically determine the correct file paths for these tools. 4. Automated Skill Syncing To ensure your AI context stays updated as your project evolves, add the update command to your `composer.json` file: ```json "scripts": { "post-update-cmd": [ "@php artisan boost:update" ] } ``` This ensures that every time you update your dependencies, Boost re-scans your `composer.json` and syncs the relevant skills for packages like Inertia, Tailwind CSS, or Livewire. Deep Dive into Skills vs. Guidelines Understanding the distinction between these two features is critical for a clean development workflow. Guidelines: The Global Rules Guidelines are persistent. They contain high-level rules that the AI should *always* know. For example, if you always use Pest for testing or strictly follow an Action-based architecture, these belong in your guidelines. However, shoving every package's documentation into a guideline leads to "context fatigue," where the AI becomes overwhelmed and starts to hallucinate. Skills: The On-Demand Context Skills are modular Markdown files. They aren't loaded into the AI's memory until they are needed. Each skill has a name and a description in its front matter. When you ask the AI to "build a new UI component with Tailwind," the agent sees the keyword "Tailwind," looks at its available skills, and activates the Tailwind CSS skill. This keeps the prompt lean and the output precise. Syntax Notes: Custom Skill Creation Creating a custom skill allows you to automate highly specific tasks, like generating pull request descriptions or adhering to internal API versioning standards. Skills rely on a specific Markdown front matter format. ```markdown --- name: my-custom-skill description: Use this skill when generating API endpoints or PR descriptions. --- My Custom Skill Rules - Always use the `App\Actions` namespace for business logic. - Ensure all API responses are wrapped in a standard `JsonResource`. - Pull Request descriptions must include a 'Breaking Changes' section. ``` When you save this in a local `.boost/skills` directory and run `php artisan boost:update`, Boost replicates this file into the hidden configuration folders of your chosen AI agents (e.g., `.cursor/rules` or `.claudecode/skills`). Practical Examples Automating Pull Requests You can create a skill that teaches an agent how to use the GitHub CLI. By invoking the skill with a slash command (e.g., `/create-pr`), the AI can analyze your staged changes, write a formatted description, and execute the CLI command to open the PR. Package-Specific Intelligence If you build a project using Filament, you don't want the AI thinking about Filament when you are just debugging a console command. By using a Filament skill, the AI only accesses those specific layout and component rules when you are actively working on the admin panel. Tips & Gotchas * **Git Management:** Never commit the auto-generated agent folders (like `.cursor/rules`) to your repository. These are local mirrors. Only commit the `.boost` folder and your `boost.json` file. This allows your teammates to run `boost:install` and get the exact same AI behavior on their machines. * **Hallucination Prevention:** If your AI starts ignoring your project structure, check your guideline length. If it exceeds 500 lines, move package-specific rules into individual skills. * **Legacy Projects:** Do not attempt to use Boost 2.0 on Laravel 10 projects. The dependency tree for the new MCP features and skills requires the modern internals found in Laravel 11 and up. * **Manual Invocation:** If an agent fails to auto-detect a skill, you can usually force it by using a slash command in the chat interface. Most modern agents support `/` to list and select active skills.
Jan 30, 2026Overview: 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.
Jan 28, 2026Overview Laravel Notify by Arthur%20Mone streamlines the implementation of toast notifications within the Laravel ecosystem. Version 3 introduces refined animations and a variety of visual presets that move beyond standard success or error alerts. It serves as a bridge between backend logic and frontend user feedback, allowing developers to trigger high-quality UI components directly from controllers or components. Prerequisites To implement this package effectively, you should possess a working knowledge of the PHP language and the Laravel framework. Familiarity with Tailwind CSS is necessary for styling, and basic understanding of Blade templates or Livewire will help you place the notification components correctly. Key Libraries & Tools - **Laravel Notify**: The primary package for flash notifications. - **Composer**: The dependency manager used for installation. - **Tailwind CSS**: Utility-first CSS framework required for the notification styles. - **Livewire**: Optional full-stack framework for dynamic interfaces. Code Walkthrough Begin by installing the package via Composer and publishing the configuration assets: ```bash composer require mckenziearts/laravel-notify php artisan vendor:publish --provider="Mckenziearts\Notify\LaravelNotifyServiceProvider" ``` Next, integrate the notification component into your main layout or sidebar within your Blade templates. This component acts as the container for all incoming alerts: ```blade {{-- resources/views/layouts/app.blade.php --}} <x-notify-messages /> @notifyJs ``` To trigger a notification from a controller, use the provided helper methods. The `notify()` function allows you to chain a status and a `send()` call to finalize the action: ```php public function store(Request $request) { // Logic to save data notify()->success('Feedback submitted successfully', 'Success'); return redirect()->back(); } ``` Syntax Notes The package utilizes a fluent API for notification construction. You can swap `.success()` for `.error()`, `.info()`, or `.warning()`. For specialized layouts, use the `connectify` or `emotify` methods which change the visual structure and icon set used in the toast. Practical Examples Beyond simple success messages, Laravel Notify supports "Drakify," which uses specific imagery for internal systems, and "Smiley" notifications for a more friendly user experience. These are particularly useful in administrative dashboards where you want to distinguish between system logs and user-facing feedback. Tips & Gotchas Ensure your Tailwind CSS configuration includes the package's view paths. If the notifications appear unstyled, check that you have imported the `@notifyCss` and `@notifyJs` directives in your layout. Always remember to call `->send()` at the end of your chain to ensure the flash data persists for the next request.
Jan 9, 2026