In the Stack Overflow 2025 Developer Survey, “84% of respondents are using or planning to use AI tools in their development process.”

They don’t break this number down by developer language, but if they did, they would likely find a wide disparity between different languages. While TS/JS and Python coders are probably using AI every day with great success, the same can’t be said for developers using other languages.

PHP and Laravel developers, in particular, have been notably cautious in their adoption of AI coding assistants, and for good reason. The promise of AI-powered development has largely fallen short for the PHP community, leaving many wondering if the technology simply wasn’t built with them in mind.

It wasn’t. But app.build is. One of our first templates is a Laravel app generation template that finally delivers on the promise of AI-assisted development for PHP developers – generating modern, idiomatic Laravel code that actually works in production.

Why AI code generation has failed PHP developers

When GitHub Copilot launched, PHP developers quickly discovered they were second-class citizens in the AI revolution. 
The most glaring issue has been the knowledge gap. Take this comment from the GitHub community:

When I use Github Copilot for PHP and Laravel, it seems that it’s using very old PHP and Laravel examples that are either not supported anymore or there are better ways with newer versions. This is more true with Laravel, when I was attempting ask about illuminate and it gave me the method and class names that do not exist anymore.

Imagine asking for help with Laravel 11 and getting code that references classes and methods that haven’t existed since Laravel 7.

This isn’t just about outdated syntax – it’s about trust. When an AI assistant confidently suggests $request->get() instead of the modern $request->input(), or uses deprecated helper functions that were removed years ago, it becomes worse than having no assistant at all. As one Laravel developer put it: “In my Laravel projects, I often found Copilot giving me old syntax, outdated helper functions, or just weird formatting that didn’t match the rest of the codebase.”

The tooling ecosystem hasn’t helped either. Many PHP developers have historically preferred PHPStorm or Sublime Text over VS Code, meaning Copilot’s initial VS Code exclusivity left them out in the cold. Even Laravel’s creator, Taylor Otwell, still codes in Sublime and only uses AI occasionally “for regular expressions or [in] a language I’m not super familiar with.” Notably, not for his daily Laravel work.

Perhaps most damaging has been the erosion of developer confidence. PHP developers pride themselves on understanding their code deeply, and AI’s hit-or-miss suggestions have forced them into an exhausting cycle of verification. They found themselves constantly adding caveats: “Use Laravel 12 syntax. Don’t use deprecated functions. Use PSR-12 formatting.”

The result? Many PHP developers have concluded that AI code generation, at least in its current form, simply isn’t worth the hassle. The promise of increased productivity has been replaced by the reality of constant corrections, outdated suggestions, and a nagging worry that accepting AI help means introducing subtle bugs they don’t fully understand.

For a community that values craftsmanship and takes pride in writing elegant, maintainable code, AI has felt less like a copilot and more like a backseat driver who learned to navigate using an outdated map.

How we want app.build to change Laravel developers relationship with AI code generation

Up until the week before Laracon, app.build would not generate Laravel code. Whereas other code generation tools would wing it, the entire concept of app.build is not to wing it.

The philosophy of app.build is:

• Reliability over capabilities: We prioritize generating working apps 100% of the time, even if it means limiting initial features
• Specialization through generalization: By deeply understanding specific frameworks and their conventions, we can generate more reliable code across different use cases
• Extensive validation pipeline: Every piece of generated code must pass TypeScript compilation, unit tests, linters, and end-to-end tests
• Context encapsulation: Each generation step only sees the information it needs, preventing context pollution and improving accuracy
• Continuous error analysis: We use production logs to automatically improve our generation templates and catch edge cases

This extends to our Laravel app.build template:

• Framework-specific validation: Beyond TypeScript checks, we validate Laravel-specific patterns like proper Eloquent relationships, form request validation, and middleware usage
• Laravel convention enforcement: Our actors understand Laravel’s file structure, naming conventions, and best practices, ensuring generated code feels native to Laravel developers
• Modern version targeting: Unlike generic AI tools, we specifically target Laravel 12 and PHP 8.3+, using only current APIs and patterns
• Full-stack type safety: We ensure types flow correctly from Eloquent models through Inertia to React components, catching mismatches before runtime
• Production-ready defaults: Every generated app includes proper authentication, Docker configuration, and testing setup – not just demo code
• Laravel-aware context: Our system prompts include specific guidance on Laravel gotchas like decimal handling in migrations, nullable vs optional fields, and proper use of casts

The output should then be a Laravel app that works. But more than that, it is a Laravel app that experienced Laravel developers would recognize: the correct patterns, modern versioning, and the idiomatic approaches they’d use themselves.

Building a Laravel app with app.build

This is really simple. If you went with such a simple prompt as “I want to build and deploy a TODO app using Laravel” in most code generation tools, you wouldn’t get something ready to go.

Let’s look at what happens when we do this with app.build. app.build first generates the initial application code, then immediately begins its validation pipeline. The system validates each component of the Laravel application – authentication routes, user settings, API endpoints – checking that the generated code follows Laravel conventions and will function correctly.

app.build then automatically executes the application’s test suite using Pest PHP. The tests cover:

• Authentication flows, including login, registration, and password reset
• API CRUD operations
• Frontend-backend communication through Inertia.js
• Data validation and error handling
• Protected route access and authorization

The validation pipeline runs dozens of tests, checking everything from basic functionality to edge cases. Each passing test confirms that the generated code is not just syntactically correct but functionally complete.

Throughout this process, app.build is validating that:

• Eloquent relationships are properly defined
• Form requests handle validation correctly
• Middleware is configured appropriately
• API responses follow expected formats
• Database migrations will execute without errors

The entire validation process happens automatically after code generation. app.build won’t deliver the application until it passes the same rigorous testing that a human developer would perform. This ensures that the generated Laravel application is genuinely production-ready, not just a template that compiles but fails at runtime.

At the end, we get a deployed, working application:

If we look at the code, we can see some lovely Laravel patterns that experienced developers would recognize and appreciate.

Modern Type-Safe Development

app.build generates Laravel code with strict PHP types throughout, ensuring runtime safety and better IDE support:

declare(strict_types=1);

class Task extends Model
{
    protected function casts(): array
    {
        return [
            'completed' => 'boolean',
            'created_at' => 'datetime',
            'updated_at' => 'datetime',
        ];
    }
}

Notice the use of the modern casts() method instead of the legacy $casts property – this is Laravel 11 syntax, not outdated patterns from older versions.

Inertia.js for Modern SPAs

Instead of building a separate API and frontend, app.build leverages Inertia.js to create a seamless full-stack experience:

const handleAddTask = (e: React.FormEvent) => {
    e.preventDefault();
    router.post(route('tasks.store'), {
        title: newTaskTitle.trim()
    }, {
        preserveState: true,
        preserveScroll: true,
        onSuccess: () => {
            setNewTaskTitle('');
        }
    });
};

This approach gives you React’s reactivity with Laravel’s routing – no need to maintain API documentation or worry about CORS.

Production-Ready Docker Configuration

The generated application includes a multi-stage Dockerfile with security headers and performance optimizations:

# Security headers in nginx
add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-Content-Type-Options "nosniff" always;

# OPcache settings for production
opcache.enable = 1
opcache.memory_consumption = 128
opcache.validate_timestamps = 0

This isn’t a basic “getting started” Docker setup – it’s configured for real production use with proper caching, security headers, and optimized PHP settings.

Expressive Testing with Pest

Instead of verbose PHPUnit tests, app.build generates clean Pest tests that verify your application works:

test('can create task', function () {
    $response = $this->post('/tasks', ['title' => 'New Task']);
    
    $response->assertStatus(200);
    $this->assertDatabaseHas('tasks', [
        'title' => 'New Task',
        'completed' => false
    ]);
    
    $response->assertInertia(fn (Assert $page) =>
        $page->component('welcome')
            ->has('tasks', 1)
            ->where('tasks.0.title', 'New Task')
    );
});

These tests verify that routes respond and that data flows correctly through the entire stack – from database to Inertia props to React components.

Modern Frontend with Tailwind CSS v4

The application uses Tailwind’s new CSS-first configuration approach, not the outdated JavaScript config:

@theme {
    --font-sans: 'Instrument Sans', ui-sans-serif, system-ui, sans-serif;
    --color-background: var(--background);
    --color-foreground: var(--foreground);
}

What you get from app.build is a thoughtfully architected Laravel application with:

• Type safety from database to frontend
• Modern tooling (Vite, Pest, Tailwind v4)
• Production-ready infrastructure
• Comprehensive test coverage
• Security best practices baked in

Most importantly, it’s code that a senior Laravel developer would write – not AI-generated spaghetti that happens to execute. When you need to extend it with your business logic, you’ll find familiar patterns and clean architecture that make development a joy, not a chore.

If you’re interested in seeing whether app.build can help with your Laravel development, you can use it right now with:

npx @app.build/cli@beta --env=staging --template=laravel

app.build isn’t trying to replace Laravel developers or dumb down the craft. It’s built for serious developers who want to ship faster without compromising on quality. We want to supply you with code that works and code that you want to work with.

App.build is an open-source AI agent built by the Neon team. It acts as a reference implementation for agent builders – use it as an architecture template if you’re building an agent. All code here.