PHP Attributes in Laravel 13: The Ultimate Guide (36 New Attributes!)

New Laravel 13 went all-in on PHP attributes. Properties like $fillable, $guarded, and $hidden that you've been defining on models for years can now be declared as class-level attributes: #[Fillable], #[Guarded], and #[Hidden]. The same applies to job configuration, console command signatures, middleware, and more.

In this article, I'll walk you through every PHP attribute available in Laravel 13 — both the new ones and those that existed before — with practical code examples for each.

Important notice: those attributes are optional, and you may use the old syntax in all those cases. The attributes are NOT breaking changes, just the new alternatives.

New in Laravel 13

Eloquent Model Attributes

These attributes replace the familiar model properties you've been writing for years. Again, if you WANT to use them, they are optional.

1. #[Fillable] — Define Mass-Assignable Fields

Before:

class Post extends Model
{
    protected $fillable = ['title', 'body', 'status'];
}

After:

use Illuminate\Database\Eloquent\Attributes\Fillable;
 
#[Fillable(['title', 'body', 'status'])]
class Post extends Model
{
}

2. #[Guarded] — Define Guarded Fields

Before:

class User extends Model
{
    protected $guarded = ['id', 'is_admin'];
}

After:

use Illuminate\Database\Eloquent\Attributes\Guarded;
 
#[Guarded(['id', 'is_admin'])]
class User extends Model
{
}

3. #[Unguarded] — Disable Mass-Assignment Protection

A marker attribute — no parameters needed.

Before:

class Setting extends Model
{
    protected $guarded = [];
}

After:

use Illuminate\Database\Eloquent\Attributes\Unguarded;
 
#[Unguarded]
class Setting extends Model
{
}

4. #[Hidden] — Hide Fields From Serialization

Before:

class User extends Model
{
    protected $hidden = ['password', 'remember_token'];
}

After:

use Illuminate\Database\Eloquent\Attributes\Hidden;
 
#[Hidden(['password', 'remember_token'])]
class User extends Model
{
}

5. #[Visible] — Explicitly Define Visible Fields

Before:

class User extends Model
{
    protected $visible = ['id', 'name', 'email'];
}

After:

use Illuminate\Database\Eloquent\Attributes\Visible;
 
#[Visible(['id', 'name', 'email'])]
class User extends Model
{
}

6. #[Appends] — Auto-Append Accessors to JSON

Before:

class User extends Model
{
    protected $appends = ['full_name', 'is_active'];
 
    public function getFullNameAttribute(): string
    {
        return $this->first_name.' '.$this->last_name;
    }
}

After:

use Illuminate\Database\Eloquent\Attributes\Appends;
 
#[Appends(['full_name', 'is_active'])]
class User extends Model
{
    public function getFullNameAttribute(): string
    {
        return $this->first_name.' '.$this->last_name;
    }
}

7. #[Table] — Set Table Name and Key Configuration

This one is powerful — it replaces multiple properties at once: $table, $primaryKey, $keyType, $incrementing, $timestamps, and $dateFormat.

Before:

class Post extends Model
{
    protected $table = 'blog_posts';
    protected $primaryKey = 'post_id';
}

After:

use Illuminate\Database\Eloquent\Attributes\Table;
 
#[Table('blog_posts', key: 'post_id')]
class Post extends Model
{
}

With all options:

Before:

class ExternalOrder extends Model
{
    protected $table = 'external_orders';
    protected $primaryKey = 'uuid';
    protected $keyType = 'string';
    public $incrementing = false;
    public $timestamps = false;
}

After:

#[Table(
    name: 'external_orders',
    key: 'uuid',
    keyType: 'string',
    incrementing: false,
    timestamps: false,
)]
class ExternalOrder extends Model
{
}

8. #[Connection] — Set Model Database Connection

Before:

class PageView extends Model
{
    protected $connection = 'analytics';
}

After:

use Illuminate\Database\Eloquent\Attributes\Connection;
 
#[Connection('analytics')]
class PageView extends Model
{
}

9. #[Touches] — Touch Parent Timestamps

Before:

class Comment extends Model
{
    protected $touches = ['post'];
 
    public function post(): BelongsTo
    {
        return $this->belongsTo(Post::class);
    }
}

After:

use Illuminate\Database\Eloquent\Attributes\Touches;
 
#[Touches(['post'])]
class Comment extends Model
{
    public function post(): BelongsTo
    {
        return $this->belongsTo(Post::class);
    }
}

Queue / Job Attributes

Configure your jobs declaratively instead of setting properties.

10. #[Tries] — Set Max Attempts

Before:

class ProcessPayment implements ShouldQueue
{
    public $tries = 3;
}

After:

use Illuminate\Queue\Attributes\Tries;
 
#[Tries(3)]
class ProcessPayment implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
}

11. #[Timeout] — Set Job Timeout

Before:

class GenerateReport implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
 
    public $timeout = 120;
}

After:

use Illuminate\Queue\Attributes\Timeout;
 
#[Timeout(120)]
class GenerateReport implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
}

12. #[Backoff] — Set Retry Backoff

Before:

class SyncInventory implements ShouldQueue
{
    public $backoff = 30;
 
    // Or for exponential backoff:
    // public $backoff = [10, 30, 60];
}

After:

use Illuminate\Queue\Attributes\Backoff;
 
// Fixed backoff
#[Backoff(30)]
class SyncInventory implements ShouldQueue
{
}
 
// Exponential backoff
#[Backoff([10, 30, 60])]
class SyncInventory implements ShouldQueue
{
}

13. #[MaxExceptions] — Max Exceptions Before Failing

Before:

class ImportCsvRows implements ShouldQueue
{
    public $maxExceptions = 3;
}

After:

use Illuminate\Queue\Attributes\MaxExceptions;
 
#[MaxExceptions(3)]
class ImportCsvRows implements ShouldQueue
{
}

14. #[Queue] — Set Queue Name

Before:

class SendWelcomeEmail implements ShouldQueue
{
    public $queue = 'high';
}

After:

use Illuminate\Queue\Attributes\Queue;
 
#[Queue('high')]
class SendWelcomeEmail implements ShouldQueue
{
}

15. #[Connection] — Set Queue Connection

Before:

class ProcessWebhook implements ShouldQueue
{
    public $connection = 'redis';
}

After:

use Illuminate\Queue\Attributes\Connection;
 
#[Connection('redis')]
class ProcessWebhook implements ShouldQueue
{
}

16. #[UniqueFor] — Unique Job Lock Duration

Before:

class RebuildSearchIndex implements ShouldQueue, ShouldBeUnique
{
    public $uniqueFor = 3600;
}

After:

use Illuminate\Queue\Attributes\UniqueFor;
use Illuminate\Contracts\Queue\ShouldBeUnique;
 
#[UniqueFor(3600)]
class RebuildSearchIndex implements ShouldQueue, ShouldBeUnique
{
}

17. #[FailOnTimeout] — Fail Instead of Retry on Timeout

Before:

class CallExternalApi implements ShouldQueue
{
    public $failOnTimeout = true;
}

After:

use Illuminate\Queue\Attributes\FailOnTimeout;
 
#[FailOnTimeout]
class CallExternalApi implements ShouldQueue
{
}

You can combine multiple job attributes:

use Illuminate\Queue\Attributes\{Connection, Queue, Tries, Timeout, Backoff};
 
#[Connection('redis')]
#[Queue('high')]
#[Tries(3)]
#[Timeout(60)]
#[Backoff([5, 15, 30])]
class ProcessPayment implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
}

Console Command Attributes

Define your Artisan commands without the $signature, $description, and $help properties.

18. #[Signature] — Define Command Signature

Before:

class PruneUsers extends Command
{
    protected $signature = 'users:prune {--days=30 : Days of inactivity}';
    protected $description = 'Prune inactive user accounts';
}

After:

use Illuminate\Console\Attributes\Signature;
use Illuminate\Console\Attributes\Description;
 
#[Signature('users:prune {--days=30 : Days of inactivity}')]
#[Description('Prune inactive user accounts')]
class PruneUsers extends Command
{
    public function handle(): void
    {
        $days = $this->option('days');
        // ...
    }
}

The Signature attribute also accepts aliases:

#[Signature('cache:warm', aliases: ['warm-cache'])]
class WarmCache extends Command
{
}

19. #[Description] — Set Command Description

Before:

class SendMarketingEmails extends Command
{
    protected $description = 'Send scheduled marketing emails';
}

After:

use Illuminate\Console\Attributes\Description;
 
#[Description('Send scheduled marketing emails')]
class SendMarketingEmails extends Command
{
}

20. #[Help] — Set Help Text

Before:

class ProcessOrders extends Command
{
    protected $help = 'This command processes all pending orders and sends confirmation emails. Run during off-peak hours.';
}

After:

use Illuminate\Console\Attributes\Help;
 
#[Help('This command processes all pending orders and sends confirmation emails. Run during off-peak hours.')]
class ProcessOrders extends Command
{
}

21. #[Hidden] — Hide Command From List

Before:

class DebugInternals extends Command
{
    protected $hidden = true;
}

After:

use Illuminate\Console\Attributes\Hidden;
 
#[Hidden]
class DebugInternals extends Command
{
}

22. #[Usage] — Add Usage Examples (Repeatable)

Before:

class PruneUsers extends Command
{
    protected $help = <<<'HELP'
    Usage examples:
      users:prune --days=60
      users:prune --days=30 --dry-run
    HELP;
}

After:

use Illuminate\Console\Attributes\Usage;
 
#[Usage('users:prune --days=60')]
#[Usage('users:prune --days=30 --dry-run')]
class PruneUsers extends Command
{
}

Routing & Controller Attributes

23. #[Middleware] — Attach Middleware to Controllers

Apply middleware at the class level, method level, or both. This is repeatable.

Before:

class DashboardController extends Controller
{
    public function __construct()
    {
        $this->middleware(['auth', 'verified']);
    }
 
    public function index()
    {
        return view('dashboard');
    }
}

After:

use Illuminate\Routing\Attributes\Controllers\Middleware;
 
#[Middleware('auth')]
#[Middleware('verified')]
class DashboardController extends Controller
{
    public function index()
    {
        return view('dashboard');
    }
}

Restrict middleware to specific methods with only and except:

#[Middleware('auth')]
#[Middleware('admin', only: ['destroy'])]
#[Middleware('throttle:60,1', except: ['index', 'show'])]
class PostController extends Controller
{
    // ...
}

Apply middleware to individual methods:

class ReportController extends Controller
{
    #[Middleware('cache.headers:public;max_age=3600')]
    public function show(Report $report)
    {
        return view('reports.show', compact('report'));
    }
}

24. #[Authorize] — Gate Authorization on Controllers

Before:

class PostController extends Controller
{
    public function __construct()
    {
        $this->authorizeResource(Post::class, 'post');
    }
 
    public function edit(Post $post)
    {
        return view('posts.edit', compact('post'));
    }
}

After:

use Illuminate\Routing\Attributes\Controllers\Authorize;
 
#[Authorize('viewAny', Post::class)]
class PostController extends Controller
{
    #[Authorize('update', Post::class)]
    public function edit(Post $post)
    {
        return view('posts.edit', compact('post'));
    }
}

Restrict to specific methods:

#[Authorize('manage-users', only: ['edit', 'update', 'destroy'])]
class UserController extends Controller
{
}

Form Request Attributes

25. #[ErrorBag] — Set Named Error Bag

Before:

class CreatePostRequest extends FormRequest
{
    protected $errorBag = 'createPost';
}

After:

use Illuminate\Foundation\Http\Attributes\ErrorBag;
 
#[ErrorBag('createPost')]
class CreatePostRequest extends FormRequest
{
    public function rules(): array
    {
        return ['title' => 'required|max:255'];
    }
}

26. #[RedirectTo] — Redirect URL on Validation Failure

Before:

class StorePostRequest extends FormRequest
{
    protected $redirect = '/posts/create';
 
    public function rules(): array
    {
        return ['title' => 'required'];
    }
}

After:

use Illuminate\Foundation\Http\Attributes\RedirectTo;
 
#[RedirectTo('/posts/create')]
class StorePostRequest extends FormRequest
{
    public function rules(): array
    {
        return ['title' => 'required'];
    }
}

27. #[RedirectToRoute] — Redirect to Named Route on Failure

Before:

class StorePostRequest extends FormRequest
{
    protected $redirectRoute = 'posts.create';
 
    public function rules(): array
    {
        return ['title' => 'required'];
    }
}

After:

use Illuminate\Foundation\Http\Attributes\RedirectToRoute;
 
#[RedirectToRoute('posts.create')]
class StorePostRequest extends FormRequest
{
    public function rules(): array
    {
        return ['title' => 'required'];
    }
}

28. #[StopOnFirstFailure] — Stop Validation on First Error

Before:

class ImportRequest extends FormRequest
{
    protected $stopOnFirstFailure = true;
 
    public function rules(): array
    {
        return [
            'file' => 'required|file|mimes:csv',
            'mapping' => 'required|array',
        ];
    }
}

After:

use Illuminate\Foundation\Http\Attributes\StopOnFirstFailure;
 
#[StopOnFirstFailure]
class ImportRequest extends FormRequest
{
    public function rules(): array
    {
        return [
            'file' => 'required|file|mimes:csv',
            'mapping' => 'required|array',
        ];
    }
}

HTTP Resource Attributes

29. #[Collects] — Define Resource Collection Type

Before:

class PostCollection extends ResourceCollection
{
    public $collects = PostResource::class;
}

After:

use Illuminate\Http\Resources\Attributes\Collects;
 
#[Collects(PostResource::class)]
class PostCollection extends ResourceCollection
{
}

30. #[PreserveKeys] — Preserve Array Keys in Collections

Before:

class CountryResource extends JsonResource
{
    public $preserveKeys = true;
 
    public function toArray(Request $request): array
    {
        return [
            'code' => $this->code,
            'name' => $this->name,
        ];
    }
}

After:

use Illuminate\Http\Resources\Attributes\PreserveKeys;
 
#[PreserveKeys]
class CountryResource extends JsonResource
{
    public function toArray(Request $request): array
    {
        return [
            'code' => $this->code,
            'name' => $this->name,
        ];
    }
}

Eloquent Factory Attributes

31. #[UseModel] — Bind Factory to a Model

Before:

class PostFactory extends Factory
{
    protected $model = Post::class;
 
    public function definition(): array
    {
        return [
            'title' => fake()->sentence(),
            'body' => fake()->paragraphs(3, true),
        ];
    }
}

After:

use Illuminate\Database\Eloquent\Factories\Attributes\UseModel;
 
#[UseModel(Post::class)]
class PostFactory extends Factory
{
    public function definition(): array
    {
        return [
            'title' => fake()->sentence(),
            'body' => fake()->paragraphs(3, true),
        ];
    }
}

Testing Attributes

32. #[Seed] — Run Default Seeder for Test Class

Before:

class ProductPageTest extends TestCase
{
    protected $seed = true;
 
    public function test_products_page_shows_seeded_data(): void
    {
        $this->get('/products')->assertOk();
    }
}

After:

use Illuminate\Foundation\Testing\Attributes\Seed;
 
#[Seed]
class ProductPageTest extends TestCase
{
    public function test_products_page_shows_seeded_data(): void
    {
        $this->get('/products')->assertOk();
    }
}

33. #[Seeder] — Run a Specific Seeder

Before:

class AdminAccessTest extends TestCase
{
    protected $seeder = RoleAndPermissionSeeder::class;
 
    public function test_admin_can_access_dashboard(): void
    {
        $admin = User::factory()->admin()->create();
 
        $this->actingAs($admin)->get('/admin')->assertOk();
    }
}

After:

use Illuminate\Foundation\Testing\Attributes\Seeder;
 
#[Seeder(RoleAndPermissionSeeder::class)]
class AdminAccessTest extends TestCase
{
    public function test_admin_can_access_dashboard(): void
    {
        $admin = User::factory()->admin()->create();
 
        $this->actingAs($admin)->get('/admin')->assertOk();
    }
}

34. #[SetUp] — Mark Method as setUp Hook

Before:

class OrderTest extends TestCase
{
    private User $user;
 
    protected function setUp(): void
    {
        parent::setUp();
        $this->user = User::factory()->create();
    }
 
    public function test_user_can_place_order(): void
    {
        $this->actingAs($this->user)
            ->post('/orders', ['product_id' => 1])
            ->assertCreated();
    }
}

After:

use Illuminate\Foundation\Testing\Attributes\SetUp;
 
class OrderTest extends TestCase
{
    private User $user;
 
    #[SetUp]
    public function createUser(): void
    {
        $this->user = User::factory()->create();
    }
 
    public function test_user_can_place_order(): void
    {
        $this->actingAs($this->user)
            ->post('/orders', ['product_id' => 1])
            ->assertCreated();
    }
}

35. #[TearDown] — Mark Method as tearDown Hook

Before:

class ExternalApiTest extends TestCase
{
    protected function tearDown(): void
    {
        Cache::tags('external-api')->flush();
        parent::tearDown();
    }
}

After:

use Illuminate\Foundation\Testing\Attributes\TearDown;
 
class ExternalApiTest extends TestCase
{
    #[TearDown]
    public function clearApiCache(): void
    {
        Cache::tags('external-api')->flush();
    }
}

Pre-existing Attributes (Before Laravel 13)

These attributes were available in Laravel 11-12 and continue to work in Laravel 13.

Eloquent Model Attributes (Pre-existing)

#[ObservedBy] — Attach Model Observers

use Illuminate\Database\Eloquent\Attributes\ObservedBy;
 
#[ObservedBy(PostObserver::class)]
class Post extends Model
{
}

#[ScopedBy] — Apply Global Scopes

use Illuminate\Database\Eloquent\Attributes\ScopedBy;
 
#[ScopedBy(ActiveScope::class)]
class Subscription extends Model
{
}

#[CollectedBy] — Use Custom Collection Class

use Illuminate\Database\Eloquent\Attributes\CollectedBy;
 
#[CollectedBy(PostCollection::class)]
class Post extends Model
{
}

#[UseFactory] — Bind Model to Factory

use Illuminate\Database\Eloquent\Attributes\UseFactory;
 
#[UseFactory(PostFactory::class)]
class Post extends Model
{
}

#[UseEloquentBuilder] — Use Custom Query Builder

use Illuminate\Database\Eloquent\Attributes\UseEloquentBuilder;
 
#[UseEloquentBuilder(PostBuilder::class)]
class Post extends Model
{
}

#[UsePolicy] — Bind Model to Policy

use Illuminate\Database\Eloquent\Attributes\UsePolicy;
 
#[UsePolicy(PostPolicy::class)]
class Post extends Model
{
}

#[UseResource] and #[UseResourceCollection]

use Illuminate\Database\Eloquent\Attributes\UseResource;
use Illuminate\Database\Eloquent\Attributes\UseResourceCollection;
 
#[UseResource(PostResource::class)]
#[UseResourceCollection(PostCollection::class)]
class Post extends Model
{
}

#[Boot] and #[Initialize] — Lifecycle Hooks on Methods

use Illuminate\Database\Eloquent\Attributes\Boot;
use Illuminate\Database\Eloquent\Attributes\Initialize;
 
class Post extends Model
{
    #[Boot]
    public static function registerEvents(): void
    {
        static::creating(fn (Post $post) => $post->slug = Str::slug($post->title));
    }
 
    #[Initialize]
    public function setDefaults(): void
    {
        $this->attributes['status'] ??= 'draft';
    }
}

#[Scope] — Define Local Scopes on Methods

use Illuminate\Database\Eloquent\Attributes\Scope;
use Illuminate\Database\Eloquent\Builder;
 
class Post extends Model
{
    #[Scope]
    public function published(Builder $query): void
    {
        $query->whereNotNull('published_at');
    }
}

Queue Attributes (Pre-existing)

#[DeleteWhenMissingModels] — Delete Job When Model is Missing

use Illuminate\Queue\Attributes\DeleteWhenMissingModels;
 
#[DeleteWhenMissingModels]
class SendOrderConfirmation implements ShouldQueue
{
    public function __construct(private Order $order) {}
}

#[WithoutRelations] — Strip Relations Before Serializing

use Illuminate\Queue\Attributes\WithoutRelations;
 
#[WithoutRelations]
class ProcessOrder implements ShouldQueue
{
    public function __construct(private Order $order) {}
}

Container / Dependency Injection Attributes

These are used on constructor or method parameters to control how dependencies are resolved.

#[CurrentUser] — Inject the Authenticated User

use Illuminate\Container\Attributes\CurrentUser;
 
class DashboardController extends Controller
{
    public function index(#[CurrentUser] User $user)
    {
        return view('dashboard', compact('user'));
    }
}

#[Config] — Inject a Config Value

use Illuminate\Container\Attributes\Config;
 
class PaymentService
{
    public function __construct(
        #[Config('services.stripe.secret')] private string $stripeSecret,
    ) {
    }
}

#[Auth] — Inject an Auth Guard

use Illuminate\Container\Attributes\Auth;
use Illuminate\Contracts\Auth\Guard;
 
class ApiController extends Controller
{
    public function __construct(
        #[Auth('api')] private Guard $auth,
    ) {
    }
}

#[Cache] — Inject a Cache Store

use Illuminate\Container\Attributes\Cache;
use Illuminate\Contracts\Cache\Repository;
 
class ReportService
{
    public function __construct(
        #[Cache('redis')] private Repository $cache,
    ) {
    }
}

#[DB] — Inject a Database Connection

use Illuminate\Container\Attributes\DB;
use Illuminate\Database\Connection;
 
class AnalyticsService
{
    public function __construct(
        #[DB('analytics')] private Connection $db,
    ) {
    }
}

#[Log] — Inject a Log Channel

use Illuminate\Container\Attributes\Log;
use Psr\Log\LoggerInterface;
 
class PaymentService
{
    public function __construct(
        #[Log('payments')] private LoggerInterface $logger,
    ) {
    }
}

#[Storage] — Inject a Filesystem Disk

use Illuminate\Container\Attributes\Storage;
use Illuminate\Contracts\Filesystem\Filesystem;
 
class UploadService
{
    public function __construct(
        #[Storage('s3')] private Filesystem $disk,
    ) {
    }
}

#[Tag] — Inject Tagged Services

use Illuminate\Container\Attributes\Tag;
 
class NotificationSender
{
    public function __construct(
        #[Tag('notification.channels')] private iterable $channels,
    ) {
    }
}

#[RouteParameter] — Inject a Route Parameter

use Illuminate\Container\Attributes\RouteParameter;
 
class InvoiceController extends Controller
{
    public function show(#[RouteParameter('invoice')] string $invoiceId)
    {
        // ...
    }
}

#[Give] — Provide a Specific Implementation

use Illuminate\Container\Attributes\Give;
 
class OrderProcessor
{
    public function __construct(
        #[Give(StripePaymentGateway::class)] private PaymentGateway $gateway,
    ) {
    }
}

#[Authenticated] — Inject the Authenticated User (via Guard)

use Illuminate\Container\Attributes\Authenticated;
use Illuminate\Contracts\Auth\Authenticatable;
 
class ProfileController extends Controller
{
    public function edit(#[Authenticated('web')] Authenticatable $user)
    {
        return view('profile.edit', compact('user'));
    }
}

#[Context] — Inject from the Context Repository

use Illuminate\Container\Attributes\Context;
 
class RequestHandler
{
    public function __construct(
        #[Context('request_id')] private string $requestId,
    ) {
    }
}

#[Database] — Inject a Database Connection (alias)

use Illuminate\Container\Attributes\Database;
use Illuminate\Database\Connection;
 
class LegacyService
{
    public function __construct(
        #[Database('legacy_mysql')] private Connection $db,
    ) {
    }
}

Container / Service Registration Attributes

These go on class definitions to control how services are registered.

#[Bind] — Auto-Bind a Class to the Container

use Illuminate\Container\Attributes\Bind;
 
#[Bind]
class InvoiceGenerator
{
    public function generate(Order $order): Invoice
    {
        // A new instance is created each time it's resolved
    }
}

#[Singleton] — Register as Singleton

use Illuminate\Container\Attributes\Singleton;
 
#[Singleton]
class FeatureFlagService
{
    private array $flags = [];
 
    public function isEnabled(string $flag): bool
    {
        return $this->flags[$flag] ?? false;
    }
}

#[Scoped] — Register as Scoped Instance

use Illuminate\Container\Attributes\Scoped;
 
#[Scoped]
class RequestContext
{
    public ?string $traceId = null;
}

Summary

Laravel 13 added 36 new attribute classes, bringing the total to over 50. The biggest wins are:

• Model attributes (#[Fillable], #[Table], #[Hidden], etc.) — cleaner model definitions with no property boilerplate
• Job attributes (#[Tries], #[Timeout], #[Queue], etc.) — configure jobs entirely with attributes
• Console attributes (#[Signature], #[Description]) — define commands without string properties
• Controller attributes (#[Middleware], #[Authorize]) — attach middleware and authorization declaratively

The traditional property-based approach still works. Attributes are an alternative, not a replacement. Pick whichever style your team prefers and stay consistent.