Class 1. How to Command AI — Vibe Coding Essentials

Image: AI generated

Quick Tips — Just Know This and You Can Command AI

Installation is covered in Lecture 0. If you haven’t, go to Lecture 0 and confirm claude --version prints 2.1.x first (it must be the CLI Claude Code, not an IDE-extension chat).

5 Essential Keywords for Commanding AI

1. API — A standard 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. “Store it in the DB”
4. Commit — A save point of the current state. “Commit”
5. Deploy — Putting it on the internet. “Deploy”

These five words are enough to point in a direction. AI understands 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 “pick up where we left off” work in new sessions

All three files are Markdown. Anyone can read and write them, even without knowing code.

Tips for Commanding AI

• Give one instruction at a time. “Make the login API first” is better than “make login and signup and 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 drops. Start a new session, but update the 3 files above first

Hands-On Trial

With Claude Code already installed (see Lecture 0), 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. 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, launches the server, and verifies it. Open http://localhost:8080 in your browser.

Why You Should Command This Way

You’ve already used AI to make things by talking to it. The screen appeared, buttons worked, data was saved. But one question probably remains.

“Is it okay to keep growing this?”

To answer that question, we first need to see exactly where we stand. What tools exist, what words are being used, what patterns we’re following. Class 1 is the time to unfold the map. From Class 2 onward, we’ll build roads on this map.

The Landscape of AI Coding Tools

There are several tools that write code when you tell them to. They broadly split into two branches.

Editor-Based Tools — AI is embedded inside a code editor.

Editor-based tools are optimized for fixing code while looking at it. Great for programmers. But for people who don’t read code, the code on the screen is just meaningless letters.

Terminal Agents — AI makes decisions and executes autonomously in the terminal (black screen).

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

Why Claude Code

This course uses Claude Code as the standard.

Claude Code currently excels at autonomously handling the most complex multi-file tasks among terminal agents. Tokens are the unit of text chunks that AI reads. 200K (200,000) is about one novel, 1M (1,000,000) is about five novels. Claude Code supports a 200K token base context, and Opus 4.6 model supports up to 1M tokens, allowing it to grasp the 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. Editor agent modes like Cursor attempt similar things, but terminal agents are a step ahead in file exploration range and depth of autonomous judgment.

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

Installation Was Done in Lecture 0

Full installation details are in Lecture 0. The essentials:

• Install in one line: curl -fsSL https://claude.ai/install.sh | bash (Windows users need WSL or Docker first)
• Gate criterion: claude --version prints 2.1.x and AI runs commands and verifies results on its own
• Must be CLI Claude Code, not an IDE-extension chat — the autonomous loop this course depends on does not run in chat mode

Keywords for Commanding — The Complete Dictionary

To command AI without reading code, you need to know a minimum of keywords. You don’t need to learn every programming term. Just enough to point in a direction.

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

Backend — The Invisible Engine

The server-side program invisible to users. It receives, processes, stores, and returns data.

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

Frontend — The Visible Screen

The screen users see and click. 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"
"Store it in the DB"

Deployment — Releasing to the World

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

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

Other Frequently Used Terms

You don’t need to memorize these terms. When commanding AI, saying “you know, that thing that stores data” also works. But to understand what AI says back, it’s good to be familiar with at least this much.

Now that you know the keywords, the next question is: do you have to explain all this every time you command AI? Does AI remember what it did before 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 answer “a smart model.” Wrong. Context.

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

AI Forgets

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

Opening a new session is a complete blank slate. Last night’s all-night conversation evaporates. That’s why “pick up where we left off” doesn’t work.

So what do you do? Externalize memory to files.

CLAUDE.md — The Project’s Constitution

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

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

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

# CLAUDE.md

## Project Overview
To-do 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: anyone can read and write it, even without knowing code. Markdown is a simple writing format where # makes headings and - makes lists. It’s in this format, and the content is natural language.

requirements.md — Record of Decisions

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

Record decisions in a file.

# requirements.md

## Authentication
- Only Naver OAuth login supported
- Navigate to dashboard on successful login (decided 2026-05-20)
- No password recovery feature (because OAuth)

## To-Do Management
- To-dos have title, content, deadline, and priority
- Completed to-dos are marked complete, 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] Project initial setup
- [x] Users table creation
- [x] Login API
- [x] To-do CRUD API

## In Progress
- [ ] Frontend to-do list screen

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

When you tell AI “pick up where we left off,” having this file means it knows exactly where things stand.

Why Files

This is the key for someone who doesn’t know code to control AI in long-term projects. You can’t read code, but you can read documents. Open CLAUDE.md to check “is this rule correct?”, add new decisions to requirements.md, and check current position in progress.md.

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

Vibe Coding Patterns

The person who first used the term vibe coding is Andrej Karpathy. Coding by vibe. Not reading code. Checking by clicking and typing on screen. When errors occur, copying the error message and throwing it to AI. (Claude Code does this automatically — it detects errors and attempts fixes on its own.)

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

Basic Flow

Idea → Command AI → Check result → Request corrections → Repeat

Actual conversations go 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 request corrections: “this column isn’t needed,” “make the date format like this.”

Step 2: Make the API

"Make CRUD APIs for this table."

APIs are created. Functions that store and retrieve data. At this point there’s no screen. But AI tests 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. A list appears, there’s an add button, entering data saves it.

Step 4: Add features

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

Up to here is vibe coding’s golden hour. Up to 3 features, it’s magically fast.

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 saves
• Check if it shows up again in the list
• Try editing and deleting

Error occurs? Claude Code automatically detects errors and attempts fixes. No copy-paste needed.

AI fixes it on its own.

Limitations of This Pattern

Vibe coding is surprisingly fast. But once you exceed 5 features, strange things start happening. Adding a new feature breaks existing ones. Tell AI to fix it and something else breaks. Whack-a-mole begins.

Why? That 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. It asks along the way “may I create this file?”, “may I run this command?”. Allow and it proceeds.

Useful Commands

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

Conversation Tips

1. Give one instruction at a time. “Make the login API first” produces better results than “make login and signup and 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 on its own. When errors occur, Claude Code automatically detects and attempts to fix them. No copy-paste needed.

4. Check along the way. Rather than commanding 10 things at once and checking at the end, checking every 2-3 items in the browser is safer.

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

Lab: Building a To-Do List App

Enough theory. Let’s build it ourselves.

Goal

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

Prerequisites

Before starting the lab, the following should be installed. If not yet, tell Claude Code to install them.

• Go installation: Tell Claude Code "Install Go for me"
• Node.js installation: 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. 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 to-do list web app.

Tech stack:
- Backend: Go + Gin
- Frontend: React
- Database: SQLite (file DB, so no installation needed)

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

Keep the frontend simple. Everything visible on one page.
Serve the frontend from a single backend server.

AI starts working. File creation, package installation, and code writing proceed autonomously. Approve when permission prompts appear.

When complete, run the server and check in the browser.

Run the server. And tell me the access URL.

Open http://localhost:8080 in the browser. Try adding to-dos, marking them complete, and deleting them.

Step 2: Add Feature — Priority

Add priority to to-dos. 3 levels: high/normal/low.
- Can select priority when adding
- Priority is visible in the list
- High is red, normal is blue, low is gray

Check in the browser. Add a to-do with a priority selected.

Step 3: Add Feature — Deadline

Add deadline to to-dos.
- Select date from calendar when adding
- Deadline is visible in the list
- Highlight with red background when past deadline

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

Step 4: Add Feature — Search

Add search functionality for to-dos.
- Search input field above the list
- Filter to-dos whose title or content contains the search term
- Real-time filtering as you type

Check in the browser. Add several to-dos and enter search terms to see filtering in action.

Step 5: Create CLAUDE.md

Record the current 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 and read the generated CLAUDE.md. When you “pick up where we left off” in a new session tomorrow, this file becomes AI’s memory.

Step 6: Create requirements.md

Create it yourself. Don’t ask Claude Code — open requirements.md in a text editor and write:

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

## To-Do Management
- To-dos have title, content, priority (high/normal/low), and deadline
- Completed to-dos are marked complete, not deleted
- Past-deadline to-dos are highlighted with red background

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

## Technical
- Database is SQLite file DB
- Backend serves frontend together

This file was written by you, not AI. That’s important. You make the 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, multi-file editing — currently the most powerful terminal agent
3. Installation: Covered in Lecture 0 — confirm claude --version prints 2.1.x and AI runs autonomously (not IDE chat)
4. Keywords: Backend, frontend, DB, deploy — know just enough to point in a direction
5. Context management: Externalize AI’s memory with CLAUDE.md (rules), requirements.md (decisions), progress.md (status)
6. Vibe coding pattern: Excel → DB design → API → screen → add features. Magic up to 3, cracks at 5

Next class preview: “Why does it collapse at 5 features.” We’ll add 5 features in a row to the app built in Class 1. Around the 3rd one, you’ll personally witness the moment existing features break. Then we’ll structurally analyze the cause.

Assignment

After completing the Class 1 lab, try the following:

1. Add 2 more features: Anything works. Category sorting, dark mode, to-do sorting, etc. Observe how far things go smoothly and where they start getting weird.

2. Polish the CLAUDE.md: Open and read the CLAUDE.md that AI created. Are there parts you don’t understand? Is information missing? Edit it yourself.

3. Try continuing in a new session: Exit Claude Code and run it again. Say “continue the feature in progress.” Observe the difference between when CLAUDE.md exists and when it doesn’t.

Reins Engineering Full Course

References

• Ouyang, L., Wu, J., Jiang, X. et al. (2022). “Training Language Models to Follow Instructions with Human Feedback.” NeurIPS 2022. link
• Chen, M., Tworek, J., Jun, H. et al. (2021). “Evaluating Large Language Models Trained on Code.” arXiv preprint. link
• Peng, S., Kalliamvakou, E., Cihon, P. & Demirer, M. (2023). “The Impact of AI on Developer Productivity: Evidence from GitHub Copilot.” arXiv preprint. link

Changelog

• 2026-05-24: Initial release