Setting Up Your Environment with AI's Help

Here's a dirty secret about learning to code: getting your development environment up and running is often the hardest part. Not because it's conceptually difficult, but because it involves a lot of moving pieces, version numbers, operating system quirks, and configuration steps that nobody warned you about. Many beginners have quit before writing a single line of application code, defeated by an error message during setup.

This chapter is where AI really earns its place as your learning companion. We're going to install everything you need — PHP, Composer, Node.js, and a full Laravel project — and at every step we'll use AI not just to follow instructions, but to understand what we're actually doing and why. By the end of this chapter, you'll have a working development environment and — more importantly — the skills to troubleshoot your own setup when things go sideways.

And they will go sideways, at least a little. That's completely normal. Let's talk about that first.

Errors Are Part of the Process

Before we install a single thing, let's reframe how you think about error messages. For most beginners, an error message feels like a failure. The terminal turns red, something goes wrong, and the instinct is to panic or give up.

Professional developers feel the opposite. An error message is information. It's the computer telling you exactly what went wrong, in what file, on what line. A blank screen with no feedback is the scary thing — errors are your friends.

With AI in your toolkit, error messages become even less intimidating, because you have an expert on call who can read them with you. The skill we're building in this chapter isn't just 'follow these steps.' It's: when something doesn't work, here's how to figure out why.

What We're Installing and Why

Before we open a terminal, let's understand what our development stack actually consists of. This is the kind of context that AI is great at providing — but it's worth having a clear mental map before you dive in.

PHP

PHP is the programming language we'll write our application code in. It runs on the server — meaning it executes on your computer (or eventually a web server), not in the user's browser. When someone requests a page from a PHP application, PHP processes the logic, talks to the database if needed, and sends back HTML to the browser.

Composer

Composer is PHP's package manager. Think of it as an app store for PHP code — it lets you download and manage libraries that other developers have written. Laravel itself is installed via Composer, as are most of the tools you'll add to your projects.

Node.js and npm

Even though we're building a PHP application, we need Node.js installed for Laravel's frontend asset pipeline (Vite, which compiles your CSS and JavaScript). You won't write much Node.js code yourself in this book, but it needs to be present.

Laravel

Laravel is the PHP framework we'll build everything in. It's not a separate program you install globally — each project you create gets its own copy of Laravel, managed by Composer.

A local development server

To see your application in a browser, you need a web server running locally on your machine. Laravel includes a simple built-in server for development, and we'll also look at Laravel Herd — a beautiful desktop application that manages your local environment with almost no configuration.

Option A: Laravel Herd (Recommended for Beginners)

If you're on macOS or Windows and you want the fastest path to a working environment, Laravel Herd is the answer. It's a free desktop application that installs PHP, a web server, and everything else you need in one click — no terminal commands, no version conflicts, no configuration files.

We recommend this path for most beginners, because it lets you focus on actually learning Laravel rather than fighting your development environment. Here's how to get it set up.

1. Go to herd.laravel.com in your browser and download the installer for your operating system.
2. Run the installer. Herd will install PHP and a local web server automatically.
3. Once installed, open Herd. You'll see a menu bar icon (macOS) or system tray icon (Windows). Click it and select 'Open Herd.'
4. In the Herd interface, you'll see a 'Sites' panel. This is where your local Laravel projects will live.
5. Open your terminal (Terminal on macOS, PowerShell or Command Prompt on Windows) and run:

You should see a PHP version number printed. If you do, Herd is working correctly. If not, paste the error into your AI assistant — Herd errors during installation are almost always either a permissions issue or a conflicting PHP installation, and both are easy to fix with a little guidance.

Option B: Manual Installation

If you prefer full control over your environment, or if you're on Linux, here's how to install everything manually. This path gives you a deeper understanding of what's happening, at the cost of more terminal work upfront.

Step 1: Install PHP

On macOS, the easiest way is via Homebrew — a package manager for macOS that works similarly to Composer but for system tools. If you don't have Homebrew installed:

Once Homebrew is installed, installing PHP is a single command:

On Windows, the recommended approach is to use a tool called XAMPP or to install PHP directly via winget:

After installation, verify PHP is available by running:

You should see something like 'PHP 8.3.x' (the exact version will vary). If you see a 'command not found' error, your system doesn't know where PHP is installed — this is a PATH issue, and it's one of the most common setup problems.

Step 2: Install Composer

Go to getcomposer.org and follow the download instructions for your OS — or ask AI to walk you through it:

Once installed, running this command should print Composer's version number:

Step 3: Install Node.js

Go to nodejs.org and download the LTS (Long Term Support) version. LTS versions are more stable and better supported than the latest release — always prefer LTS for development tools unless you have a specific reason not to.

After installation, verify both Node and npm (the Node package manager, which comes bundled with Node) are available:

Creating Your First Laravel Project

With PHP and Composer installed (either via Herd or manually), you're ready to create a Laravel project. This is a moment worth appreciating: with a single command, Composer will download Laravel and all its dependencies and set up a complete, ready-to-run application structure.

Open your terminal, navigate to the folder where you want to keep your projects (your home folder or a 'projects' subfolder works well), and run:

You'll see a stream of output as Composer downloads packages. This will take a minute or two. When it finishes, you'll have a new folder called my-first-app containing a complete Laravel installation.

Running Laravel for the First Time

Let's see it in the browser. Navigate into your new project folder and start Laravel's built-in development server:

You'll see output like this:

Open your browser and go to http://127.0.0.1:8000. You should see Laravel's default welcome page — a clean screen with the Laravel logo and version number. If you see that, congratulations: you have a fully working Laravel installation.

A Tour of the Project Structure

Let's open the project in a code editor and take a look at what Composer created. If you don't have a code editor installed, VS Code is the most popular choice and it's free — download it from code.visualstudio.com.

Open the my-first-app folder in your editor. You'll see something like this:

That might look overwhelming right now. Don't try to understand it all at once — you'll get familiar with each folder naturally as we build things. For now, just notice the big picture: there's a clear separation between your application code (app/), your configuration (config/), your database work (database/), your web-facing files (public/), and your templates (resources/).

This structure is intentional and consistent across all Laravel projects. One of the great benefits of using a framework is that when you look at someone else's Laravel project, you already know where to find things.

The .env File: Your Project's Secret Settings

Open the file called .env in the root of your project. You'll see a collection of key-value pairs that control how your application behaves. This includes things like your database connection details, your application name, and whether you're in 'debug' mode.

Notice that DB_CONNECTION is set to 'sqlite' by default in recent Laravel versions. SQLite is a file-based database — no server required — which makes it perfect for getting started. We'll work with this in Chapter 10 when we get to databases.

The .env file is deliberately excluded from version control (you'll see it listed in .gitignore). That's because it often contains passwords and API keys that should never be shared. Every developer on a project maintains their own .env file locally.

When Things Go Wrong: Using AI to Troubleshoot

Let's talk about the AI troubleshooting workflow in practical terms, because you'll use it constantly — not just during setup, but throughout your entire career.

The key insight is this: the quality of the answer you get from AI depends almost entirely on the quality of the information you give it. A vague question gets a vague answer. Here's what a good error report to an AI looks like:

One more thing worth knowing: AI tools sometimes give you a fix that works without fully explaining why. When that happens, follow up. Ask: 'That fixed it — can you explain what was causing the problem and why that fix worked?' Building understanding from fixes is one of the best learning habits you can develop.

Checking In: What You Now Have

By this point, you should have:

• PHP installed and accessible from your terminal
• Composer installed globally
• Node.js and npm installed
• A fresh Laravel project created and running at http://127.0.0.1:8000
• VS Code (or your preferred editor) open with the project
• A working mental model of the project structure

If any of those aren't in place yet, that's completely fine — use the AI troubleshooting workflow from this chapter to work through whatever's blocking you. The setup phase genuinely is the hardest part for many beginners, and getting through it is an achievement worth recognizing.

In the next chapter, we're going to focus on the most important skill in the AI era: reading and understanding code you didn't write. We'll take the Laravel welcome page you just saw in the browser and trace it all the way back through the framework to understand how it got there.

Next up: Chapter 3 — Reading Code You Didn't Write