PHP

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.

Overview of Large Context Engineering Anthropic recently expanded the Claude%203.5%20Opus context window to 1 million tokens for Max plan users. For developers using Claude%20Code, this change shifts the development workflow from fragmented, phase-based prompting to holistic codebase analysis. Instead of feeding an AI model isolated functions, you can now provide entire repository structures, extensive documentation, and thousands of lines of test code in a single session. This matters because it reduces the cognitive load on the developer to track state across multiple prompts. Prerequisites To effectively use these high-capacity models, you should understand: - **Command Line Interface (CLI)**: Basic navigation and execution within terminal environments. - **Tokenization**: How text converts into numerical representations (tokens). - **Agentic Workflows**: Understanding how AI tools spawn sub-agents to handle specific sub-tasks. Key Libraries & Tools - **Claude Code**: A terminal-based coding agent that interacts directly with your filesystem. - **Laravel Blade**: A templating engine for PHP used in the BookStack project tests. - **Sub-agents**: Internal Claude processes that distribute tasks across multiple context windows simultaneously. Code Walkthrough: Stress Testing Analysis To test the limits of the 1 million token window, you might attempt a comprehensive security audit across a massive codebase like BookStack. ```bash Initializing a large-scale security audit claude-code "Perform a full security audit of all 279 Laravel Blade templates for XSS vulnerabilities." ``` In this scenario, Claude%20Code performs internal optimization. It doesn't blindly ingest every byte. Instead, it identifies structural patterns—layouts, components, and models—to minimize token waste. If the task is too broad, it triggers sub-agents, each possessing its own context window, effectively giving you millions of tokens of processing power across a parallelized architecture. Syntax Notes & Optimization You can explicitly control how the agent handles context. To force a single-agent analysis (which tests the 1M window directly), use specific directives in your prompt: ```markdown Prompt: "Analyze all files in /tests/ without using sub-agents. Provide a report on missing edge cases." ``` This forces the primary agent to maintain all 130+ test files in its active memory, which is where the 1M window provides the most value over the standard 200k limit found in Claude%203.5%20Sonnet. Tips & Gotchas - **Quality Degradation**: While 1M tokens are available, LLM performance can dip as context fills. Opus is specifically tuned to maintain high "needle-in-a-haystack" accuracy at these depths. - **Usage Costs**: A larger context window does not mean cheaper tokens. Monitor your session usage in the status line to avoid exhausting your plan limits. - **Sub-agent Efficiency**: Usually, letting Claude%20Code manage sub-agents is more efficient than forcing everything into a single context window.

Overview Modern development workflows require more than just clean code; they demand a foundation that AI agents can interpret. By structuring Laravel projects with a specific 7-step system, you provide LLMs with the context needed to "one-shot" complex features like Telegram bots. This technique minimizes hallucinations and maximizes the effectiveness of tools like Laravel Boost and Codeex. Prerequisites To follow this workflow, you should be comfortable with the PHP ecosystem and terminal-based development. Familiarity with Git version control is essential for managing AI-generated changes. You should also understand the basics of Composer for package management and have a preferred AI-integrated editor. Key Libraries & Tools - **Laravel & Filament**: The core framework and the preferred TALL-stack admin panel for rapid UI development. - **Laravel Boost**: A tool that manages guidelines and skills specifically for AI agents within a repository. - **Cloud Code / Codeex**: AI-powered code editors that interact with the project's markdown guidelines. Code Walkthrough 1. Initialization and Documentation Start by creating a clean project and establishing a documentation folder. AI agents perform better when they have a source of truth for project requirements. ```bash laravel new my-app mkdir docs touch docs/project-description.md ``` 2. Admin Panel and AI Skill Injection Installing Filament provides a powerful UI, but the AI agent won't know how to use it unless the Boost guidelines are refreshed. ```bash composer require filament/filament php artisan filament:install --panels ``` After installation, you must re-run the Boost installer. This step discovers the new package and injects Filament-specific rules into `claude.md` or `agents.md`. ```bash php artisan boost:install ``` Syntax Notes This workflow relies heavily on **Markdown-based guidelines**. The `claude.md` file acts as a system prompt for your editor. By running `boost:install`, you ensure the AI understands Laravel 12 and Filament 5 syntax conventions, preventing it from suggesting deprecated methods. Practical Examples In a real-world Upwork project for a Telegram Bingo bot, this preparation allowed an AI to generate the core game logic in just seven phases. By defining the tech stack as MySQL 8 and Laravel in the markdown docs, the AI correctly handled job queues for drawing numbers every five seconds. Tips & Gotchas - **The Boost Refresh**: Many developers forget that `boost update` is different from `boost install`. Only `install` triggers the discovery of new third-party package guidelines. - **Git as a Frontier**: Always commit after every AI interaction. If the agent generates a broken migration or a messy controller, Git is your only way to safely roll back.