CodeBooster
Get the kit free

Your AI writes the migration. CodeBooster builds the module.

A Laravel 13 + React 19 starter kit with MCP built in. Your assistant handles what is unique to your app; CodeBooster turns each table into screens, API and tests, the same way every time.

Free kit, no card. 10 generator modules on us.

  1. 01Migrationcreate_products_table.php
  2. 02make:crudproducts --api
  3. 0360 fileswired, registered
  4. 04Checksphp -l · phpstan · tsc · eslint

Built on Laravel 13 · React 19 · Inertia · TypeScript · Tailwind 4 · PostgreSQL or MySQL · Docker

See it working

Watch it build a module. Then sign in and click around.

Two and a half minutes in real time, recorded on kit 2.6.0 — then the same application, live. Not a sandbox, and no sign-up.

Open the live demo ↗

Super Admin

Everything, including the audit trail and the permission matrix

superadmin@demo.com · password

Admin

Modules, exports, users and the audit trail

admin@demo.com · password

Guest

Sees the dashboard and nothing else

guest@demo.com · password

Why not just ask an AI?

Because the thirtieth module has to match the first.

Keep your assistant. This is not a replacement: your assistant can write a CRUD screen, but it cannot promise that the next thirty look like the same person wrote them.

Deterministic

Same schema, same files

The generator runs the same make:crud your machine would, then pint, prettier and eslint — so even import order cannot drift. Ask an AI twice, get two shapes.

Wired, not just written

Files are the easy half

Routes, permissions, the sidebar entry, the seeder, both translation files and 50+ tests per module — placed and registered.

Change is a diff

Regenerate, then read the diff

Schema changed? Regenerate and review a clean diff against the last run. Re-prompting gives you a rewrite instead.

Use both. Let this do the repetitive eighty percent the same way every time, and spend your assistant on the twenty percent that is actually interesting.

Inside a module

One command. Up to 60 files you would otherwise type yourself.

Not a scaffold you clean up afterwards — the actual output, the same file list every time, on every machine.

  • Model, actions and requests — one transaction each
  • Columns and filters declared once
  • React pages with filters, bulk actions and exports
  • Routes, RBAC and 50+ tests per module
Browse the generated files ↗
app/Models/Product.php
#[ObservedBy(ProductObserver::class)]
#[Fillable([
    'category_id',
    'name',
    'slug',
    'sku',
    'status',
    'price',
    // …
])]
class Product extends Model
{
    /** @use HasFactory<ProductFactory> */
    use HasFactory, SoftDeletes;

    protected function casts(): array
    {
        return [
            'status' => ProductStatus::class,
            'price' => 'decimal:2',
            'compare_at_price' => 'decimal:2',
            // …
        ];
    }

    public function category(): BelongsTo
    {
        return $this->belongsTo(Category::class)->withTrashed();
    }
app/Actions/Product/StoreProduct.php
final class StoreProduct
{
    public function handle(array $data, array $photos = [], ?UploadedFile $size_chart = null): Product
    {
        return DB::transaction(function () use ($data, $photos, $size_chart): Product {
            // …
            if (($data['status'] ?? null) === 'active') {
                $data['published_at'] = now();
                $data['published_by'] = auth()->id();
            }

            $product = Product::create($data);
            $product->tags()->sync($tagsIds);

            activity()
                ->performedOn($product)
                ->event('created')
                ->log("Created product \"{$product->name}\"");

            return $product;
        });
    }
}
app/Http/Requests/Product/ProductRequest.php
abstract class ProductRequest extends FormRequest
{
    public function rules(): array
    {
        return array_replace([
            'name' => ['required', 'string', 'max:120'],
            'status' => ['required', Rule::enum(ProductStatus::class)],
            'price' => ['required', 'numeric', 'min:0', 'decimal:0,2', 'max:99999999.99'],
            // …
            'is_featured' => ['required', 'boolean'],
            // …
        ], $this->modeRules(), $this->customRules());
    }

    /** The one point where creating and updating part ways. */
    abstract protected function unique(string $column): Unique;
app/Columns/ProductColumns.php
return ColumnSet::for(Product::class)
    ->add('id', 'ID', static fn (Product $product): int => $product->id)
    ->notImportable()
    ->add('name', 'Name', static fn (Product $product): mixed => $product->name)
    ->add('sku', 'SKU', static fn (Product $product): mixed => $product->sku)
    ->add('status', 'Status', static fn (Product $product): string => $product->status->value)
    ->add('price', 'Price', static fn (Product $product): mixed => $product->price)
    ->add('is_featured', 'Is Featured', static fn (Product $product): bool => $product->is_featured)
    ->exportAs(static fn (Product $product): string => $product->is_featured ? 'Yes' : 'No')
    // …
resources/js/pages/product/columns.tsx
export const PRODUCT_COLUMNS: ProductColumn[] = [
    // …
    {
        key: 'status',
        label: 'Status',
        reveal: '576px',
        sort: 'status',
        skeleton: 'pill',
        cell: (item) => (
            <StatusBadge status={item.status} palette={STATUS_PALETTE} />
        ),
    },
    {
        key: 'price',
        label: 'Price',
        reveal: '896px',
        sort: 'price',
        cell: (item) => (
            <span className="text-[13px] text-foreground tabular-nums">
                {formatMoney(item.price)}
            </span>
        ),
    },
tests/Feature/ProductModuleTest.php
it('creates a record and logs the activity', function () {
    actingAs(userCan(['product.create']));
    $payload = productPayload();

    post(route('product.store'), $payload)
        ->assertRedirect()
        ->assertSessionHasNoErrors()
        ->assertInertiaFlash('toast', ['type' => 'success', 'message' => __('crud.created')]);

    expect(Product::count())->toBe(1);
    $product = Product::query()->firstOrFail();
    expect($product->name)->toBe($payload['name']);
    assertDatabaseHas('activity_log', ['subject_type' => Product::class, 'subject_id' => $product->getKey(), 'event' => 'created']);
});

The screens

What the kit actually looks like.

Every screen below ships in the box, in both themes, and every generated module inherits the same shape.

Roles, permissions and an audit trail

Up to eight permissions per module, and every change written to an audit log.

  • Export and import kept separate
  • Audit log with IP and user agent
Open the live demo ↗

Sign-in your clients expect

Two-factor, passkeys and SSO are already wired, with impersonation for support.

  • 2FA and passkeys
  • Google and GitHub SSO
Read the auth docs ↗

Live, and safe to share

Every open table updates itself over a websocket when someone changes a row.

  • Open a record twice, the second save is refused
  • In every module the generator writes
See it update ↗

Production Docker, pinned

FrankenPHP, Caddy, Postgres 18 and Redis — pinned to patch versions.

  • Same stack for every buyer, every month
  • Mailpit, Adminer and RedisInsight for local work
Deployment guide ↗

MCP support

MCP built in. Your AI agent runs the generator.

Claude Code, Cursor, Codex or Copilot plans the table with you, then generates the module through the same make:crud — so what it builds is exactly what your own terminal would.

Your key
The licence stays with the kit’s generator client; the agent never sees it.
Progress
Each step of the generate is reported as it runs, and every tool says what it returns.
Setup
A project from the kit already carries .mcp.json; Laravel Boost adds the kit’s guideline and skill.

Proof

Numbers we measured, not numbers we promised.

Every release is installed from nothing on four clean machines — Docker and native, PostgreSQL and MySQL — and its whole test suite has to pass on each before it reaches anyone.

How each number is measured · what we do not claim →

Who is behind this

“I build client systems for a living, and this kit is the foundation I build them on.”

Faizal Harwin

Independent developer · Malang, Indonesia

Questions? [email protected] — a person reads it.

Pricing · public beta

The kit is free. The generator is what you pay for.

We are in public beta: the kit and 10 generator modules are free, no card. Paid plans open at launch — join the waitlist to hear first.

Free no card

$0with an account

The whole kit, and the generator for your first modules.

  • The full kit, source included — Laravel 13, React 19, production Docker
  • Unlimited projects, yours and your clients’
  • 10 generator modules every 30 days while the beta runs
  • An MCP server for Claude Code, Cursor, Codex and Copilot
Get the kit free →

Solo at launch

$19per month

For one developer, across their own and client projects.

Everything in Free, plus:

  • 30 new modules every month
  • Use it on up to 3 machines
Notify me at launch →

Studio at launch

$49per month

For agencies and teams running many projects at once.

Everything in Free, plus:

  • 100 new modules every month
  • Use it on up to 10 machines
Notify me at launch →
  • Refining a module is free within your period
  • Your generated code keeps working if you stop
  • Switch or cancel any time from your portal

Need more? Add 10 modules for $9 to a running Solo or Studio plan, from your portal — one payment, and the extra modules last until that period ends.

Prices in US dollars, before any sales tax or VAT for your country. Money back within 14 days of your first payment if you have not generated a module yet.

Working as a team?

  • Write to us and we will sort it out for your team size
  • An invoice made out to your company, with VAT where it applies
Talk to us

Fair questions

What people ask before they start.

Why is the kit free and the generator paid?

The kit is code you download once, so we give it away to anyone with an account. The generator holds most of the knowledge in this product and it keeps moving — running it as a service means a fix reaches you the day it is made, not at the next release. What you pay for is new modules; what you receive is ordinary source that is entirely yours. Both cover unlimited projects, your own and your clients’ — the one thing you may not do is resell the kit itself.

Can I try it first, and what if it does not fit?

Yes, on your own schema: get the kit free, then press “Get my free generator key” in your portal — 10 modules over 30 days, renewed every 30 days while the beta runs, generated straight into your project, and they stay yours whether or not you subscribe. If you subscribe and have not generated a module yet, write to us within 14 days of the first payment and we refund it, no reason needed. Cancel any time from your portal; what you generated stays yours.

Is my database sent to your server?

Its shape, not its contents. Sent: table and column names, types, indexes, foreign keys, check constraints, column comments and a row count per table — plus the files the generator edits or must leave alone: the module’s existing files, the shared files it wires into (routes, seeder, sidebar, search) and your translated labels. Never sent: a single row of data, your .env or database credentials, or any other file. What collects it is two small classes inside your own project, under 500 lines together — open them and read them.

If the service goes away, what happens to my code?

It keeps running, forever. A generated module is ordinary source in your repository — zero runtime dependency on our server. Only generating new or changed modules needs an active generator key, free or paid.

What if I need to change a generated module?

Change the schema and regenerate — refining a module is free within your current period. Files that are genuinely yours, such as translated labels, are never overwritten. For changes the schema cannot express, the code is entirely yours; edit it like any other code.

Why this when Filament and Laravel’s React starter kit are free?

Both are excellent, and sometimes they are the right choice. Filament is the better fit if your team writes Livewire: it builds admin screens from your columns and ships multi-factor sign-in, multi-tenancy and imports at no cost. Laravel’s React starter kit gives you sign-in and two-factor on the same React 19 + shadcn/ui stack this kit uses — a clean foundation, with no admin layer on top.

This kit is for React teams, and for what comes after sign-in: roles with a permission matrix, an audit trail with field-level diffs, passkeys and Google/GitHub sign-in handled inside your own app rather than by a hosted auth service, exports, and a production Docker stack. On top of that, the generator writes ordinary Laravel for every module — controllers, form requests, a REST API with its OpenAPI document, and 50 or more Pest tests. What it does not have is multi-tenancy: if you need tenants on day one, Filament is ahead of it there.

When is an AI assistant better?

For one unusual screen that follows no pattern — a bespoke dashboard, a one-off report — an assistant will get you there faster, and we would rather say so than have you find out after paying. This is built for the thirty screens that do follow a pattern, and for keeping them identical when five people build them.

Which databases are supported?

PostgreSQL, MySQL 8.4 and MariaDB 11. PostgreSQL is the engine the kit is built on and the one where every feature exists. MySQL and MariaDB run the product — install, migrations, CRUD, filters, exports, roles, the audit trail, two-factor, the REST API, and the generator itself: make:crud reads a MySQL schema as well as a PostgreSQL one — with four things that are simply absent there: array columns and the filter that reads them, the inet and macaddr types, trigram search (MySQL gets a plain LIKE: fine on a small table, a full scan on a large one), and reusing the email address of a soft-deleted account. Measured, not assumed: before a release the bundle is installed from nothing in a clean virtual machine four ways — Docker and native, each on PostgreSQL and on MySQL/MariaDB — and the suite is run on each engine there. For 2.9.1: 2,441 passing on PostgreSQL and 2,348 on MariaDB, and 971 on MySQL after the example modules are removed — none failing on any.

Does it work with our company identity provider?

Today: Google and GitHub, plus two-factor and passkeys. That is consumer SSO — it is not SAML or OIDC against Okta, Entra ID (Azure AD) or Keycloak, and there is no SCIM provisioning. If your client’s IT department hands you a metadata URL, this kit does not read it yet. Need one of those? Tell us which provider — it is buildable on the sign-in flow that is already there, and knowing which provider you actually use is what decides whether we build it.

Still have a question? Write to [email protected] — a person reads it.

Write the table once.
The rest is born from it.

Screens, validation, permissions, exports — and the tests.