Building with AI in 2026: The Fundamentals (Terminal, Claude Code, Git, APIs, and Everything Else You Need to Ship)

If you read our first post, you already know the big idea: building with AI works, and the thing that separates shipped products from abandoned ones is a clear spec. That's the why.

This post is the what. Because the moment you open Claude Code for the first time, you're going to hear a lot of words — terminal, CLI, API, repo, hosting, framework, MCP — and if nobody's ever defined them for you, the whole experience feels like trying to read a map in a language you don't speak.

So this is the map. One read-through, and the rest of this blog will make sense. We're going to define every piece of the modern builder's toolkit in plain English, end with a concrete shopping list for shipping your first product, and move on.

No jargon for jargon's sake. No talking down. Just the vocabulary.

Start Here: Why the Vocabulary Matters

Every post we write from here on out is going to assume you know these terms. "Open the terminal." "Push to GitHub." "Add an MCP." "Deploy to Vercel." If those sentences feel like static, the advice won't land.

That's not your fault. The tech world has spent forty years building a vocabulary for itself and nobody ever bothered to translate it for the rest of us. So let's fix that.

Come back to this post any time a word feels fuzzy. It's meant to be a reference, not a one-time read.

The Terminal: Your Direct Line to the Machine

Your computer has two faces.

The one you've used your whole life is the graphical interface — windows, icons, folders, buttons you click. Nice for humans. The other face is the terminal — a text window where you type commands and the computer does them directly. No clicking, no dragging, just words in and work out.

On a Mac, it's the app called Terminal. On Windows, it's PowerShell. Both do essentially the same thing.

The first time you open one, it looks like a hacker movie. A blinking cursor, maybe your username, a dollar sign or a prompt arrow. That's it. You type something, hit Enter, and the computer responds.

The terminal is not a special thing reserved for programmers. It's just a more honest way to give your computer instructions. And for one very specific reason, it matters more than ever right now: it's where AI development tools live. Claude Code, Git, package installers, deployment tools — they all run in the terminal, because the terminal is the universal environment for software that talks to other software. No app wrappers, no menus, just direct access.

If you've never opened a terminal before, here's your assignment: do it once. Press Cmd + Space on Mac and type "Terminal." Click it. Type `echo hello` and hit Enter. Watch it print "hello." You just used the command line. You're fine.

Command Line Tools (CLIs): Single-Purpose Programs You Type At

Every command you run in the terminal is a CLI — a "command-line interface." That's just a fancy way of saying: a program with no windows, just a keyboard.

Here are the CLIs you'll meet on almost every project:

• `git` — tracks changes to your code (more on Git in a minute)


• `npm` — installs JavaScript packages (little bundles of other people's code)


• `curl` — downloads stuff from the internet


• `claude` — starts Claude Code

Each one does one thing well. Stacked together, they're how every modern product is built.

Claude Code is itself a CLI. That's not a small detail. Because Claude Code lives in the same terminal as `git`, `npm`, and everything else, it can use them. When you tell Claude "install this package," it runs `npm`. When you say "save my progress," it runs `git`. When you ask it to test an API, it runs `curl`.

One assistant, operating your entire toolbox. That's the superpower the terminal unlocks. A website builder can't do this — it lives inside a browser tab, sealed off from your actual machine. Claude Code sits in the same room as every tool you'll ever use.

APIs: How Software Talks to Software

An API — Application Programming Interface — is a structured way for one program to ask another program for something.

The cleanest analogy is a waiter at a restaurant. You don't walk into the kitchen and start opening fridges. You tell the waiter what you want, the waiter carries the order back, and your food shows up. The waiter is the API.

The modern internet is APIs all the way down. Stripe's API handles payments. Twilio's API sends SMS. Google Maps' API shows maps. The Anthropic API runs Claude. You don't build any of these from scratch — you call their API and get the capability.

Two terms you'll hear constantly that confuse new builders:

• The Claude API is the raw door. Programs send text, get text back, billed by the word. It's what your code calls when you want to embed AI inside a product you're building.


• Claude Code is a CLI (remember those?) built on top of the Claude API. It wraps the API into a ready-to-use AI engineer that runs in your terminal. You pay a Max plan subscription, not per-word.

Rule of thumb: If you're building a product, use Claude Code. If you're building something inside a product that needs AI (a chatbot in your app, an AI-powered feature), you call the Claude API from your own code.

Databases and Hosting: Where Your App Remembers and Where It Lives

Every real app needs two pieces of infrastructure. Knowing them by name changes how the rest of the stack feels.

A database is where your app remembers things. User accounts, orders, messages, logs — all of it lives in a database. Think of it as an intelligent spreadsheet that other software can read and write very fast, safely, and at scale.

• Postgres is the industry default. Runs everywhere, handles almost any workload.


• SQLite is a tiny, file-based database — great for lightweight apps and prototypes.


• Supabase is Postgres that someone else runs for you, with auth and APIs bolted on. A popular starter choice.

Hosting is where your app actually lives on the internet. Your laptop isn't reachable from Ohio, Singapore, or your mom's phone. A hosting platform is.

• Vercel is the easiest way to ship a Next.js app. Free to start. Most first products go here.


• Netlify is similar, tuned for static marketing sites.


• Google Cloud Run is for serious production apps — it runs the container your product lives in and scales automatically. Pilotship's stack defaults here for client work.


• AWS is the biggest, most powerful option, and also the most complicated. Probably not your first choice.

The mental model: the database is the filing cabinet, hosting is the office building. Every app needs both.

Languages and Frameworks: The Building Blocks

A language is the syntax code is written in — TypeScript, JavaScript, Python, Go, Rust. A framework is a pre-built structure that handles the boring parts of a project (routing, rendering, authentication plumbing) so your developer doesn't start from zero every time.

For web and mobile products, our default stack is:

• TypeScript — the language. JavaScript with guardrails that catch mistakes before your users do.


• React — the UI library. The industry-standard way to build interfaces.


• Next.js — the framework. Sits on top of React and handles the things every serious web app needs.


• React Native + Expo — for mobile. Lets you ship to iOS and Android from one codebase.

For AI-heavy work — data pipelines, model fine-tuning, research tooling — we reach for Python, because the AI ecosystem lives there.

Here's the important part: you don't have to pick these yourself. Claude Code, given a good spec, will pick them for you. But you should know the names when they come up, so when Claude says "we'll build this in Next.js with a Postgres database," you're not nodding along blindly.

Git and GitHub: Time Travel and Teamwork

These are two different things people constantly smash together. Let's split them apart.

Git is the software that tracks every change you make to your code. Every save is called a commit, and every commit gets a timestamp, an author, and a short message. You can jump backward to any point in history. You broke something? Git can undo it. Exactly.

GitHub is a website where your Git history lives online. Think of it as Google Drive for code, with superpowers. It's where your code gets backed up, where teammates collaborate, and — crucially — where your hosting platform pulls your code from when it's time to deploy.

Three words you'll hear constantly:

• Repo (short for repository): a project's full code and history. Every app is a repo.


• Branch: a parallel version of your project. You make a branch to try something new without touching the main version.


• Pull request (PR): "I've done some work on this branch — want to merge it into the main version?" It's how teams review each other's changes before they go live.

Why this matters with Claude Code: every change Claude Code makes is a commit. If you don't like where something is going, Git lets you roll back. That safety net is exactly what lets you move fast without fear. It's also why Pilotship's first rule for every client build is everything through a pull request — so nothing ships without eyes on it.

MCP: How Claude Reaches Beyond the Terminal

MCP stands for Model Context Protocol. It's Anthropic's standard for letting Claude connect to tools outside of the terminal.

Here's why it matters. Claude Code is already powerful inside your project folder — it can read your files, run your commands, write your code. But most of your work lives elsewhere. It lives in GitHub, in your database, in your project tracker, in your documentation. MCPs are the plug that lets Claude reach into all of it.

Real examples you'll meet:

• GitHub MCP — Claude can read PR comments, open issues, merge branches, all without leaving the chat.


• Database MCPs (Postgres, Supabase) — Claude can query your database to understand what data actually exists before writing code against it.


• Linear MCP — Claude can read your tickets and implement them directly.


• Web search MCP — Claude can look things up on the live internet.

The effect is dramatic. Claude Code stops being "a tool that writes code" and becomes "a teammate that operates your whole stack." You don't need to set any of this up on day one — start with just Claude Code. But the moment you plug in your first MCP, the ceiling on what Claude can do moves up by an order of magnitude.

We'll do a full post on which MCPs are worth installing first. Consider this the teaser.

The Starter Toolkit: What You Actually Need to Ship

Enough definitions. Here is the actual shopping list for shipping your first product with AI in 2026:

1. Claude Code — your AI engineer. Install is one terminal command (full walkthrough in the first post). Start on the Max plan — Pro hits its ceiling too fast on a real build.
2. A GitHub account — free at github.com. This is where your code lives and where your hosting platform will pull from.
3. A hosting platform — Vercel is free to start and will ship most first products painlessly. You can graduate to Google Cloud Run when you outgrow the free tier or need a custom backend.
4. A domain name — optional on day one. Around `$12/year` at Namecheap or Cloudflare. You can launch on a free `.vercel.app` URL and wire up a custom domain later.
5. A spec — the single most important item on this list. Build one for free in 10 minutes at Mission Control.

The end-to-end flow for going from nothing to a live product:

1. Open your terminal.
2. Make a project folder (`mkdir my-app && cd my-app`).
3. Start Claude Code (`claude`).
4. Hand it your spec. Let it build.
5. Create a GitHub repo. Claude can do this for you.
6. Connect your GitHub repo to Vercel. One click.
7. Click deploy. Your app is live on the internet.

The whole loop — from idea to live URL — can happen in a single day once you know the pieces. That's the point. That's what this post exists to unlock.

Where We Go From Here

This post is the foundation. From here on, we'll go deeper on each piece individually:

• Setting up GitHub from zero, for people who've never touched it


• Choosing the right hosting platform for your specific product


• The MCPs worth installing on day one


• Claude Code power-user moves most founders never learn


• When to use the Claude API directly instead of Claude Code

Bookmark this page. Come back the moment a word feels fuzzy. The whole point of a 101 is that you don't have to remember everything the first time.

Ready to start?

Build your spec at Mission Control — free, 10 minutes, no signup →

Then open your terminal, type `claude`, and let's ship something.

---

Phil Thornton is a co-founder of Pilotship.io — we help founders and business owners turn ideas into real products with AI. Questions about any of the above? Get in touch.