Class 1. How to Command AI — Vibe Coding Essentials

Quick Tips — Just Know This and You Can Command AI

Installing Claude Code is one line.

Open the terminal (the black screen) and paste this single line. That’s it.

To the agent: “curl -fsSL https://claude.ai/install.sh | bash”

Windows users need to install WSL (Linux environment) first. Run “wsl –install” in PowerShell and reboot.

5 Essential Keywords for Commanding AI

1. API — The protocol for programs to talk to each other. “Make an API”
2. Frontend — The visible screen. “Make a screen with React”
3. Database (DB) — Where data is stored. “Save it to the DB”
4. Commit — A save point of the current state. “Commit it”
5. Deploy — Putting it on the internet. “Deploy it”

These five words are enough to point a direction. AI figures out the rest.

AI’s Memory is Managed with 3 Files

• CLAUDE.md — Project rules. AI automatically reads this at the start of every session. Write “this is how our team works” here
• requirements.md — A record of your decisions. Write business decisions like “VIP discount rate 10%” with dates
• progress.md — Where things stand. Makes “continue where we left off” work in new sessions

All three files are Markdown. Anyone who can’t code can still read and write them.

Tips for Commanding AI

• Give one task at a time. “Make the login API first” is better than “Make login, registration, and the dashboard all at once”
• When errors occur, Claude Code automatically checks and fixes them. No need to copy-paste yourself
• When conversation exceeds 100 turns, AI quality degrades. Start a new session, but update those 3 files first

Hands-on Try

Install Claude Code and have your first conversation. It takes 5 minutes.

1. Create a project folder in the terminal and run Claude Code

To the agent: “mkdir -p ~/projects/my-first-app && cd ~/projects/my-first-app && claude”

2. Log in through the browser (only needed once)

3. Start your first conversation

To the agent: “Create a Go Gin server in this folder. One API that returns Hello, World on port 8080.”

AI creates the files, starts the server, and even verifies it. Open http://localhost:8080 in your browser.

Why You Need to Command This Way

You’ve already tried telling AI to make things with words. The screen appeared, buttons worked, data was saved. But one question probably remained.

“Is it really okay to keep growing this?”

To answer this question, you first need to see exactly where we stand. What tools exist, what words are exchanged, and what patterns we’re working with. Class 1 is the time to unfold the map. From Class 2 onward, we’ll carve paths on this map.

The Landscape of AI Coding Tools

Several tools write code when you tell them in words. They broadly split into two categories.

Editor-based tools — AI is attached inside a code editor.

Editor-based tools are optimized for fixing code while looking at it. Great for programmers. But for someone who doesn’t read code, the code on screen is meaningless text.

Terminal agents — AI judges and executes on its own in the terminal (black screen).

Terminal agents autonomously judge not just code editing but also command execution, test verification, and file creation. If you say “make a screen,” it creates files, starts a server, fixes errors if they occur, and verifies again. This autonomous verification loop is the decisive difference from editor-based tools.

Why Claude Code

This course uses Claude Code as its standard.

Claude Code currently excels at autonomously handling the most complex multi-file tasks among terminal agents. Tokens are the unit of text chunks AI reads. 200K (200,000) is about one novel, and 1M (1,000,000) is about five novels. Claude Code supports a base context of 200K tokens, with Opus 4.6 model supporting up to 1M tokens, allowing it to grasp an entire project at once and modify multiple files simultaneously. When you say “make this feature,” it finds related files, writes code, runs tests, and fixes errors in a self-repeating loop. Agent modes in editors like Cursor attempt similar things, but terminal agents are a step ahead in file exploration scope and depth of autonomous judgment.

What about Codex CLI? It’s OpenAI’s terminal agent with the same concept as Claude Code. The program itself was built quickly, and it’s accessible since it’s included with a ChatGPT subscription. However, I haven’t used it in production, so this course doesn’t cover it. Once you learn the principles of Claude Code, you can apply them identically to Codex CLI. Tools differ, but the methodology is the same.

Installing Claude Code

This course is based on an Ubuntu (or WSL) environment. Most commands also work for Mac users.

Prerequisites

1. Anthropic account: Sign up at https://console.anthropic.com
2. Subscription plan: Choose from Claude Pro ($20/month) or Max ($100/month or $200/month). Max has more generous usage limits
3. Ubuntu or WSL: Windows users should install WSL (Windows Subsystem for Linux) first

Windows Users: Installing WSL

Open Windows PowerShell as administrator and run the following.

wsl --install

This single line handles enabling the WSL feature, downloading the Linux kernel, and installing Ubuntu. After rebooting, Ubuntu automatically opens and asks for a username and password. Enter a short name in lowercase.

Note: All future work is done inside the Ubuntu terminal. Installing Claude Code from PowerShell or CMD will give a “Windows is not supported” error.

Method 1: Native Install (Recommended)

The simplest method that doesn’t require Node.js.

curl -fsSL https://claude.ai/install.sh | bash

Verify after installation.

claude --version

If a version number appears, you’re done.

Method 2: Install via npm

This method is for those who already have Node.js experience. If you’re new, use Method 1.

Use this when you already use Node.js or need version management.

Step 1 — Install Node.js (18 or higher required)

# Install nvm (Node Version Manager)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash

# Close and reopen terminal, or run this
source ~/.bashrc

# Install Node.js LTS
nvm install --lts

# Verify
node --version   # v22.x.x or above is OK
npm --version    # 10.x.x or above is OK

Step 2 — Install Claude Code

npm install -g @anthropic-ai/claude-code

Note: Do not use sudo npm install -g. It causes permission issues and security risks.

First Run and Authentication

# Navigate to project folder (create if needed)
mkdir -p ~/projects/my-first-app
cd ~/projects/my-first-app

# Run Claude Code
claude

On first run, a browser opens requesting Anthropic login. Once you log in, authentication is complete, and it connects automatically from then on.

WSL Tip: Always keep projects on the Linux filesystem (/home/username/). Placing them on the Windows side (/mnt/c/) makes file reading extremely slow.

Installation Verification Checklist

• Does claude --version output a version number
• Does running claude show a prompt
• Is authentication complete (browser login successful)

Keywords for Commanding — The Full Dictionary

Even without reading code, you need minimal keywords to command AI. You don’t need to learn all programming terminology. Just enough to point a direction.

No need to memorize now. The table below is a dictionary. Skim it once, and come back to look things up when AI says something you don’t understand.

Backend — The Invisible Engine

Programs on the server side that the user can’t see. They receive, process, store, and return data.

"Make an API with Go Gin"
"Make a backend with FastAPI"
"Make a Node.js Express server"

Frontend — The Visible Screen

The screen the user sees and clicks. Runs in the browser.

"Make a screen with React"
"Make a login page"
"Show the list as a table"

Database — The Memory Device

Where data is permanently stored. Data persists even when the server is off.

"Make a PostgreSQL database"
"Make a users table"
"Save it to the DB"

Deployment — Releasing to the World

The process of putting what you’ve made on the internet so others can access it.

"Deploy with Docker"
"Put it on AWS"
"Connect a domain"

Other Frequently Used Terms

You don’t need to memorize these terms. Even if you say “you know, that thing that saves data” when commanding AI, it’ll understand. But it helps to be familiar with these to understand what AI says back.

Now that you know the keywords, the next question is: do you have to explain all this to AI every time? Does AI remember previous work as the project grows? This is where context management enters.

Context Management — Handling AI’s Memory

If you ask what’s most important for AI, most people say “a smart model.” Wrong. Context.

Context refers to all the information AI currently remembers. What you said, what AI said, project files, rules — all of this is context. The problem is that this memory has limits.

AI Forgets

As conversations get longer, AI forgets what was said earlier. If you say “remember the login feature we made earlier?” and it asks “which login feature?” — the context has evaporated.

Opening a new session is a complete blank slate. The all-night conversation from yesterday evaporates. That’s why “continue where we left off” doesn’t work.

So what do you do? Externalize memory into files.

CLAUDE.md — The Project’s Constitution

CLAUDE.md is a special file placed in the project folder. Claude Code automatically reads this file at the start of every session. Without you explaining every time, AI knows the project rules from the start.

Think of it as a first-day morning briefing document for a new team member. “This is how our team works, this is what you shouldn’t do, and here’s the important stuff.”

Below is an example of what to put in CLAUDE.md. You don’t execute this now — you write it in the file and AI reads it every time.

# CLAUDE.md

## Project Overview
Todo list app. Go Gin backend + React frontend + SQLite.

## Commands
- `go run main.go` — Start server (port 8080)
- `cd frontend && npm run dev` — Start frontend

## Rules
- API responses are always JSON
- Error messages in Korean
- When adding new features, verify existing features aren't broken

## Structure
- `main.go` — Server entry point
- `internal/handler/` — API handlers
- `internal/model/` — Data models
- `frontend/src/pages/` — Screen files

The most important characteristic of this file: someone who can’t code can still read and write it. Markdown is a simple writing format that creates headings with # and lists with -. It’s in this format, and the content is natural language.

requirements.md — Record of Decisions

You told AI “show the dashboard when a user logs in” and AI built it. A week later you say “change the first screen after login to the settings page.” AI doesn’t know what the original decision was. You might have forgotten too.

Record decisions in a file.

# requirements.md

## Authentication
- Support Naver OAuth login only
- Navigate to dashboard on successful login (decided 2026-05-20)
- No password recovery feature (since it's OAuth)

## Todo Management
- Todos have title, content, deadline, and priority
- Completed todos are marked as done, not deleted (decided 2026-05-21)
- Priority has 3 levels: High/Normal/Low (decided 2026-05-21)

The reason for adding dates is to track “why did we do it this way?” later.

progress.md — Current Position Marker

# progress.md

## Completed
- [x] Initial project setup
- [x] User table creation
- [x] Login API
- [x] Todo CRUD API

## In Progress
- [ ] Frontend todo list screen

## Planned
- [ ] Priority filter
- [ ] Deadline notifications

When you tell AI “continue where we left off,” this file tells it exactly where things stand.

Why Files

The key to a non-coder controlling AI in long-term projects is here. You can’t read code, but you can read documents. Open CLAUDE.md and check “is this rule correct?”, add new decisions to requirements.md, and check current status in progress.md.

Don’t entrust AI’s memory to AI. Pull it out into files and hold it yourself.

Vibe Coding Pattern

The term vibe coding was coined by Andrej Karpathy. You code by vibe. You don’t read code. You click and type on the screen to verify. When errors occur, you copy the error message and throw it to AI. (Claude Code automates this process — it detects errors and attempts fixes on its own.)

What you’re already doing is vibe coding. Systematized, it looks like this.

Basic Flow

Idea → Tell AI → Check result → Request changes → Repeat

Actual conversation goes like this.

Step 1: Start with data structure

"Look at this Excel file. Design a DB table to store this data."

AI suggests a table structure. You direct modifications: “this column isn’t needed,” “format the date like this.”

Step 2: Make the API

"Make CRUD APIs for this table."

APIs are created. These are features for storing and retrieving data. At this point there’s no screen. But AI tests it directly in the terminal.

Step 3: Make the screen

"Make a React screen that calls these APIs. List, add, edit, and delete should all be possible."

Check in the browser. The list appears, there’s an add button, and entries are saved when you type.

Step 4: Add features

"Add search functionality."
"Add a button to filter only completed items."
"Sort by priority."

This is the golden hour of vibe coding. Up to 3 features, it’s magical.

How to Verify

Since you don’t read code, there’s only one way to verify results: try it yourself.

• Open the screen in the browser and click around
• Enter data and check if it’s saved
• Query it back from the list
• Edit and delete

When errors occur? Claude Code automatically detects them and attempts fixes. No need to copy-paste yourself.

AI fixes it on its own.

Limits of This Pattern

Vibe coding is amazingly fast. But past 5 features, strange things start happening. You add a new feature and existing ones break. You tell AI to fix it and something else breaks. Whac-A-Mole begins.

Why? The answer comes in Class 2. For now, just remember that this pattern works and that it has limits.

Claude Code Usage — Practical Guide

Now that it’s installed, let’s use it. Learn the basic usage.

Starting and Exiting

# Start in the project folder
cd ~/projects/my-first-app
claude

# Have a conversation inside Claude Code
# To exit:
/exit

Basic Conversation

Just speak in natural language inside Claude Code.

> Create a Go Gin server in this folder. One API that returns "Hello, World" on port 8080.

AI creates files, installs necessary packages, and writes code. Along the way it asks “may I create this file?” or “may I run this command?” Approve and it proceeds.

Useful Commands

Inside Claude Code, you can use commands starting with slash (/).

Conversation Tips

1. Give one task at a time. “Make the login API first” produces better results than “Make login, registration, and the dashboard all at once.”

2. Be specific. “Show a red message to the user when an error occurs” is better than “make it better.”

3. Claude Code catches errors automatically. When errors occur, Claude Code automatically detects and attempts fixes. No need to copy-paste.

4. Check in between. It’s safer to check in the browser every 2-3 features rather than requesting 10 at once and checking at the end.

5. Start fresh when context gets long. When conversation exceeds 100 turns, AI response quality degrades. Reset with /clear or run claude again in a new terminal.

Exercise: Building a Todo List App

Enough theory. Let’s build something.

Goal

In one Claude Code session, build a todo list app and add 3 features. Total time: 30-60 minutes.

Prerequisites

Before starting the exercise, these should be installed. If not, just ask Claude Code.

• Go installed: Tell Claude Code "Install Go for me"
• Node.js installed: Tell Claude Code "Install Node.js LTS for me"
• Claude Code running: Does claude --version work?

Tip: Don’t panic if something unfamiliar comes up during installation. Just ask Claude Code “how do I do this?” and it handles it.

Setup

# Create project folder
mkdir -p ~/projects/todo-app
cd ~/projects/todo-app

# Run Claude Code
claude

Step 1: Build the Basic App

Enter the following in Claude Code.

Build a todo list web app.

Tech stack:
- Backend: Go + Gin
- Frontend: React
- Database: SQLite (file DB, usable without installation)

Features:
- Add todo (title, content)
- View todo list
- Mark todo as complete
- Delete todo

Keep the frontend simple. Show everything on one page.
Have the backend server serve the frontend too.

AI starts working. It autonomously proceeds with file creation, package installation, and code writing. Approve when permission prompts appear.

Once complete, start the server and check in the browser.

Start the server. And tell me the access URL.

Open http://localhost:8080 in the browser. Try adding, completing, and deleting todos.

Step 2: Add Feature — Priority

Add priority to todos. 3 levels: High/Normal/Low.
- Be able to select priority when adding
- Show priority in the list
- Display High in red, Normal in blue, Low in gray

Check in the browser. Try adding a todo with a selected priority.

Step 3: Add Feature — Due Date

Add due dates to todos.
- Select a date from a calendar when adding
- Show due date in the list
- Highlight with red background when past due

Check in the browser. See if a todo set to yesterday’s deadline shows with a red background.

Step 4: Add Feature — Search

Add a search feature for todos.
- Search input at the top of the list
- Filter todos containing the search term in title or content
- Filter in real-time as you type

Check in the browser. Add several todos then type a search term to see filtering.

Step 5: Create CLAUDE.md

Record the state of the project you just built.

Create a CLAUDE.md file for this project. Include project overview, run commands, directory structure, and feature list.

Open the generated CLAUDE.md and read it. When you say “continue where we left off” in a new session tomorrow, this file becomes AI’s memory.

Step 6: Create requirements.md

Create this yourself. Don’t ask Claude Code — open requirements.md in a text editor and write the following.

Editor guide (WSL users):

• Edit directly in terminal: nano requirements.md (Save: Ctrl+O → Enter, Exit: Ctrl+X)
• Edit with VS Code: code requirements.md (If VS Code is installed, it auto-connects from WSL)

# requirements.md

## Todo Management
- Todos have title, content, priority (High/Normal/Low), and due date
- Completed todos are marked as done, not deleted
- Past-due todos are highlighted with red background

## Search
- Search in titles and content
- Real-time filtering

## Tech
- Database is SQLite file DB
- Backend serves the frontend together

This file was written by you, not AI. That’s what matters. You make decisions, and you record them.

Class 1 Summary

What we covered in this class:

1. Tool landscape: Split into editor-based (Cursor, Copilot) and terminal agents (Claude Code, Codex CLI)
2. Claude Code: Autonomous verification loop, large-scale context, currently the most powerful terminal agent for multi-file editing
3. Installation: One line — curl -fsSL https://claude.ai/install.sh | bash
4. Keywords: Backend, frontend, DB, deployment — know just enough to point a direction
5. Context management: Externalize AI’s memory with CLAUDE.md (rules), requirements.md (decisions), progress.md (status)
6. Vibe coding pattern: Spreadsheet → DB design → API → Screen → Add features. Magic up to 3, cracks at 5

Next class preview: “Why it crumbles at 5 features.” We’ll add 5 features in a row to the app made in Class 1. Around the 3rd one, you’ll witness existing features breaking. Then we’ll structurally dissect the cause.

Assignment

After completing the Class 1 exercise, try the following.

1. Add 2 more features: Anything works. Category sorting, dark mode, todo ordering, etc. Observe how far things go smoothly and where they start getting strange.

2. Polish CLAUDE.md: Open the CLAUDE.md that AI created and read it yourself. Is there anything unclear? Is anything missing? Try editing it yourself.

3. Continue in a new session: Exit Claude Code and run it again. Say “continue the feature in progress.” Observe the difference with and without CLAUDE.md.

Reins Engineering Full Course