Aiku ERP Development Assistant

An expert AI assistant for developing the Aiku open-source white-label ERP web application. This skill enforces project-specific conventions, Laravel 12 best practices, Inertia v2 patterns, and mandatory test coverage.

Core Principles

1. **No Code Comments**: Write clear, self-explanatory code instead of adding comments

2. **Explicit Types**: Always use return type declarations and parameter type hints

3. **Test-Driven**: Every change must have programmatic test coverage

4. **Laravel Way**: Use Artisan commands, Eloquent ORM, and framework conventions

5. **Existing Conventions**: Check sibling files for structure, approach, and naming patterns before creating new code

Technology Stack

**Backend**: PHP 8.4, Laravel 12, Horizon, Octane, Pennant, Sanctum, Scout

**Frontend**: Vue 3, Inertia v2, Tailwind CSS 3, Ziggy

**Testing**: Pest 4, PHPUnit 12

**Code Quality**: Laravel Pint (formatting)

Development Workflow

1. Planning Phase

Before writing code:

Check existing components, methods, and patterns in sibling files

Use `list-artisan-commands` to verify available Artisan options

Search documentation using `search-docs` with broad, topic-based queries (e.g., `['rate limiting', 'routing']`)

Verify the approach aligns with Laravel 12 and Inertia v2 best practices

2. Code Generation

**Always use Artisan commands to create files:**

```bash

php artisan make:model --no-interaction [options] {Name}

php artisan make:controller --no-interaction {Name}

php artisan make:request --no-interaction {Name}

php artisan make:test --no-interaction --pest {Name}

php artisan make:class --no-interaction {Name} # For generic PHP classes

```

**PHP Conventions:**

Use constructor property promotion:

```php

public function __construct(public GitHub $github) { }

```

Always use curly braces for control structures (even single-line)

Use explicit return types and parameter types:

```php

protected function isAccessible(User $user, ?string $path = null): bool

{

// Implementation

}

```

Enum keys should be TitleCase: `FavoritePerson`, `BestLake`

No empty `__construct()` methods with zero parameters

**Database & Eloquent:**

Prefer `Model::query()` over `DB::`

Use eager loading to prevent N+1 queries

Define proper relationship methods with return type hints

When modifying columns in migrations, include ALL previous attributes to avoid data loss

Use model factories and seeders for test data

**Controllers & Validation:**

Create Form Request classes instead of inline validation

Check sibling Form Requests to match array vs. string validation rule style

Use queued jobs (`ShouldQueue`) for time-consuming operations

**Inertia v2 Patterns:**

Place components in `resources/js/Pages` directory

Use `Inertia::render()` in routes instead of Blade views

Leverage v2 features: polling, prefetching, deferred props, infinite scrolling

Use `<Form>` component or `useForm` helper following existing conventions

Add animated skeleton states for deferred props

**Configuration & URLs:**

Use `config('app.name')` never `env('APP_NAME')` outside config files

Generate links with `route()` function and named routes

Use `get-absolute-url` tool for sharing project URLs with correct scheme/domain

3. Testing Requirements

**Critical: Every change must be tested programmatically.**

Write feature tests (default) or unit tests (`--unit` flag)

Use model factories; check for custom states before manual setup

Use `$this->faker->word()` or `fake()->randomDigit()` per existing conventions

Test happy paths, failure paths, and edge cases

**Pest Syntax:**

```php

it('returns all users', function () {

$response = $this->postJson('/api/users', []);

$response->assertSuccessful(); // Use specific assertions

});

```

**Running Tests:**

```bash

Specific file

php artisan test tests/Feature/ExampleTest.php

Filter by name (recommended after changes)

php artisan test --filter=testName

All tests

php artisan test

```

**Run minimal tests needed to verify changes before finalizing.**

4. Code Quality

**Run Pint before finalizing (DO NOT run with --dirty flag per project rules):**

```bash

vendor/bin/pint

```

5. Debugging Tools

Use `tinker` tool to execute PHP and query Eloquent models

Use `database-query` tool for read-only database queries

Use `browser-logs` tool to read browser errors (only recent logs are useful)

Laravel 12 Structure Notes

This project upgraded from Laravel 10 **without migrating to the streamlined file structure** (this is recommended by Laravel):

Middleware: `app/Http/Middleware/`

Service Providers: `app/Providers/`

Middleware registration: `app/Http/Kernel.php`

Exception handling: `app/Exceptions/Handler.php`

Console commands: `app/Console/Kernel.php`

No `bootstrap/app.php` application configuration

Feature Flags

This application uses **Laravel Pennant** for feature flag management. Use `search-docs` to assist with feature flag implementation.

API Development

Default to Eloquent API Resources with versioning (unless existing APIs use different conventions)

Follow existing route structure and resource patterns

Common Issues

**Vite Manifest Error:**

If you see "Unable to locate file in Vite manifest", run:

```bash

npm run build

or ask user to run:

npm run dev

or:

composer run dev

```

**Frontend Changes Not Reflected:**

Ask user if they need to run build commands (`npm run build`, `npm run dev`, or `composer run dev`).

Documentation Search Syntax

Use `search-docs` with multiple broad queries:

Simple words: `authentication` (auto-stemming finds 'authenticate', 'auth')

Multiple words (AND logic): `rate limit` (both terms required)

Exact phrases: `"infinite scroll"` (adjacent, exact order)

Mixed: `middleware "rate limit"`

Multiple queries: `["authentication", "middleware"]` (ANY match)

**Never include package names in queries** (already passed automatically).

Constraints

Do not create documentation files unless explicitly requested

Do not create verification scripts when tests cover functionality

Do not change directory structure or dependencies without approval

Do not remove tests or test files without approval

Be concise in explanations; focus on important details only

Never allow empty `__construct()` methods

Example Workflow

1. User requests: "Add user authentication endpoint"

2. Search docs: `search-docs ["authentication", "api resources", "sanctum"]`

3. Create files using Artisan:

- `php artisan make:controller --no-interaction AuthController`

- `php artisan make:request --no-interaction LoginRequest`

- `php artisan make:test --no-interaction --pest AuthTest`

4. Write clear, typed, self-documenting code (no comments)

5. Write comprehensive tests covering happy/failure/edge cases

6. Run targeted tests: `php artisan test --filter=Auth`

7. Format code: `vendor/bin/pint`

8. Ask user if they want full test suite run

---

This skill ensures consistency with Aiku's established patterns while leveraging modern Laravel 12, Inertia v2, and Vue 3 capabilities.

Aiku ERP Development Assistant

Aiku ERP Development Assistant

Core Principles

Technology Stack

Development Workflow

1. Planning Phase

2. Code Generation

3. Testing Requirements

Specific file

Filter by name (recommended after changes)

All tests

4. Code Quality

5. Debugging Tools

Laravel 12 Structure Notes

Feature Flags

API Development

Common Issues

or ask user to run:

or:

Documentation Search Syntax

Constraints

Example Workflow

Reviews (0)