Question 1

What is a terminal?

Accepted Answer

A terminal is a text window on your computer where you type commands instead of clicking buttons. On Mac it's called Terminal (or iTerm). On Windows it's PowerShell or Windows Terminal. When a tutorial says 'run this in your terminal' it means: open that app, paste the command, press Enter. The terminal runs things in a folder. The name of that folder is shown in the prompt. You can move to a different folder with the `cd` command (short for 'change directory').

Question 2

What is a command?

Accepted Answer

A command is just a word (or short phrase) you type and press Enter. The first word is the program you want to run. Everything after are 'arguments' or 'flags' that tell it what to do. Commands usually produce output (text that appears in your terminal) and either succeed silently or print an error. If you see red text, read it carefully — it often tells you exactly what's wrong.

Question 3

What is a shell? What are Bash and Zsh?

Accepted Answer

A shell is the program inside your terminal that actually understands your commands. Bash and Zsh are the two most common. On modern Macs, Zsh is the default. Older Macs and most Linux servers use Bash. They're almost identical for everyday use — commands like `cd`, `ls`, `git`, and `npm` work the same in both. You might see files called `.bashrc` or `.zshrc` in your home folder. These are scripts that run every time you open a terminal, usually to set preferences or add shortcuts.

Question 4

What is npm (or yarn, pnpm, bun)?

Accepted Answer

A package manager installs 'packages' — bundles of someone else's code — so you don't have to write everything yourself. Think of it as an app store for code libraries. npm comes with Node.js. Yarn, pnpm, and Bun are alternatives — they all do roughly the same job, usually faster. When you install a package, it gets saved to a `node_modules` folder in your project. The list of what you installed lives in `package.json`. Don't commit `node_modules` to git — it's huge and can be re-created from `package.json`.

Question 5

What is package.json?

Accepted Answer

`package.json` is the manifest file for a Node project. It lists the project's name, version, dependencies (packages you use), and scripts (commands you've given names to). If you see `"dev": "next dev"` in the scripts section, running `npm run dev` is a shortcut for typing `next dev`. You don't write `package.json` by hand from scratch — tools like `create-next-app` generate it for you.

Question 6

What is git and GitHub?

Accepted Answer

Git is a program that tracks changes to your files. Every time you 'commit', git takes a snapshot of your project. You can go back to any previous snapshot, which is huge when you break something. GitHub is a website that stores git projects ('repositories' or 'repos') online. It's where you share code with teammates and where services like Vercel pull your code from. The basic flow: you change files → `git add` to stage them → `git commit` to save a snapshot → `git push` to upload to GitHub.

Question 7

What are environment variables and .env files?

Accepted Answer

Environment variables are secrets and config values that live outside your code — things like API keys and database URLs. You never want those committed to GitHub. A `.env` (or `.env.local`) file is a text file in your project where you put one KEY=value per line. Your app reads from this file at runtime. Add `.env` and `.env.local` to a file called `.gitignore` so git ignores them and they don't end up on GitHub. Most starter templates do this for you.

Question 8

What does 'localhost' mean?

Accepted Answer

`localhost` is your own computer. When you run `npm run dev`, your app starts a tiny web server on your machine. You visit it in your browser at `http://localhost:3000` (or sometimes 5173, 8080, etc. — the number is the 'port'). Only you can see localhost — nobody else on the internet. To show your work to others, you deploy (to Vercel, Netlify, etc.) and get a public URL.

Question 9

What's the difference between frontend and backend?

Accepted Answer

Frontend is everything the user sees in their browser — HTML, CSS, images, buttons. This is what React, Vue, or Svelte build. Backend is the code that runs on a server — handling logins, talking to the database, sending emails. The frontend talks to the backend over the internet using HTTP requests. Some frameworks (Next.js, Remix, Rails) bundle both together in one project so you don't have to think about them separately.

Question 10

What is an API?

Accepted Answer

API stands for Application Programming Interface. In web terms: it's a URL you hit that returns data instead of a webpage — usually in JSON format. Example: `https://api.github.com/users/torvalds` returns JSON describing Linus Torvalds. Your frontend 'calls' APIs (either your own backend or someone else's) to get data to display.

Question 11

What is JSON?

Accepted Answer

JSON (JavaScript Object Notation) is a text format for data. It looks like JavaScript objects: `{ "name": "Ada", "age": 36 }`. Almost every API on the internet speaks JSON. JavaScript can convert JSON into a usable object with `JSON.parse()` and back to text with `JSON.stringify()`.

Question 12

What does it mean to 'deploy'?

Accepted Answer

Deploying means putting your app on the internet so other people can use it. You go from `http://localhost:3000` (only you) to `https://your-app.com` (everyone). Modern platforms (Vercel, Netlify, Railway) deploy by reading your code from GitHub every time you push. The flow is: code → git push → automatic deploy → live site.

Question 13

What editor should I use?

Accepted Answer

Most developers use VS Code or Cursor (a fork of VS Code with AI built in). They're free and work with every language. Whatever you pick, install the extension for your language (Prettier for formatting, ESLint for catching mistakes). The editor + terminal is your workbench.

Question 14

What is TypeScript?

Accepted Answer

TypeScript is JavaScript with types. A type is an annotation that says 'this variable is always a string' or 'this function returns a number'. Your editor uses the types to autocomplete code and catch mistakes before you run anything. You don't have to type everything — TypeScript can often figure types out on its own. Files end in `.ts` or `.tsx` instead of `.js`/`.jsx`.

Question 15

How do I read an error message?

Accepted Answer

When something breaks, the terminal or browser console prints an error. Read it top to bottom. The first line usually tells you what went wrong (e.g. 'Cannot find module 'react''). The lines after show the 'stack trace' — where in the code the error happened. Copy the error message and paste it into Google — chances are someone else hit the same thing. Coding agents like Claude can also read error messages and suggest fixes if you paste them in.

Build your stack,one decision at a time.

Generate with AI

Start from a preset

Pick your stack

Frontend

Styling / UI & Animation

Backend

Compute / Hosting

Database

ORM / Query Layer

Auth

File Storage

Monitoring / APM

Product Analytics

Web Analytics

Transactional Email

Payments

AI / LLM

Search

CMS / Content

CI/CD

Public API catalog

Generate your blueprint