# AI-Driven Development Compatibility Report

**Project:** QuitSure Laravel Program
**Date:** 2026-02-23 (updated)
**Laravel Version:** 11.47.0 | **PHP:** 8.3+
**Analyzed by:** Claude Opus 4.5

---

## Overall AI Compatibility Score

| | |
|---|---|
| **Score** | **60 / 100** |
| **Grade** | **C-** |
| **Verdict** | Functional but significant friction for AI-assisted development |

The codebase has strong foundational qualities (consistency, test infrastructure, excellent AI context documentation with 100% PHPDoc coverage on public methods) but is held back by massive code duplication, oversized files, and weak type contracts. An AI assistant can work in this codebase but will frequently encounter ambiguity, context-window limitations, and multi-file synchronization challenges.

---

## Category Scores

| Category | Score | Weight | Weighted | Status |
|---|---|---|---|---|
| Structure & Navigability | 13/15 | 15% | 13.0 | Good |
| Code Consistency | 13/15 | 15% | 13.0 | Strong |
| Type Safety & Contracts | 5/15 | 15% | 5.0 | Weak |
| Code Duplication (DRY) | 2/10 | 10% | 2.0 | Critical |
| Testing Infrastructure | 6/10 | 10% | 6.0 | Moderate |
| Documentation & Context | 10/10 | 10% | 10.0 | Excellent |
| File Size & Complexity | 3/10 | 10% | 3.0 | Critical |
| Architecture & Dependencies | 5/10 | 5% | 5.0 | Moderate |
| Change Safety & Verifiability | 3/5 | 5% | 3.0 | Moderate |
| **Total** | | **100%** | **60.0** | **C-** |

---

## Detailed Category Analysis

### 1. Structure & Navigability — 13/15 (Good)

**What works well:**
- Clear, predictable directory hierarchy organized by feature (OnBoarding, B2C, B2B) and language
- Dedicated layers: Controllers → Query Classes → Models → Services
- 40 Query classes provide a clean data-access abstraction that AI can reason about
- `CLAUDE.md` provides purpose-built AI navigation context
- All 790 production routes are named using a consistent `{flow}.{lang}.{section}.{step}` convention (e.g., `b2c.eng.email.submit`, `onboarding.eng.basic.1-0`), enabling `route()` helper usage and clear identification in `route:list`, logs, and error pages

**What hinders AI:**
- 69 controller files across nested language directories — AI must determine which language variant to modify

**Example — Clear structure AI can navigate:**
```
app/Http/Controllers/
├── B2C/
│   ├── B2CController.php          ← Base class (144 lines)
│   ├── English/CustomerController.php  ← 2,399 lines
│   ├── German/CustomerController.php   ← 2,371 lines
│   ├── Hindi/CustomerController.php    ← 2,370 lines
│   └── ... (6 language variants)
```

**Key metrics:**
| Component | Count | Avg Lines |
|---|---|---|
| Controllers | 69 | ~900 |
| Models | 45 | ~150 |
| Query Classes | 40 | ~200 |
| Services | 12 | ~275 |
| Blade Views | 468 | ~88 |
| Routes | 795 (790 named) | Single file |

---

### 2. Code Consistency — 13/15 (Strong)

This is the codebase's greatest strength for AI development. Once an AI learns one controller's pattern, it can predict the structure of all others.

**Highly consistent patterns:**

**Controller constructor pattern (used in all 12 major controllers):**
```php
// app/Http/Controllers/B2C/English/CustomerController.php:48-80
public function __construct(
    protected Request $request,
    protected CouponQuery $couponQuery,
    protected CurrencyQuery $currencyQuery,
    // ... 25 more dependencies
) {
    parent::__construct($request);
    Stripe::setApiKey(config('services.stripe.key'));
}
```

**Model convention (all 45 models):**
```php
// app/Models/User.php:12-39
class User extends Model {
    protected $table = 'tbl_Users';       // Always prefixed with tbl_
    protected $primaryKey = 'iUserID';     // Always Hungarian notation
    public $timestamps = false;            // Always disabled
    protected $fillable = [...];           // Always specified
}
```

**Query class convention (all 40 classes):**
```php
// Consistent method naming: get*(), create(), update(), check*(), find*()
public function getUserProgram(int $iUserID, int $iProgramID): ?UserProgram
public function create(array $data): int
public function update(int $id, array $data): bool
```

**Hungarian notation is consistent throughout:**
| Prefix | Type | Examples |
|---|---|---|
| `v` | varchar/string | `vEmail`, `vName`, `vAccessToken` |
| `i` | integer | `iUserID`, `iProgramID`, `iPartnerId` |
| `b` | boolean | `bActive`, `bDeleted`, `bSubscribed` |
| `d` | date | `dDateCreated`, `dExpiryDate` |
| `dec` | decimal | `decCostPerMonth`, `decMultiplier` |
| `set` | array/JSON | `setHealthIssues`, `setQuittingReasons` |

**Minor inconsistencies (-2):**
- String concatenation spacing varies: `viewPrefix . 'email'` vs `viewPrefix.'email'`
- Some column names break Hungarian convention: `SmokingStatus`, `SocialId` in `User.php:26-28`

---

### 3. Type Safety & Contracts — 5/15 (Weak)

This is a significant weakness. AI assistants rely on type information to understand data shapes, method contracts, and expected behaviors.

**What exists:**
- PHP 8.2+ enables modern type features
- PHPStan at level 5/9 with Larastan (`phpstan.neon`)
- Constructor parameters have type hints (via PHP 8.1 promoted properties)
- Some services have good type coverage

**What's missing:**

**Missing return types (~70% of controller/service methods):**
```php
// app/Http/Controllers/B2C/English/CustomerController.php:82
public function loadEmail()           // No return type
{
    return view($this->viewPrefix . 'email', $viewData);
}

// app/Services/UserUtilityService.php:23
public function encryptData($data)    // No param type, no return type
{
    return base64_encode($data . '-' . substr(uniqid(), -5));
}
```

**Good type coverage (RazorpayService — the gold standard in this codebase):**
```php
// app/Services/RazorpayService.php
private string $keyId;
private string $keySecret;
public function generateOrder(array $requestData): object|false
private function convertToSubunit(float|int $amount): int
```

**No interfaces defined anywhere:**
- 12 services have no contracts
- Query classes have no interfaces
- AI cannot verify substitutability or understand expected behaviors

**No Form Requests:**
- Validation is inline in controllers via `Validator::make()`
- AI cannot discover validation rules without reading each controller method

**No DTOs:**
- Data passed as untyped arrays between layers
- AI must trace array keys through multiple method calls to understand data shapes

**Type coverage estimate:**
| Layer | Constructor Types | Return Types | Parameter Types | PHPDoc |
|---|---|---|---|---|
| Controllers | 100% | ~10% | ~30% | ~5% |
| Services | 80% | ~40% | ~50% | 100% |
| Query Classes | 90% | ~30% | ~60% | ~10% |
| Models | N/A | ~80% (relations) | N/A | ~5% |
| Helpers | N/A | 100% | 100% | 100% |

---

### 4. Code Duplication — 2/10 (Critical)

This is the codebase's most severe AI-compatibility issue. Nearly identical code is replicated across 6-7 language variants.

**Controller duplication — 25,000 lines across 12 files:**

| Controller | Lines | Diff from English |
|---|---|---|
| `B2C/English/CustomerController.php` | 2,399 | — (baseline) |
| `B2C/German/CustomerController.php` | 2,371 | ~28 lines differ |
| `B2C/Hindi/CustomerController.php` | 2,370 | ~29 lines differ |
| `B2C/Japanese/CustomerController.php` | 2,372 | ~27 lines differ |
| `B2C/Portuguese/CustomerController.php` | 2,371 | ~28 lines differ |
| `B2C/Spanish/CustomerController.php` | 2,333 | ~66 lines differ |
| `B2B/English/PartnerController.php` | 1,861 | — (baseline) |
| `B2B/German/PartnerController.php` | 1,783 | ~78 lines differ |
| `B2B/Hindi/PartnerController.php` | 1,783 | ~78 lines differ |
| `B2B/Japanese/PartnerController.php` | 1,783 | ~78 lines differ |
| `B2B/Portuguese/PartnerController.php` | 1,783 | ~78 lines differ |
| `B2B/Spanish/PartnerController.php` | 1,783 | ~78 lines differ |
| **Total** | **24,992** | **~22,500 duplicated** |

**Estimated duplication: ~90% of these 25K lines are identical across languages.**

**Why this critically hurts AI:**
1. **Multi-file synchronization** — A bug fix or feature addition must be replicated in 6-7 files. AI must identify ALL affected files.
2. **Ambiguity** — When asked to "fix the checkout flow," AI must determine: which language? All of them? Just English?
3. **Context window waste** — Reading one 2,399-line controller consumes significant context. Reading all 6 variants for a cross-language change is prohibitive.
4. **Drift risk** — AI might apply a fix slightly differently across variants, introducing subtle bugs.

**View template duplication is equally severe:**
```
resources/views/B2C/english/subscribe.blade.php    886 lines
resources/views/B2C/german/subscribe.blade.php     893 lines
resources/views/B2C/hindi/subscribe.blade.php      878 lines
resources/views/B2C/japanese/subscribe.blade.php   864 lines
resources/views/B2C/portuguese/subscribe.blade.php 885 lines
resources/views/B2C/spanish/subscribe.blade.php    709 lines
```

---

### 5. Testing Infrastructure — 6/10 (Moderate)

**Strengths:**

- **61 test files** covering unit, feature, and integration layers
- **Pest PHP framework** with custom expectations in `tests/Pest.php`:
  ```php
  expect()->extend('toBeSuccessResponse', function () {
      return $this->toHaveKey('success', true);
  });
  expect()->extend('toBeValidUser', function () {
      return $this->toHaveKeys(['iUserID', 'vEUserID']);
  });
  ```
- **MockHelper** (`tests/Helpers/MockHelper.php` — 472 lines) with 50+ factory methods:
  ```php
  MockHelper::mockUserQuery(['getUser' => $fakeUser]);
  MockHelper::mockStripePaymentService();
  ```
- **TestDataBuilder** (`tests/Helpers/TestDataBuilder.php`) for composing test objects:
  ```php
  TestDataBuilder::userWithAllRelations(['user' => ['iProgramID' => 5]]);
  ```
- **In-memory SQLite** configured in `phpunit.xml` for fast tests

**Weaknesses:**
- **No database factories** — `database/factories/` does not exist; tests use MockHelper instead
- **No migrations** — Cannot run real database tests; all tests mock DB layer
- **Some tests skipped** — Stripe webhook tests deferred to integration
- **No code coverage thresholds** defined
- **Controller test ratio** — 48 feature tests for 69 controllers (~70% coverage)

**AI impact:** AI can run tests to verify changes (`php artisan test`) but cannot write tests that exercise real database interactions. The mock-heavy approach means tests verify wiring, not behavior.

---

### 6. Documentation & Context — 10/10 (Excellent)

**CLAUDE.md is exceptional (the strongest single factor):**
```markdown
## Architecture
### Controller Organization (Language-based)
### Query Classes (app/Http/Queries/)
### Services (app/Services/)
### Global Helper
### Models - non-standard naming conventions
### Key Integrations
```

This file alone elevates the documentation score significantly. It tells an AI:
- Where to find things
- What conventions to follow (including route naming: `{flow}.{lang}.{section}.{step}`)
- What non-standard patterns exist
- How to run commands

**CLAUDE.local.md provides environment context:**
- Laradock container commands
- Working branch information
- Personal coding preferences

**What's been addressed:**
- `README.md` replaced with project-specific Quick Start, architecture overview, and documentation index
- PHPDoc coverage: 100% on all public methods across services and helpers; private methods documented in key services
- Multi-database architecture (3 connections) documented in `CLAUDE.md`
- Business logic reference (Addiction Scoring, Subscription Intent, Payment Gateway Selection) added to `CLAUDE.md`
- 10 per-directory `README.md` files across `app/` subdirectories

**Remaining gaps:**
- No API documentation (no external REST API currently exposed)
- No architecture decision records (ADRs)

---

### 7. File Size & Complexity — 3/10 (Critical)

Large files are a direct barrier to AI effectiveness. Most AI coding assistants process 4K-8K lines of context effectively; beyond that, accuracy degrades.

**Top 10 largest PHP files:**

| File | Lines | AI Processable? |
|---|---|---|
| `B2C/English/CustomerController.php` | 2,399 | Partial — requires chunked reading |
| `B2C/Japanese/CustomerController.php` | 2,372 | Partial |
| `B2C/Portuguese/CustomerController.php` | 2,371 | Partial |
| `B2C/German/CustomerController.php` | 2,371 | Partial |
| `B2C/Hindi/CustomerController.php` | 2,370 | Partial |
| `B2C/Spanish/CustomerController.php` | 2,333 | Partial |
| `B2B/English/PartnerController.php` | 1,861 | Partial |
| `B2B/German/PartnerController.php` | 1,783 | Partial |
| `B2C/V3/English/CustomerController.php` | 1,675 | Partial |
| `routes/web.php` | 623 | Full |

**Constructor over-injection:**

`B2C/English/CustomerController.php` constructor has **28 injected dependencies** (lines 48-77):
- 19 Query classes
- 7 Services
- 1 Request
- 1 parent call

This violates Single Responsibility Principle and makes it extremely difficult for AI to understand which dependencies are relevant to any given method.

**Route file complexity:**
- 623 lines, 795 registered routes in a single file (284 route definitions expand via language loops)
- Dynamic language registration with nested arrays (lines 16-147)
- All routes are named with consistent `{flow}.{lang}.{section}.{step}` convention
- Still a single file — splitting by feature (R6) would further improve navigability

---

### 8. Architecture & Dependencies — 5/10 (Moderate)

**Good patterns:**
- **Query class layer** — Encapsulates DB access, prevents raw queries in controllers
- **Service layer** — Business logic separated from HTTP concerns
- **Base controller inheritance** — `B2CController`, `B2BController` handle common setup
- **GeoLocationServiceProvider** — Proper service provider registration

**Problematic patterns:**

**No interfaces — services are concrete-only:**
```php
// AI cannot discover what methods a service should have
// No contract to verify implementations against
protected UserUtilityService $userUtilityService  // Concrete class, not interface
```

**No Form Requests — validation scattered in controllers:**
```php
// app/Http/Controllers/B2C/English/CustomerController.php:90-93
public function submitEmail(Request $request)
{
    $validator = Validator::make($request->all(), [
        'vEmail' => 'required|email:filter',
    ]);
```

**Data passed as untyped arrays:**
```php
// app/Http/Controllers/B2C/B2CController.php:68-79
$customerData = [
    'Status' => true,
    'vSource' => $vSource,
    'baseSection' => 1,
    'source' => $source,       // No type safety
    'medium' => $medium,       // AI must trace origin to understand type
    'campaign' => $campaign,
    'vLinkSource' => '',
    'path' => '',
    'coupon_id' => $params['coupon_id'] ?? null,
    'Data' => [],
];
```

**Multiple database connections (now documented in CLAUDE.md):**
```php
// config/database.php defines 3 connections:
// 'mysql' → quitsure (main)
// 'qsuserinfo' → quitsureUsers (PII-separated user info)
// 'logs' → laravel_logs (app logging, SQL profiling, API timing)
// See CLAUDE.md "Database Architecture" section for full model mappings
```

---

### 9. Change Safety & Verifiability — 3/5 (Moderate)

**Positive:**
- Tests exist and can catch regressions (`php artisan test`)
- PHPStan can catch type errors (`./vendor/bin/phpstan analyse`)
- Pint enforces formatting (`./vendor/bin/pint`)

**Risky:**
- Duplication means a fix applied to one file but not others creates inconsistency
- No migration system means schema changes can't be verified
- 2 PHPStan exclusions hide potential issues (`WebController.php`, `WebQuiz/*`)
- No CI/CD pipeline definition visible in the repo

---

## AI Task Success Likelihood

| Task | Success Rate | Difficulty | Notes |
|---|---|---|---|
| Read & explain a specific method | 95% | Low | Consistent patterns make comprehension easy |
| Fix a bug in one language variant | 90% | Low | Clear file location, testable |
| Fix a bug across ALL language variants | 40% | High | Must modify 6-7 files identically, risk of drift |
| Add a new field to a model | 85% | Low | Follow existing fillable pattern |
| Add a new Query class method | 90% | Low | Very consistent patterns to follow |
| Add a new Service class | 80% | Medium | No interface template, but patterns are clear |
| Add a new onboarding step | 30% | Very High | Touches controllers, views, routes, JS across 7 languages |
| Add a new language | 20% | Very High | Must duplicate 15+ files and adapt each |
| Refactor payment logic | 45% | High | 2,399-line file, 28 dependencies, scattered validation |
| Write a new test | 75% | Medium | Good MockHelper, but must understand mock patterns |
| Modify the route file | 80% | Medium | 623 lines, 790 named routes; follow `{flow}.{lang}.{section}.{step}` convention |
| Create a Form Request | 85% | Low | Standard Laravel pattern, clear extraction target |
| Add a Blade component | 75% | Medium | No existing component patterns to follow |

---

## Top Recommendations (Prioritized by Impact)

### Priority 1 — Critical (Score Impact: +15-20 points)

#### R1. Extract language-specific differences into configuration

**Current:** 12 controllers with ~25,000 lines, ~90% duplicated
**Target:** 2 base controllers + language config files

```php
// BEFORE: 6 identical CustomerControllers with only view prefix differing
// AFTER: Single controller with language resolution
class CustomerController extends B2CController
{
    public function loadEmail()
    {
        return view($this->viewPrefix . 'email', $this->commonViewData);
    }
}
// Language differences resolved via config/translations, not code duplication
```

**Impact:** Reduces 25,000 lines to ~4,000. Makes every change a single-file edit. Eliminates sync risk entirely.

**Estimated effort:** Large (2-3 weeks) — but the highest-ROI change possible.

#### R2. Split controllers by extracting Action classes

**Current:** `CustomerController.php` — 2,399 lines, 28 constructor dependencies
**Target:** ~200-line controllers delegating to focused Action classes

```php
// Extract: app/Actions/B2C/SubmitEmailAction.php
class SubmitEmailAction
{
    public function __construct(
        private UserQuery $userQuery,
        private LoginQuery $loginQuery,
        private EmailService $emailService,
    ) {}

    public function execute(SubmitEmailRequest $request): JsonResponse
    {
        // ... focused logic
    }
}
```

**Impact:** Files drop below 300 lines. Constructor params drop to 3-5 per class. AI can read entire files in one pass.

### Priority 2 — High (Score Impact: +8-12 points)

#### R3. Add return type declarations to all public methods

**Current:** ~70% of methods lack return types
**Target:** 100% return type coverage

```php
// BEFORE
public function loadEmail()
public function submitEmail(Request $request)
private function buildProgramOffer($iProgramID, $iUserID, ...)

// AFTER
public function loadEmail(): \Illuminate\View\View
public function submitEmail(Request $request): \Illuminate\Http\JsonResponse
private function buildProgramOffer(int $iProgramID, int $iUserID, ...): array
```

**Impact:** AI can predict method behavior without reading implementation. PHPStan catches more errors.

**Estimated effort:** Medium (3-5 days with Rector automation)

#### R4. Introduce Form Requests for validation

**Current:** Inline `Validator::make()` calls in controllers
**Target:** Dedicated Form Request classes

```php
// app/Http/Requests/B2C/SubmitEmailRequest.php
class SubmitEmailRequest extends FormRequest
{
    public function rules(): array
    {
        return ['vEmail' => 'required|email:filter'];
    }
}
```

**Impact:** AI can discover validation rules by reading the request class. Controllers become slimmer. Validation is testable independently.

**Estimated effort:** Medium (1-2 weeks for all controllers)

#### R5. Increase PHPStan level to 7+

**Current:** Level 5 with 2 excluded paths
**Target:** Level 7 with baseline file

```neon
# phpstan.neon
parameters:
    level: 7
    paths:
        - app
        - routes
includes:
    - phpstan-baseline.neon   # Track existing errors separately
```

**Impact:** Catches missing types, wrong types, unreachable code. Creates a gradual improvement path.

**Estimated effort:** Small (1-2 days to generate baseline, then incremental)

### Priority 3 — Medium (Score Impact: +5-8 points)

#### R6. Split routes into feature-specific files

**Current:** Single 623-line `routes/web.php` (790 named routes)
**Target:** Feature-based route files

```
routes/
├── web.php              ← Requires only, 20 lines
├── web/onboarding.php   ← OnBoarding routes
├── web/b2c.php          ← B2C routes
├── web/b2b.php          ← B2B routes
├── web/webhooks.php     ← Webhook routes
└── web/payments.php     ← Payment routes
```

**Impact:** AI can target specific route groups. Reduces cognitive load per file.

#### R7. Create interfaces for services

```php
// app/Contracts/PaymentServiceInterface.php
interface PaymentServiceInterface
{
    public function generateOrder(array $requestData): object|false;
    public function verifyWebhookSignature(string $payload, string $signature): bool;
}
```

**Impact:** AI understands service contracts without reading implementations. Enables mocking verification.

#### R8. Add database factories for models

```php
// database/factories/UserFactory.php
class UserFactory extends Factory
{
    protected $model = User::class;

    public function definition(): array
    {
        return [
            'vEUserID' => $this->faker->uuid(),
            'bActive' => true,
            'iProgramID' => 1,
            'dDateCreated' => now(),
        ];
    }
}
```

**Impact:** AI can generate realistic test data. Integration tests become possible.

### Priority 4 — Low (Score Impact: +2-4 points)

#### ~~R9. Add named routes consistently~~ — COMPLETED (2026-02-23)
All 790 production routes now have names using `{flow}.{lang}.{section}.{step}` convention (5 dev-only routes remain unnamed). Route naming documented in `CLAUDE.md`.

#### ~~R10. Document multi-database architecture~~ — COMPLETED (2026-02-23)
Multi-database architecture (3 connections: `mysql`, `qsuserinfo`, `logs`) documented in `CLAUDE.md` with model mappings and cross-database notes.

#### R11. Create Blade components from repeated UI patterns

#### ~~R12. Add PHPDoc to CommonHelper.php functions~~ — COMPLETED (2026-02-23)
All public methods in helpers and services have 100% PHPDoc coverage. Private methods documented in key services (`SubModuleService`, `UtilityService`, `FacebookService`).

---

## Implementation Roadmap

```
Phase 1: Quick Wins (1-2 weeks)                    Score Impact: +10
├── R3: Add return types (Rector-assisted)
├── R5: PHPStan level 7 + baseline
├── R9: Named routes on critical paths          ✅ DONE
├── R10: Document database architecture         ✅ DONE
└── R12: PHPDoc on helpers                      ✅ DONE

Phase 2: Architecture Improvements (2-4 weeks)      Score Impact: +12
├── R4: Form Requests for all controllers
├── R6: Split route file
├── R7: Service interfaces
└── R8: Model factories

Phase 3: Structural Refactor (4-8 weeks)            Score Impact: +18
├── R1: Consolidate language controllers
├── R2: Extract Action classes
└── R11: Blade components

Projected Score After All Phases: ~90/100 (A-)
```

| Phase | Effort | Risk | Score After |
|---|---|---|---|
| Current State | — | — | 60 (C-) |
| Phase 1 Complete | 1-2 weeks | Low | 70 (C) |
| Phase 2 Complete | 2-4 weeks | Medium | 82 (B-) |
| Phase 3 Complete | 4-8 weeks | High | 90+ (A-) |

---

## Codebase Statistics Summary

| Metric | Value |
|---|---|
| Total PHP Files | ~1,148 |
| Total Blade Views | 468 |
| Total PHP Lines (excl. vendor) | ~161,000 |
| Total Blade Lines | ~41,000 |
| Controllers | 69 |
| Models | 45 |
| Query Classes | 40 |
| Services | 12 |
| Test Files | 61 |
| Routes | 795 (790 named) |
| Largest File | 2,399 lines |
| Max Constructor Params | 28 |
| Languages Supported | 7 |
| Estimated Duplicated Lines | ~22,500 |
| Duplication Ratio (controllers) | ~90% |
| PHPStan Level | 5/9 |
| Test Framework | Pest PHP |
| Database Connections | 3 |
| External Integrations | 8 (Stripe, Razorpay, Postmark, SendGrid, Branch.io, Facebook, AWS S3, GeoLocation) |

---

## Appendix: What Makes This Codebase Uniquely Challenging

### Hungarian Notation in Database Columns

All 45 models use non-standard column naming (`iUserID`, `vEmail`, `bActive`). While consistent, this means:
- AI cannot rely on Laravel conventions (`id`, `email`, `is_active`)
- Relationship resolution requires manual tracing (custom foreign keys everywhere)
- Any AI-generated migration or factory must use Hungarian notation

### Session-Based Authentication (No Laravel Auth)

The codebase uses custom session management (`Session::get('LoggedinUser')`, `Session::get('CustomerData')`) rather than Laravel's built-in authentication. AI cannot use standard Auth scaffolding patterns.

### No Migrations Architecture

Database schema is managed outside this codebase. This means:
- AI cannot inspect or modify database structure
- No `php artisan migrate` workflow
- Schema knowledge must come from model `$fillable` arrays and query classes

### Multi-Database Design

Three separate MySQL databases (`quitsure`, `quitsureUsers`, `laravel_logs`). Cross-database architecture and model mappings are now documented in `CLAUDE.md` (Database Architecture section).

---

*Report generated by analyzing all files in the repository. Scores reflect how effectively an AI coding assistant can understand, navigate, modify, and extend this specific codebase.*