PHP & Laravel AI Workflows: From Artisan to Autopilot

Why Laravel + AI Is a Perfect Match

Laravel is arguably the most convention-driven PHP framework in existence. From its Eloquent ORM to its resource controllers, from form requests to policies — everything follows predictable patterns. And predictable patterns are exactly what AI code generation excels at.

TailwindPHP was built with Laravel as a first-class citizen. It understands Artisan commands, Eloquent relationships, Blade templates, middleware, and the entire Laravel ecosystem. In this tutorial, we'll walk through setting up AI-powered workflows that automate the repetitive parts of Laravel development while keeping you in control of the architecture.

Setting Up Your Laravel AI Workspace

Before diving into workflows, let's configure TailwindPHP for optimal Laravel development. Start by installing the package and creating your configuration file:

bash
composer require tailwindphp/ai --dev

# Initialize configuration
php artisan tailwindphp:init

This creates a .tailwindphp.json in your project root. Let's configure it for Laravel-specific generation:

json — .tailwindphp.json
{
  "framework": "laravel",
  "frameworkVersion": "11",
  "phpVersion": "8.3",
  "style": "psr-12",
  "testFramework": "pest",
  "contextDepth": 5,
  "priorityFiles": [
    "app/Models/*.php",
    "routes/api.php",
    "routes/web.php",
    "database/migrations/*.php"
  ],
  "conventions": {
    "apiResponses": "resource",
    "authorization": "policy",
    "validation": "formRequest"
  }
}

Workflow 1: AI-Powered Migrations

Database migrations are the foundation of any Laravel project. TailwindPHP can generate migrations from natural language descriptions, and — critically — it understands your existing schema to avoid conflicts.

bash
# Generate a migration from a description
tailwindphp generate:migration "Create orders table with user_id foreign key,
  status enum (pending, processing, completed, cancelled),
  total decimal(10,2), shipping_address JSON, notes text nullable,
  soft deletes, and timestamps"

TailwindPHP generates the following migration, automatically understanding your existing users table and creating the proper foreign key:

php — database/migrations/create_orders_table.php
<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up(): void
    {
        Schema::create('orders', function (Blueprint $table) {
            $table->id();
            $table->foreignId('user_id')->constrained()->cascadeOnDelete();
            $table->enum('status', [
                'pending', 'processing', 'completed', 'cancelled'
            ])->default('pending');
            $table->decimal('total', 10, 2);
            $table->json('shipping_address');
            $table->text('notes')->nullable();
            $table->softDeletes();
            $table->timestamps();

            $table->index(['user_id', 'status']);
            $table->index('created_at');
        });
    }

    public function down(): void
    {
        Schema::dropIfExists('orders');
    }
};

Notice the AI automatically added indexes on commonly queried columns and set a sensible default for the status enum. It also used cascadeOnDelete because it detected the existing users table's deletion pattern.

Workflow 2: Form Request Validation

Laravel's form requests are the right way to handle validation, but writing complex validation rules is tedious. TailwindPHP generates form requests that match your model's schema:

bash

tailwindphp generate:request "StoreOrderRequest for the orders table"

php — app/Http/Requests/StoreOrderRequest.php
<?php

namespace App\Http\Requests;

use App\Models\Order;
use Illuminate\Foundation\Http\FormRequest;
use Illuminate\Validation\Rule;

class StoreOrderRequest extends FormRequest
{
    public function authorize(): bool
    {
        return $this->user()->can('create', Order::class);
    }

    public function rules(): array
    {
        return [
            'status' => ['sometimes', Rule::in([
                'pending', 'processing',
                'completed', 'cancelled',
            ])],
            'total' => ['required', 'numeric', 'min:0', 'max:99999999.99'],
            'shipping_address' => ['required', 'array'],
            'shipping_address.street' => ['required', 'string', 'max:255'],
            'shipping_address.city' => ['required', 'string', 'max:100'],
            'shipping_address.zip' => ['required', 'string', 'max:20'],
            'shipping_address.country' => ['required', 'string', 'size:2'],
            'notes' => ['nullable', 'string', 'max:5000'],
        ];
    }
}

Workflow 3: Complete CRUD Scaffolding

The most powerful workflow combines everything — model, migration, controller, form requests, resource, policy, and routes — into a single command. TailwindPHP generates all files with proper relationships and cross-references:

bash

tailwindphp scaffold "Order module with full CRUD API. Orders belong to users, have many order items. Include filtering by status and date range. Add soft deletes and event dispatching."

This single command generates 8 files: the model with relationships, casts, and scopes; the migration; a resource controller; store and update form requests; an API resource; a policy; and a Pest test file. Every file references the others correctly — the controller uses the form request, the resource maps the model's attributes, and the policy checks the user relationship.

Workflow 4: Intelligent Route Generation

TailwindPHP can also update your route files with the correct resource routes, middleware, and grouping:

php — routes/api.php (auto-generated addition)
// TailwindPHP detected existing route patterns and matched them
Route::middleware(['auth:sanctum', 'throttle:api'])
    ->prefix('v1')
    ->group(function () {
        // ... existing routes ...

        Route::apiResource('orders', OrderController::class);
        Route::post('orders/{order}/cancel', [
            OrderController::class, 'cancel'
        ])->name('orders.cancel');
    });

Workflow 5: Model with Relationships and Scopes

The generated model includes properly typed relationships, casts for the JSON and enum columns, and query scopes based on your migration:

php — app/Models/Order.php
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\SoftDeletes;

class Order extends Model
{
    use SoftDeletes;

    protected $fillable = [
        'user_id', 'status', 'total',
        'shipping_address', 'notes',
    ];

    protected $casts = [
        'shipping_address' => 'array',
        'total' => 'decimal:2',
    ];

    public function user(): BelongsTo
    {
        return $this->belongsTo(User::class);
    }

    public function items(): HasMany
    {
        return $this->hasMany(OrderItem::class);
    }

    public function scopeForUser($query, User $user)
    {
        return $query->where('user_id', $user->id);
    }

    public function scopeWhereStatus($query, string $status)
    {
        return $query->where('status', $status);
    }

    public function cancel(): void
    {
        $this->update(['status' => 'cancelled']);
        event(new OrderCancelled($this));
    }
}

Advanced: Chaining Workflows with Artisan

For maximum efficiency, chain multiple TailwindPHP commands in a single Artisan pipeline. Create a custom Artisan command that generates an entire feature module:

bash
# Generate everything for a new feature
tailwindphp scaffold "Invoice" \
  --with-migration \
  --with-factory \
  --with-seeder \
  --with-tests \
  --with-events \
  --api-only

# Run the migration immediately
php artisan migrate

# Run the generated tests to verify
./vendor/bin/pest tests/Feature/InvoiceTest.php

Best Practices for Laravel AI Workflows

After working with hundreds of Laravel teams using TailwindPHP, here are the practices that consistently produce the best results:

Start with the migration. The database schema is the source of truth. Generate the migration first, then let the AI use it as context for models, requests, and controllers.
Use form requests, not inline validation. Configure TailwindPHP to always generate form requests. They're more testable, reusable, and the AI produces better validation rules in dedicated classes.
Generate tests alongside code. Use the --with-tests flag on every generation command. Tests written at generation time have the highest accuracy because the AI has full context of the code it just created.
Review the policy. Authorization logic is the one area where AI needs the most human oversight. Always review generated policies to ensure they match your business rules.
Keep your config updated. As your project evolves, update .tailwindphp.json to reflect new conventions, added packages, and changed patterns.

Conclusion

Laravel's convention-over-configuration philosophy makes it the ideal framework for AI-powered development. By setting up structured workflows — from migrations to form requests to complete CRUD scaffolding — you can automate the predictable parts of Laravel development and focus your energy on the unique business logic that makes your application valuable.

TailwindPHP's Laravel-first approach means you get code that doesn't just work — it follows the exact patterns and conventions your team expects. Install the extension, configure your workflows, and watch your productivity transform from Artisan to autopilot.