PHP

Overview Transitioning a local Laravel project into a production-ready API for platforms like RapidAPI requires more than just functional code. It demands standardization, rigorous versioning, and comprehensive documentation. This process demonstrates how to transform a basic PHP backend into a commercial-grade product using Codex CLI to accelerate the heavy lifting of boilerplate and documentation. Prerequisites To follow this workflow, you should be comfortable with Laravel 11 fundamentals, basic terminal usage, and the Composer package manager. You will also need a RapidAPI account to test the final deployment and local access to an AI agent like Codex CLI to replicate the automated refactoring steps. Key Libraries & Tools * **Laravel**: The primary PHP framework providing the application structure. * **Codex CLI**: An AI-driven terminal agent used for refactoring routes and generating docblocks. * **Scramble**: A documentation package that generates OpenAPI (Swagger) files automatically from Laravel code without manual YAML authoring. * **RapidAPI**: The marketplace platform where the API is hosted and monetized. Code Walkthrough Step 1: Initialize and Version After running `laravel new` and `php artisan install:api`, the first task is establishing a versioned prefix. This ensures future updates don't break existing client integrations. ```php // bootstrap/app.php or routes/api.php Route::prefix('v1')->group(function () { Route::post('/clean-text', [TextCleanerController::class, 'handle']); }); ``` Step 2: Health Monitoring Public platforms require a health check endpoint to monitor uptime. This simple route returns a `200 OK` status to verify the service is alive. ```php // routes/api.php Route::get('/health', function () { return response()->json(['status' => 'ok']); }); ``` Step 3: Automated Documentation Using Scramble, we add PHP docblocks to controllers. The AI agent can analyze the Scramble documentation and apply these tags automatically. ```php /** * Clean Text * * This endpoint removes whitespace and normalizes text input. * @bodyParam text string required The raw text to clean. */ public function handle(Request $request) { // Logic here } ``` Syntax Notes Notice the use of **Laravel's Route::prefix**; this is a best practice for API longevity. Additionally, the **Scramble** package relies on specific `@bodyParam` and `@response` tags within docblocks to build the OpenAPI JSON schema. Using an AI agent to write these prevents syntax errors in the documentation that could cause RapidAPI import failures. Tips & Gotchas * **Environment Sync**: Ensure your `APP_ENV` is set correctly. Scramble often restricts documentation access in production environments by default; you must configure the gate in the `ScrambleServiceProvider` to allow RapidAPI to fetch the schema. * **Testing Versions**: When refactoring to a `/v1/` prefix, update your Pest or PHPUnit tests immediately. Use a global variable for the version string to avoid hardcoding it in every test file.

Project Architecture and Model Comparison Building a Laravel project from a single prompt requires an AI model to handle complex dependency management and architectural consistency. In a head-to-head evaluation, GLM-5.1 attempted to construct a checklist application with PDF export capabilities using the Livewire starter kit. While it successfully delivered a functional application, the 20-minute execution time revealed significant friction compared to Opus 3.5 (often referred to in context as Opus 4.6), which completed a more refined version in just six minutes. The disparity highlights a gap in how different LLMs internalize modern PHP ecosystems and UI libraries. Prerequisites and Tech Stack To replicate this automated build process, developers should be familiar with the following: * **PHP 8.x and Laravel Framework**: Understanding of MVC patterns and routing. * **Livewire 4**: Knowledge of full-stack components and single-file component syntax. * **Flux UI**: Familiarity with the official Laravel UI library for modern components. * **Open Router**: A unified API interface used to access GLM-5.1 within VS Code. Debugging the Flux UI Bottleneck GLM-5.1 struggled primarily with Flux UI syntax. It repeatedly hallucinated component names, such as `clipboard-check`, and failed to recognize that the correct variant attribute for buttons is `outline`, not `outlined`. This led to a recursive "loop of failure" where the agent ran automated tests, failed, and attempted to fix the code blindly. ```php // Hallucinated Flux Syntax <flux:radio label="Yes" /> // Corrected implementation after multiple failures <flux:select label="Choose Response"> <option value="yes">Yes</option> </flux:select> ``` Code Quality and Performance Optimization A deep dive into the generated code reveals that while GLM-5.1 produces working software, it misses critical optimizations. A review by Claude identified an N+1 query issue in the dashboard view. Instead of loading only the count of items, the model loaded entire collections into memory. ```php // Inefficient: Loads all items just to count them $checklists = Checklist::with('items')->get(); // Recommended: Uses database-level counting $checklists = Checklist::withCount('items')->get(); ``` Final Verdict on Agentic Capabilities GLM-5.1 demonstrates impressive stamina for long-horizon tasks, remaining stable over 16 distinct task items. However, its lack of specific training on the latest Flux UI documentation resulted in a $2.15 cost per run on OpenRouter due to high token usage during debugging. For developers seeking efficiency, Claude remains the superior choice for high-fidelity UI and performance-first Laravel development.

The agentic revolution of the VS Code fork Cursor 3 represents a fundamental pivot in how we think about integrated development environments. It is no longer just a VS Code fork with a chat sidebar; it is evolving into a dedicated multi-agent environment. This shift mirrors the trajectory of tools like Conductor and Solarterm, placing the developer in the role of a high-level orchestrator rather than a line-by-line writer. The interface now allows for parallel workspaces where separate agents can tackle different tasks simultaneously, signaling a move toward "agent-first" development. Performance showdown across frontier models Testing Cursor 3 across different models reveals significant variance in both speed and capability. In a head-to-head comparison using a Laravel CRUD task, Composer 2 clocked in at a blistering 3 minutes and 21 seconds. While fast, it lacked the depth of GPT-4o (referred to as GPT-54 in the interface), which took nearly 9 minutes but implemented more nuanced features like post counts in category tables. Claude 3.5 Opus (Opus 4.6) lagged significantly in speed, though it delivered high-quality code. The takeaway is clear: speed often comes at the cost of architectural depth, and Composer 2 is built for velocity over complexity. Cloud agents and the infrastructure overhead One of the most ambitious features is the introduction of cloud agents. These allow you to run prompts in a remote virtual machine, theoretically freeing your local resources. However, the experience feels unpolished. During testing, the cloud environment lacked basic binaries like PHP, forcing the agent to spend valuable time and tokens installing dependencies and generating app keys. While it eventually succeeded in creating a pull request, the process felt slower and more cumbersome than local execution. Unless you are away from your main machine, the local agent remains the superior choice for efficiency. The steep cost of agentic orchestration Price remains the biggest hurdle for Cursor 3 adoption. Running a single multi-agent session for a simple CRUD project consumed approximately $5 worth of usage from a standard monthly plan. For context, a few hours of intensive agentic work could easily exhaust a user's monthly token quota. Cursor essentially acts as a middleman, paying API rates to providers like Anthropic and OpenAI, then passing those costs (with a premium) to the user. Compared to Claude Code or Codeium, which may offer different usage tiers, Cursor feels like a luxury tool that requires careful management of "max mode" to avoid a billing disaster. Final verdict on the agentic workspace Directionally, Cursor 3 is brilliant. It anticipates a future where we prompt, review, and merge rather than type. However, the current pricing model and the overhead of cloud environments make it a hard sell for the budget-conscious developer. If you value the ability to run three models against the same problem to find the best solution, the workflow is unmatched. For everyone else, it’s a glimpse into an expensive future that still needs a few more iterations to become a daily driver.

Overview Modern API development requires more than just returning JSON. It demands predictability and standardization. Combining the native JSON:API support in Laravel 13 with specialized packages creates a robust ecosystem for building scalable, documented, and filterable interfaces. This setup ensures that front-end clients receive data in a consistent format while providing back-end developers with powerful tools to manage complex queries and documentation without manual overhead. Prerequisites To follow along, you should have a solid grasp of PHP and Laravel fundamentals. Familiarity with Eloquent ORM, RESTful API design, and Composer for package management is essential. Knowledge of the JSON:API specification will help you understand the structural requirements of the response data. Key Libraries & Tools * **Laravel 13**: The framework providing native JSON:API resource support. * **Spatie Query Builder**: A package that handles complex filtering, sorting, and including relationships via URL parameters. * **Scramble**: An automated documentation generator that produces OpenAPI 3.1.0 specifications directly from your code. Code Walkthrough Converting a standard resource to a JSON:API resource in Laravel 13 simplifies the class structure. Instead of manual arrays, you define attributes and relationships. ```php namespace App\Http\Resources; use Illuminate\Http\Resources\JsonApi\JsonApiResource; class BookResource extends JsonApiResource { public function attributes($request): array { return [ 'title' => $this->title, 'price' => $this->price, 'in_stock' => $this->in_stock, ]; } public function relationships($request): array { return [ 'author' => $this->author, ]; } } ``` In the controller, Spatie Query Builder intercepts the request to apply filters. We restrict which fields are queryable for security. ```php public function index() { $books = QueryBuilder::for(Book::class) ->allowedFilters(['title', 'in_stock', 'price']) ->allowedIncludes(['author']) ->get(); return BookResource::collection($books); } ``` Syntax Notes JSON:API requires IDs to be strings, even if they are integers in the database. Furthermore, all model fields must reside within an `attributes` wrapper. Laravel 13 handles this wrapping automatically when you extend `JsonApiResource`. Note the usage of `allowedFilters` in the query builder; it prevents users from guessing column names that shouldn't be exposed. Practical Examples By utilizing Spatie Query Builder, users can perform advanced queries directly through the URL. For instance, `GET /api/books?filter[price]=<45&sort=-price&include=author` returns books cheaper than 45 units, sorted descending by price, with the author data included. This eliminates the need for writing dozens of conditional `if($request->has(...))` statements in your controllers. Tips & Gotchas Scramble generates documentation on the fly without an artisan command, meaning your docs are always in sync with your code. However, ensure you use proper type hinting and docblock comments for Scramble to accurately detect validation rules. When using filters, remember that Spatie Query Builder expects an array syntax like `filter[name]=value`, which might differ from standard query strings.

Overview: The Shift Toward Code Literacy in 2026 Software development has reached a tipping point where the ability to read and verify code is becoming more valuable than the mechanical act of typing it. Laravel 13 remains the gold standard for PHP development by providing a structured, expressive environment that pairs perfectly with modern AI agents like Claude Code. This guide explores how to build functional web applications—from landing pages to authenticated CRUD systems—using Laravel as the backbone and AI as the engine. The core of the framework revolves around the Model-View-Controller (MVC) architecture. By separating the data logic (Models), the user interface (Views), and the glue that connects them (Controllers), Laravel creates a predictable environment. For developers in 2026, the goal is to understand these architectural pillars so they can direct AI agents effectively and debug the results with precision. Prerequisites and Environment Setup Before launching a new project, you must have a local PHP environment. The most streamlined recommendation is Laravel Herd, a zero-config development environment for macOS and Windows. It handles PHP, web servers, and local domain management effortlessly. Key tools you should have installed: * **PHP 8.3+**: The engine behind Laravel. * **Composer**: The package manager for PHP. * **Node.js & NPM**: Essential for compiling modern CSS and JavaScript. * **Database**: SQLite is the default for zero-config setups, but MySQL is preferred for scaling. Key Libraries & Tools * Laravel 13: The primary PHP framework. * Tailwind CSS 4: A utility-first CSS framework for rapid UI styling, pre-configured in new projects. * Vite: The modern frontend build tool that manages asset compilation. * **Eloquent ORM**: Laravel's built-in database mapper that allows you to interact with data using PHP syntax instead of raw SQL. * **Blade**: The powerful templating engine for generating dynamic HTML. * Pest: The elegant, human-readable testing framework now standard in the ecosystem. * Livewire: A full-stack framework for Laravel that builds dynamic interfaces without leaving the comfort of PHP. Code Walkthrough: Routing and Controllers The entry point for any Laravel request is the `routes/web.php` file. This file maps URLs to specific logic. In a clean architecture, we offload that logic to Controllers. ```php // routes/web.php use App\Http\Controllers\PostController; use Illuminate\Support\Facades\Route; // Basic GET route returning a view Route::get('/', function () { return view('welcome'); }); // Resource routing for CRUD Route::resource('posts', PostController::class); ``` The `Route::resource` command is a shortcut that automatically generates routes for index, create, store, show, edit, update, and destroy actions. Inside the `PostController`, we handle the interaction between the user and the database: ```php // App/Http/Controllers/PostController.php public function index() { // Fetching data via Eloquent $posts = Post::with('category')->latest()->paginate(10); return view('posts.index', compact('posts')); } ``` Database Integration and Eloquent Models Laravel uses Migrations to version-control your database schema. Instead of sharing SQL dumps, you share PHP files that define table structures. To define a relationship, such as a post belonging to a category, we use expressive PHP methods in the Model files. ```php // App/Models/Post.php class Post extends Model { protected $fillable = ['title', 'slug', 'content', 'category_id']; public function category(): BelongsTo { return $this->belongsTo(Category::class); } } ``` To populate these tables with test data, we use Factories and Seeders. Running `php artisan db:seed` allows you to instantly generate hundreds of realistic records, which is crucial for testing UI layouts and pagination. Syntax Notes: Route Model Binding A signature feature of Laravel is Route Model Binding. When you define a route like `/posts/{post}`, and type-hint the `$post` variable in your controller method, Laravel automatically fetches the record from the database. If the ID doesn't exist, it triggers a 404 page immediately without requiring manual `if` checks. Practical Examples 1. **Public Marketing Sites**: Using simple routes and Blade templates to manage high-performance landing pages. 2. **Content Management**: Utilizing Eloquent relationships to link authors, categories, and tags in a blog system. 3. **SaaS Dashboards**: Leveraging starter kits like Laravel Breeze or Jetstream to handle user authentication, profile management, and password resets out of the box. Tips & Gotchas * **Mass Assignment**: Always define `$fillable` or `$guarded` in your models to prevent malicious users from injecting data into fields like `is_admin`. * **Environment Security**: Never commit your `.env` file to version control. It contains sensitive database passwords and API keys. * **The N+1 Problem**: When listing records, use `with('relationship')` to eager load data. Forgetting this can cause your application to run hundreds of unnecessary database queries, tanking performance.

Overview Laravel 13 introduces a significant shift in how developers configure classes by implementing 36 new PHP attributes. These attributes replace traditional protected properties—like `$fillable` or `$hidden`—with metadata directly above the class or method definition. This change aims to clean up class bodies and utilize native PHP 8 language features for better static analysis and cleaner syntax. Prerequisites To use these features, you should have a solid grasp of PHP 8 attribute syntax (`#[Attribute]`). You should also be familiar with Laravel's Eloquent ORM, job dispatching, and Artisan command structures. Key Libraries & Tools - **Laravel 13**: The latest version of the PHP framework. - **Eloquent**: The database mapper now supporting attribute-based model configuration. - **Livewire**: Often paired with these attributes in modern starter kits. Code Walkthrough Refactoring Eloquent Models Previously, you defined model behavior using class properties. In the new version, you apply them as attributes: ```php use Illuminate\Database\Eloquent\Attributes\Fillable; use Illuminate\Database\Eloquent\Attributes\Hidden; #[Fillable(['name', 'email'])] #[Hidden(['password'])] class User extends Model {} ``` Laravel reads these attributes at runtime, effectively populating the internal protected properties for you. Enhancing Queued Jobs For background tasks, you can now set retry limits and timeouts directly on the class: ```php use Illuminate\Queue\Attributes\Tries; use Illuminate\Queue\Attributes\Timeout; #[Tries(5)] #[Timeout(60)] class ProcessPodcast implements ShouldQueue {} ``` Syntax Notes Attributes utilize the `#[ ]` syntax. Unlike properties, attributes can take constructor arguments, allowing for cleaner configuration of complex settings like `ExponentialBackoff` within a single line. This moves configuration logic out of the class body and into the header. Practical Examples You can now define Artisan command signatures and descriptions without declaring variables: ```php #[Signature('app:send-emails {user}')] #[Description('Send a notification email to a specific user')] class SendEmails extends Command {} ``` Tips & Gotchas While Laravel now defaults to this style in its starter kits, these attributes are strictly optional. If you find multiple attributes on a single controller method hard to read, stick to the traditional `$middleware` arrays. Additionally, always ensure you import the correct namespace for each attribute to avoid "Attribute not found" errors.

The New Frontier of Laravel AI Agent Skills Laravel Skills recently surfaced as a specialized directory at skills.laravel.cloud, showcasing 143 reusable agent skills for PHP developers. This platform, powered by the Vercel ecosystem Skills.sh, promises to expand what AI agents can do within a codebase. While the interface is polished, the underlying mechanics reveal a complex marketplace of automated prompts and third-party scripts. The barrier to entry for adding these skills via Laravel Boost is incredibly low, but as with any ecosystem that scales quickly, quality and provenance become the primary concerns. Under the Hood: The GitHub Source Reality Investigating the source code for these skills leads down a rabbit hole of diverse GitHub repositories. Many popular skills, such as the Laravel Security Audit, originate from repositories like Anti-Gravity Awesome Skills. A recurring pattern emerges: these repositories often contain hundreds of skills across various programming languages, frequently maintained by anonymous authors like sick n33. This raises a critical question about domain expertise. Are these rules crafted by seasoned Laravel architects, or are they AI-generated prompts built by other AI agents? The commit history for several skills shows bulk updates generated by Claude models, suggesting a cycle where AI is essentially training itself on how to audit code. Analysis: Pros and Cons of Third-Party Skills The immediate benefit of these skills is their utility in scanning legacy codebases. A quick run of a security audit can flag user-writable system prompts or improper file permissions in minutes. However, the drawbacks are significant. Many "best practice" skills enforce highly opinionated patterns—such as mandatory strict types or specific repository patterns—that may not align with a team's internal standards. Because these skills are often static snapshots from a larger database, they risk becoming outdated the moment a new version of Laravel or PHP launches. There is no central governing body ensuring these 143 skills remain current with Laravel 13 or beyond. Strategic Alternatives and Deterministic Tools For developers seeking reliability, the official guidelines within Laravel Boost remain the gold standard. These are maintained by the core Laravel team and receive constant updates. For specific frameworks like Filament, where AI models often hallucinate deprecated code, deterministic tools like FilaCheck offer a safer path. Unlike AI-driven skills that may ignore instructions, FilaCheck functions like Laravel Pint, performing local scans for known deprecations without the unpredictability of a prompt-based agent. Final Verdict Laravel Skills is a fascinating experiment in scaling AI utility, but it operates as a "Wild West." Use these skills for secondary code reviews and quick security sanity checks, but never treat them as an absolute source of truth. Trust the official Laravel core team for architectural guidelines and lean on deterministic linting tools for critical syntax validation.