Pavel Zaněk
Select language

How to generate files in Laravel using Artisan Console - command "make:"

This guide will walk you through using the make command in the Laravel Artisan Console. Learn how to quickly generate classes, edit templates, and efficiently resolve common errors. The ideal tutorial for streamlining your development process in Laravel.

Published at 2023-09-01 by Pavel Zaněk

Estimated Reading Time: 8 minutes

How to generate files in Laravel using Artisan Console - command Make

Table of Contents

What is Artisan Console in Laravel

Artisan Console is a powerful command-line tool that is part of Laravel, a popular PHP framework. It allows developers to easily and quickly perform various tasks related to application development, from code generation to database management. Artisan is an essential tool for efficient and productive development in Laravel.

Overview of the 'Make' Command and Its Significance

The 'make' command in the Artisan Console is designed to generate various types of files that are commonly used in the development of Laravel applications. With this command, you can easily and quickly create controllers, models, migrations, tests, and many other components. The 'make' command significantly increases developer productivity by automating routine tasks associated with creating new files and classes.

Why the 'Make' Command is Important

  • It allows developers to quickly and consistently generate code, increasing efficiency and reducing the possibility of errors.
  • It boosts productivity by automating repetitive tasks, allowing developers to focus on the logic and functionality of the application.
  • It is flexible and allows developers to customize the generated files according to their needs.

Basics of the 'Make' Command

What is the 'Make' Command

The 'make' command is part of the Artisan Console in Laravel. It allows developers to generate various types of files that are necessary for the development of a Laravel application. This command is designed to automate and simplify the process of creating new components of the application.

How to Use the 'Make' Command

  • To use the 'make' command, open the terminal and navigate to the root directory of your Laravel application.
  • Enter php artisan make: followed by the name of the component you want to create.

Example of Use

Creating a new controller:

php artisan make:controller UserController

Various Options and Parameters

The 'make' command has various options and parameters that allow developers to specify what type of file they want to create and what properties it will have.

Table of Options and Parameters

Parameter Description
-m Creates a migration file for the model
--resource Creates a resource controller
--api Creates a controller for API
--factory Creates a factory for the model
--seed Creates a seeder for the model

Example of Use with Parameters

Generating a model along with the corresponding database migration:

php artisan make:model Post -m

Where to Find the Generated Files

After running the 'make' command, the newly created files are placed in the corresponding directories of the Laravel application. For example: Controllers are located in the app/Http/Controllers directory.

Generating Various Types of Files

Name Short Description
make:cast Generates a new custom Eloquent cast class
make:channel Creates a new channel class for broadcasting events
make:component Generates a new view component class
make:command Creates a new Artisan command class
make:controller Generates a new controller class
make:event Creates a new event class
make:exception Generates a new custom exception class
make:factory Creates a new model factory
make:job Generates a new job class for the queue
make:listener Creates a new event listener class
make:mail Generates a new email class
make:middleware Creates a new middleware class
make:model Generates a new Eloquent model class
make:notification Creates a new notification class
make:observer Generates a new observer class
make:policy Creates a new policy class
make:provider Generates a new service provider class
make:request Creates a new form request class
make:resource Generates a new resource class
make:rule Creates a new validation rule class
make:scope Generates a new Eloquent query scope class
make:seeder Creates a new seeder class
make:test Generates a new test class
make:livewire Creates a new Livewire component
make:migration Creates a new migration file

This table provides a quick reference guide for the various types of files that can be generated using the make command in Laravel's Artisan Console. Each row in the table represents a different make command, along with a short description of what that command is used for.

Working with Templates (Stubs)

What Are Templates (Stubs)

Templates, known as stubs, are file templates that Artisan uses when generating new classes and files. Essentially, they are predefined code templates that Laravel uses as a basis for generating new files.

How to Use Templates

When you use the make command, Artisan automatically uses the corresponding template to generate a new file. However, you can also modify these templates according to your needs.


If you want to modify the template that Laravel uses to generate new controllers, you can find the corresponding template in the directory: vendor/laravel/framework/src/Illuminate/Routing/Console/stubs

Customizing Templates

Laravel allows for the publishing and customization of these templates. After publishing the templates, you can edit their content according to your needs.

How to Publish Templates

  1. Run the following Artisan command:
    php artisan stub:publish
  2. This command will copy all the templates to the stubs/ directory in your application's root directory.
  3. Now you can edit these files according to your needs.

Why Customize Templates

Customizing templates allows you to define your own structure and content for the generated files. This is useful if you want all your generated files to have a consistent style and structure that aligns with your coding standards.

Advanced Techniques and Tips

Creating Custom 'Make' Commands

Laravel allows you to create custom Artisan commands, including custom 'make' commands. This is useful if you need to generate specific types of files that are not included by default in Laravel.

How to Create a Custom 'Make' Command

  1. Create a New Command:
    php artisan make:command CustomMakeCommand
  2. Edit the Command File:
    • Open the newly created command file (e.g., app/Console/Commands/CustomMakeCommand.php) and set up the file generation logic.
  3. Register the Command:
    • Add the new command to the $commands array in the Kernel class in app/Console/Kernel.php.
  4. Now You Can Use Your New Make Command Just Like Any Other Artisan Command:
    • Use the Command: php artisan make:custom

Automating the File Generation Process

You can create scripts or Artisan commands that automate the file generation process to reduce the need for manual command input.

Example of Automation

Creating an Artisan command that automatically generates a model, controller, migration, and seeder all at once:

Artisan::call('make:model', ['name' => 'Post', '--migration' => true, '--controller' => true]);
Artisan::call('make:seeder', ['name' => 'PostsTableSeeder']);

Optimizing Templates for Teamwork

If you are working in a team, it is important to ensure that all generated files will have a consistent and expected structure. Customized templates can be saved in a version control system (e.g., Git) so that the entire team can use them.

Tips for Teamwork

  1. Share Customized Templates: Save them in a repository so that the entire team has access.
  2. Document Changes: When you modify a template, document what and why you changed it to make it clear for other team members.

Common Errors and How to Solve Them

Error: Class Already Exists

This error occurs when you try to create a class that already exists in the application.


  1. Check the Directory: Make sure that the class actually already exists by browsing the relevant directory.
  2. Rename the Class: If you need to create a new class with a different purpose, consider renaming the class to avoid a name conflict.

Error: Invalid Class Name

This error occurs if you enter an invalid class name when using the make command.


  1. Check the Syntax: Make sure that the class name is in the correct format. It should start with an uppercase letter and must not contain invalid characters.
  2. Use the Correct Command: Ensure that you are using the correct Artisan command to generate the desired type of file.

Error: Template Not Found

This error occurs if Laravel cannot find the required template (stub) for generating a file.


  1. Check the Template Directory: Make sure that all templates are in the correct place in the stubs/ directory in your application's root directory.
  2. Republish the Templates: If some templates are missing, try republishing them using the command:
    php artisan stub:publish

Error: Syntax Error in Generated File

This error occurs if there is a PHP syntax error in the generated file.


  1. Check the Templates: The error may be in the template that Laravel used to create the file. Check the template and correct the error.
  2. Check the Generated File: Open the generated file and locate and correct the PHP syntax error.


  • The make command in Laravel's Artisan Console is a powerful tool that significantly increases a developer's productivity by automating the process of creating new classes and files.
  • It allows for the generation of various types of files, from controllers and models to tests and migrations.
  • Templates (stubs) are a key part of this process and can be customized according to the developer's needs.
  • Common errors when using the make command are easily solvable and usually relate to class names, template locations, or PHP syntax.

The Importance of Effectively Using the 'Make' Command

Effectively using the make command can significantly improve a developer's workflow, enabling faster development and reducing the risk of errors by providing consistent and reliable ways of generating code. It is a tool that should be part of every Laravel developer's arsenal.

Recommendations for Next Steps

  • Explore More Artisan Commands: Laravel Artisan offers many other commands that can facilitate development. Try, for example, php artisan list to display all available commands.
  • Study Laravel's Documentation: Laravel's documentation is a rich source of information. Dedicate time to browsing through it and learn about the additional features that the framework offers.
5 / 5
Total votes: 3
You have not rated yet.
Pavel Zaněk

Full-stack developer & SEO consultant

Pavel Zaněk is an experienced full-stack developer with expertise in SEO and programming in Laravel. His skills include website optimization, implementing effective strategies to increase traffic and improve search engine rankings. Pavel is an expert in Laravel and its related technologies, including Livewire, Vue.js, MariaDB, Redis, TailwindCSS/Bootstrap and much more. In addition to his programming skills, he also has a strong background in VPS management, enabling him to handle complex server-side challenges. Pavel is a highly motivated and dedicated professional who is committed to delivering exceptional results. His goal is to help clients achieve success in the online space and achieve their goals with the help of the best web technologies and SEO strategies.


No comment has been added yet.

Add a comment

Suggested Articles

How to create RSS feed in Laravel framework

Published at 2023-08-10 by Pavel Zaněk

Estimated Reading Time: 10 minutes


Guide to creating RSS feed in Laravel framework without external packages. From basic principles to advanced techniques. Ideal for developers looking for an efficient and secure solution.

Continue reading

Your experience on this site will be improved by allowing cookies. - Cookies Policy