---
title: 'NEW Laravel 13 For Beginners: 30-Minute Crash Course'
source: 'https://youtube.com/watch?v=0WulLe5q4Rw'
video_id: '0WulLe5q4Rw'
date: 2026-06-14
duration_sec: 1841
---

# NEW Laravel 13 For Beginners: 30-Minute Crash Course

> Source: [NEW Laravel 13 For Beginners: 30-Minute Crash Course](https://youtube.com/watch?v=0WulLe5q4Rw)

## Summary

This video presents a new 30-minute crash course on Laravel 13 for beginners, focusing on fundamentals through three demo projects generated with AI. The instructor emphasizes understanding concepts over writing code, reflecting the 2026 developer workflow where AI generates code and developers review it.

### Key Points

- **Course Introduction and Philosophy** [00:00] — The course is a new style for 2026, shortened to 30 minutes. It uses AI-generated demo projects to teach fundamentals, as developers will increasingly rely on AI for code generation.
- **Three Demo Projects Overview** [01:35] — Project 1: Landing page with routing, controllers, views. Project 2: Blog with database, models, migrations. Project 3: CRUD with authentication using starter kits.
- **Project 1: Landing Page Setup** [03:18] — Uses Laravel Herd for local environment. Laravel new project wizard with options: starter kit (none for public site), testing (Pest), database (SQLite), frontend compilation (yes), Laravel Boost (default).
- **AI Prompt for Landing Page** [06:40] — Uses Claude Code to generate a landing page for a fictional startup. The AI creates routes, controllers, and Blade views. Key concepts: routes/web.php, controllers, Blade templates with layouts and sections.
- **Project 2: Blog with Database** [10:30] — New project with MySQL database. Configures .env file for database credentials. Shows migrations for users table, then uses Claude Code to generate blog with categories and posts.
- **Eloquent Models and Relationships** [13:15] — Models represent database tables. Category hasMany Posts, Post belongsTo Category. Factories and seeders generate fake data. Route model binding automatically fetches model by URL parameter.
- **Project 3: Starter Kit and CRUD** [19:32] — Uses Laravel new with LiveWire starter kit for authentication. Claude Code generates full CRUD for categories and posts with resource controllers, form requests for validation, and Blade views.
- **CRUD in Action** [24:55] — Demonstrates listing, creating, editing, and deleting categories and posts. Uses route resource for automatic routing. Middleware protects routes with auth. Redirects with success messages.
- **Conclusion and Next Steps** [29:54] — The three demo projects are on GitHub with original prompts. Encourages viewers to dive deeper into specific topics like APIs, other starter kits, or automated testing on Laravel Daily.

### Conclusion

This crash course provides a high-level overview of Laravel 13 fundamentals using AI-generated projects, preparing beginners to understand and review code rather than write it from scratch.

## Transcript

Hello guys, what you will see in this
video will be a course, a new course on
Laravel Daily, Laravel 13 for beginners.
And this is a new kind of style of
courses. I thought how to proceed with
courses in 2026 because no one has time
for that to watch two-hour courses or
longer. So I shortened it massively. And
I need your opinion if you watch that
course. This is free on YouTube or you
may want to watch it on Laravel Daily by
lesson. The idea is this. We work on
specific demo projects. And the goal is
to show a realistic project, very
simplified design-wise, but realistic
project generated by AI because I think
that many developers will not write the
code by hand in 2026 and beyond. But we
need to understand the fundamentals. So
I will have three projects generated
with prompts in cloud code. But then I
will go and explain step by step the
fundamental concept that people would
need to know when learning Laravel. So
they need to understand the fundamentals
the pieces not necessarily the deeper
syntax because you can prompt AI for
that now. So I think even with the age
of AI people will still need courses but
they should be much more densed much
more practical and using AI pretty
heavily like we all do in 2026. So this
is my attempt. Please watch and share
your opinion. It matters a lot to me
when thinking about how to proceed with
other course updates for Laravel 13 on
Laravel Daily. Now, let's dive into the
course itself. Hello guys, welcome to
this course about Laravel 13 for
beginners for someone who haven't tried
Laravel at all. In this crash course in
30 minutes, I will try to explain the
fundamentals of how Laravel works and we
will create three demo projects in those
half an hour. I will show you the
example of a simple landing page with
just home about and contact us. So we
will learn about how routing works,
controllers and views. Then the second
project will be a blog with posts and
categories. And then you will find out
about how database works and how to get
the data from the database. And then the
third project we will use one of the
Laravel starter kits and we will create
resource CRUDs resource controllers and
validations and forms with authenticated
users. I think this will cover the
fundamentals of what you need to know
about how Laravel works as an overview
and we will also heavily use AI. I will
prompt cloud code to generate that code.
This is what I fundamentally believe in
in 2026 as developers. Now we need to
learn to read and review the code not
necessarily write the code. So this is
exactly what I want to mimic in this
course. Quite a lot of you will not
write the code. You will ask AI agents
to generate the code but then you still
need to understand at least on
conceptual level. You may not know some
of the syntax and you may prompt AI for
that. But this is exactly what I think
the job of a developer will be in 2026.
So this is the premise of this course
for you to understand Laravel project,
the structure and the main types of
projects you would create with Laravel.
Let's dive in. Let's start by creating a
new Laravel project and I will show you
the installer the wizard of Laravel new
project and what choices you may want to
make. Before starting with Laravel, you
need to have software on your machine
for PHP. So according to the official
documentation, there are two ways.
either you have prepared commands for
operating systems or my personal
favorite recommendation is to install
Laravel herd. So that is a software that
will install everything you need on your
machine. You can download it at
herd.laravel.com.
And then here I am in my herd folder and
I launch Laravel new project. And what
are the choices? Laravel has starter
kits but they are optional. It depends
on what kind of projects you want to
create. And by starter kit it means
authentication mechanism. So if you
choose any of those reacts view or
liveware wireware you would get
something like this homepage with login
and register buttons. So I will use fake
filler chrome extension and this is what
you would see inside with the starter
kit the dashboard and then settings to
change your security or appearance or
profile. So that's if you want to create
a project with authentication. But if
you want to create a simple public
website like a blog or API project then
you don't need the starter kits and you
may choose none. We'll get to starter
kit project in the third example of this
course. Which testing framework do you
prefer? I recommend best which is now
the default in Laravel Laravel boost.
This is pretty important in AI agent
era. I recommend you stick with yes. and
then Laravel boost will prepare your
project with guidelines and skills for
AI agents. The next question of the
wizard is to choose the database. This
is your personal preference what you
use. By default, it's SQLite which means
you don't need to install anything
specifically. SQLite is just a file in
your folder of the project. The next
question is compiling the front end. Do
you want to compile right now npm
install and npm run build? because the
default framework homepage comes with
tailwind already prepared and I've
chosen yes and then the final part is
configuring Laravel boost. So what
skills and guidelines for which AI
agents do you want? For the first
attempt I will advise to stick with the
default. So you may choose guidelines
skills and boost configuration. Do you
want her MCP for starters? You probably
don't. And then choose which AI agents,
which IDEs you use. For example, I can
untick cursor Gemini and open code. And
then it will install the scales and the
guidelines only for claude code and
codeex which means claude.md file and
agents.mmd file. And that's it. That's
all the installation. And now we can do
project.est
which is powered by my Laravel herd. And
yeah, this is the Laravel 13 homepage.
And if we open that project in VS code
or other IDE, the main thing where to
start is the list of routes, which in
this case is just one route of welcome
page. But instead of digging deeper into
default homepage, let's try to create a
very simple public page for a fictional
startup with AI because we are now
entering the error of fewer developers
would type the code manually and more
developers would read the code generated
by agent. So that's why I will
initialize the repository and commit
installed Laravel. And now I will launch
cloud code. So in the terminal clear cd2
project and then I launch cloud code
with dangerously skip permissions. I
have alias for that. And I will launch
this prompt for project number one in
this project. The first demo landing
page for fictional startup with a few
pages to demonstrate the routing and how
the pages generally work in Laravel for
public facing website. As you can see,
cloud code catches the skill of tailwind
CSS development. That's why Laravel
boost was important. Okay, we're done in
1 minute and 23 seconds. And let's click
that. And we have the homepage of
fictional startup with very minimal
design, but that's intentional. We're
talking about Laravel here, not that
much about Tailwind. So let's see what's
inside the code. So the main file
listing the pages of the website is
routes web.php. So if you navigate here
about and contact us, then the URL
changes and that is powered by this
file. So these are the URLs and these
are the controller methods that power
those pages. Controller is a class in
Laravel that gets the data from the
routes from the URL from the parameters.
then transforms that data if needed and
then passes that data to so-called blade
file. This is the classical so-called
MVC approach model view controller.
We'll talk about models and the data a
bit later but for now you need to
understand routing then controllers.
Each controller method is responsible
for separate page but it may be separate
controllers as well. This is your
personal preference. And then each
controller returns home which
corresponds to the file in
resources/views
folder in this case home blade. Blade is
Laravel templating language. So HTML
with some constructions on top. So for
example for each loop looks like this
with blade. So blade directives start
with at at if at for each and others
also you see tailwind classes here and
some variables. So this is how you
define the variable in blade and that
variable come from the controller. So
this array those keys become the
variable in blade also to have separate
pages using the same layout. This is how
it looks. There are two ways to do that
in Laravel. I will show you one of them.
So extends layouts app. This is the main
HTML for the full page. And then we have
yield content which becomes in homelade
section content. And then if we open
resources views about blade for example
extends layout then another section and
then section content which is different
for every page and that title about is
another section here on top yield title.
So this is how you do with templates and
same layouts for different pages. A few
more important things. If you want to
have a link to some kind of URL, you may
reference route home, route about and
route contact by their names in routes
webph. Each route may have optional name
which is a good practice to have the
name instead of URL because URLs may
change. And another thing with the front
end I mentioned that Laravel comes with
Tailwind 4 preconfigured by default with
V server. So this is the line that
ensures that npm install and npm run
build or npm rundev compiles the assets
accordingly and in the package json file
you may see tailorent here already
installed with vit as well. So that's
basically all you need to know to create
simple public websites with laravel
routing controller methods and blade
views. Now I will show you the second
project demo and this will be the prompt
again with AI for that blog with data
from the database and again I start with
Laravel new project and the same wizard
with the same choices as the first
project except for database. I will
choose my SQL and this is the point I
will show you how to configure MySQL in
Laravel. And then the question from the
wizard do you want to run default
database migrations? So, Laravel comes
with a few database tables preconfigured
in so-called migrations and you may run
them right away if you have your MySQL
database ready. But even if you haven't,
it will create it for you. So, it tries
to find the same database as project
name and would you like to create it?
Yes. I have MySQL local server with
default credentials which is root
database user and no password. And this
is exactly the defaults from Laravel.
again npm install and npm run build and
other defaults. Then the installation is
done and we're opening the project in
IDE and we look at the file very
important file envolder.
So this is where you configure a lot of
main things about the project like app
URL for example powered by Laravel herd
automatically and the database. These
are again my default credentials for
MySQL. may be different on your machine
but this is exactly where you provide
the credentials database username and
password important part thatv should be
very secure on your local machine and do
not push it to any repository on the
server there should be anotherv file
with the credentials for server database
and server parameters but the security
rule is that this file should be get
ignored and never in a public repository
because well it contains all the path
passwords. And now if we open our
database, we see already some tables
like for example users table. This is
the structure and a few more tables. And
this is powered by actually the same
thing of database migrations that we saw
earlier in the installation. So create
users table. This is how you define the
database structure in Laravel migration
file with fields inside strings
timestamps and others. And then if you
want to transform the structure to the
actual database, you run artisan
command. PHP artisan migrate. Laravel is
full of commands. PHP artisan something.
So for example, migrate will execute the
migrations. But in this case, it's
nothing to migrate because we already
have those database tables. But if for
example, we delete all of them and rerun
those migrations again, it will execute
those migrations. And if we refresh,
those tables are here again. So this is
how database structure works in Laravel.
And now we open again cloud code and
prompt to create a simple blog which
would take the data from the database.
And this is exactly what I want to show
in this lesson. As you can see cloud
code AI agent is running PHP out
command. So there's make model make
controller. We'll talk about models in a
minute. This is exactly [clears throat]
what is powering specific database
table. And let's actually watch it in
action. So it creates the migrations for
categories and post tables. Then it
creates the model. So we can actually
talk about it now. Model is a class that
powers the work with specific database
table. So category is for plural form of
categories database table. Then you
define the fillable fields. What fields
do you want to work with? And then you
define relationships between the tables
between the models. So category has many
posts. This is one to many relationship
on the database level. And then the
other way around we have second model
post with set of fillable columns in the
database. Then we have relationship to
category which is the other way around.
There's has many and there's belongs to
table. And then also there's cast to
work with datetime specifically for
Laravel. I will not really stay on that
too much. Factory is about fake data and
about testing. And this is also outside
of scope of this course. But basically
every model may have factor with some
fake data just for testing. And then
there's cedar which may use those
factories to create that fake data. So
this is the cedar for fake or semi-fake
categories. And this is the cedar for
post. So we will have 10 posts each with
random category. And then we have the
main file called database cedar that
basically seeds all database. So you
call whatever cedars you want. And
probably somewhere down below the agent
executed command not only PHP artisan
migrate for the database but also
artisan DB seed to actually seed that
data. And as a result we refresh the
database and we have categories with
that data. And timestamps by the way are
automatic in Laravel with created at and
updated ad. if you use those eloquent
models and also posts again fake data
with random category ID here and
timestamps here and then if we take a
look at controllers so you saw the
controller for public website with
hard-coded data in this case we use
eloquent model which basically
represents the database table and then
we query so this is how you query the
database with Laravel with eloquent
models it's a lot of syntax options But
basically what you need to know is post
where and then pageionate or get
probably another query is more simple
for categories. So category this query
is optional then order by name and get.
So this is how you get all the
categories from the database. Also you
may specify with count of posts and then
again similar to previous lesson we
return blade view and pass the data
array. Blade views by the way may be
dotsarated or slppparated which means
subfolders in resources/views.
So we have one controller method for
post controller for index for the list
of posts and then show specific post and
then in the routes web again we have two
routes homepage and the post and then
the blade layout you already saw that
app blade with HTML then post index
extending layout with the content and
then we have all the variables here with
if with blade and with variables shown
with another transformation if needed.
Probably it's better now to switch to VS
Code and see the project or actually
let's click the project here. So project
2.est should be the URL here. And do we
have a blog? Yes, this is our result.
Again, very simplified in terms of
design intentionally. But what I wanted
to show you is list of blog articles
coming from the database. Then sidebar
here with a category ID which then
filters the list of blog posts. And then
if we go here, there's a slug of post
which shows the post details again with
the same layout similar to previous
project demo. And if we take a look at
the code now in VS code, I will just
briefly repeat what we saw already. So
migrations for categories and for post
important part is this line. Foreign ID.
This is how you define the foreign key
between database tables in Laravel. So
foreign id category id with constraint
to which table by default it's plural
name of category without underscore id.
So categories so this is how you define
the foreign keys. Then you already saw
factories and cedars. This is all in the
database folder of laravel project. And
then in the routes web in addition to
postcontroller index method we have
postcontroller show method with
interesting concept called route model
binding. So this is how you define the
parameter of the URL. If you have this
for example here the slug then you may
define the model name and the field to
automatically filter by and then in the
method of show you type hint the model
and then that object becomes the post
with all the fields from the database.
So that's called route model binding.
Very important concept and oftenly used
in Laravel. And then the other concepts
you already saw passing the data to
blade. In the blade we have if and
[snorts] sections and others some more
syntax options like in every framework
but in this course I don't want to state
too much on the details. I want to give
you the overview of how the things work.
So the main things that you need to know
for such project public website with
data from the database you need to know
the same routing controllers and blade
views and for the data you need to be
familiar with models database migrations
and if you want some fake data factories
and cedars and now I will show you the
third project with starter kit how does
it work if you want to have
authenticated users so in case of
laravel new we will choose one of them.
And if you are not a JavaScript
developer, so you don't want to learn or
use React View or Swelt, LiveWire is
your best bet. Even if you don't know
LiveWire, this is kind of a Laravel way
to have dynamic websites without
JavaScript. But you may choose LiveWire
Starter Kit and then continue using
Laravel controllers inside. This is
exactly what I want to show you. So kind
of the quickest way to start with
Laravel. So we choose Live Wire. We
choose Laravel's built-in authentication
for single file LiveWire components.
This is debatable for LiveWire users,
but I will choose no. I have separate
courses on LiveWire on Laravel daily
website. So, you may go into those
deeper. Again, we install Laravel Boost
and Laravel Boost with LiveWire starter
kit. It will also install Livewire
skills and guidelines if you want to use
LiveWire deeper. And again, we choose to
run npm install and npm run build. And
for Laravel boost, same thing but with
one new addition. So if Boost detects
that some third-party package has its
own guidelines, you may want to tick
that box or tick it off. So Laravel
Fortify is a first-party package, but
still it's a separate package for
authentication. And let's choose to
install those guidelines as well.
For everything else, it's the defaults.
But as you can see here there are skills
and guidelines for example for livewire.
Here we have livewire development as a
skill and also flux library is part of
livewire. So this is the example how
Laravel boost guidelines and claude MD
and agents MD and skills depend on the
packages of Laravel ecosystem that you
choose during installation. But of
course you may add more in the future on
top but this is outside of this course.
So now we have the project we may go to
that in browser. We may register in this
case we have escalite database. We
create an account and we have empty
dashboard. So we have a new user
registered authenticated and now we
build the functionality and again I will
prompt cloud code for this. I want to
build two cruds for same or similar
blog. So managing the categories and
managing the posts. So I want to show
you the forms, the validation, the whole
life cycle of so-called CRUD. So let's
prompt for that. This will be a bit
longer prompt. It will work probably for
5 minutes or so. So I will come back at
the end and comment the code step by
step or actually I thought it would be
beneficial to watch it in action and
again comment what it does like a
developer would write that manually. So
first again we have the database make
model make controllers and make
requests. So this is a new thing for
form requests. We will have the
validation files and I will comment on
them in a minute. So it generated the
files with PHP artisan make something
commands. Again as I said there are a
lot of PHP artisan commands and then it
fills the files with exactly the fields
in migrations. The model again this is
how you see the same things for the
second time. It's kind of repeating. So
then the factory for title and factory
for post data. Then cedar for five
categories. Cedar for three posts for
each category. You can kind of read it
in almost English language without even
knowing the exact syntax. Then in the
form request for storing the category we
will have validation rules and authorize
true means all authenticated users may
access that action. Similar update
category and store post request more
validation rules and also you may
specify different custom messages for
validation errors. And then the
controller for category controller you
will see in action so-called resource
controllers. So if you have the full
CRUD typically in Laravel there are
seven methods for that I will open the
official documentation of Laravel. So
basically these are the methods of
controller. So index to list the data
create for the form store to submit the
form then show individual record edit
that record the form update action and
delete action destroy. So this is
exactly what AI agent is generating. Now
for index we have list of categories
with the blade view again dotsepparated
for the folder. So there will be a
folder of categories and then separate
blade files for each page. Then store
method show and others. So this is for
the categories and then almost identical
structurally for the post. So this is
the crud how it works with Laravel and
after some action. Okay. So the agent
jumped to automated tests. The tests
will not be covered by this course. I
have separate courses on automated
tests. But it's great that AI agent runs
the test and ensures that the
functionality actually works including
Laravel Pint. There's Laravel Pint
package for code styling and we have the
summary. Now let's see how it works in
action and then we'll look at the code.
So if we refresh our dashboard now, we
should see categories here and I see the
styling off which means that the agent
didn't run npm install and npm run
build. And you can do that in cloud code
kind of a side tip by doing exclamation
mark. And then you can run bash commands
like npm install and npm run build in my
case. You can do npm rundev as well. And
now if we refresh the website, yep, we
have some styling. So this is the list
of categories. No categories found. And
now it's time to look at the code. So
these are the changes in git. Look at
how many files. So this was a bigger
change like five minutes for AI agent.
And if we take a look at category cedar,
we do have category cedar and post
cedar, but the main database cedar was
not changed. So this is how the main
database looks by default in Laravel
demo user with test example.com. So in
this case let's manually add this call
or actually VS code will autocomplete
that or actually we don't need the
default C. So let's comment that out.
And now we can open the terminal here in
VS code and run PHP artisan DB seed. And
now if we refresh the page yep we do
have demo categories. So this is how our
CRUD works. We can add a new category.
We can edit any category dot dot dot and
we can delete probably with confirmation
indeed. So that's how it works. For the
post, there should be probably a
drop-down for category. Yes. So the list
of categories is passed to the create
form of post and let's see that in the
code. So in the routes web we see a bit
more code than in the projects before
because it's starter kit and we have
so-called middleares. So middleware in
Laravel is a way to protect the route or
route group in this case with some kind
of rules and the most popular one is O
and also verified means email verified
which may or may not be enabled in the
user model that's a separate topic and
the dashboard is powered by default
starter kit and these are our routes
it's not route get this is what I meant
by resource controller it's route
resource and then automatically that
route resource
powers all those seven methods that I
mentioned. So index, create, store,
edit, update, and destroy only show
method is missing because it's not
needed in the CRUD. With this, you
basically saw it all in action. So
controllers and blade views are not new
to you. What is new is store method. So
to create the data in the database, we
use the same eloquent model category
create and then we pass the array. The
array may be just key and value but also
request validated means that the form
was actually validated. And this is
where we have those form request
separate classes that you saw already by
AI agent. So these are validation rules
and only those fields are passed to the
model to create the actual record in the
database. And then after you store you
return not the blade view but you return
redirect to wherever you want to the
route name which is automatically by the
way assigned again in the resource
controller. Automatic route names are
these. So resource name and
thenindex.create
and others. So you redirect to that page
with success message that is then shown
in the blade with edit category you see
the same route model binding we
discussed earlier in the previous
project and by default that route model
binding if you don't specify the slug
it's by ID field by primary key so if we
go to categories and click edit the
parameter is / one/edit which is
automatically parsed by laravel
controller with route model binding and
also you see compact here. This is a PHP
function to avoid key and value pairs if
they are repeating. It's just kind of a
shorter way to do the same array. And
then other eloquent model operations is
category update and category delete,
which basically means exactly what the
name says, update or delete the record
in the database. So that's basically all
you need to know to create such CRUDLike
projects with Laravel. So choose the
starter kit. Livewire is the quickest to
start with if you don't want JavaScript.
And then inside you create routes,
controllers, resource controllers in
this case, the same blade views with
Tailwind, the same eloquent models for
operations with the database and form
request for validations. And as you saw
throughout all the scores, you can ask
AI agent to generate a lot of those
things, at least the first version. So
for all of those three demo projects I
will not only put them on GitHub but
also in that repository I will put the
original prompts in markdown so you may
understand the origins better where do
those things come from and how they were
prompted. So yeah, this is where I want
to end this course because I think you
have enough of the overview of the
concept understanding about Laravel
fundamentals and then you may want to
dive deeper into separate topics of how
Laravel works with APIs for example,
what are other starter kits on how
Laravel works with React View or
Livewire, how automated testing works
and a lot of details. We have the
courses about that on Laravel daily
website. So browse around and choose
which projects you want to dive deeper
into. But for now, that's it for this
time and see you guys in other