The twenty-minute gap

The distance between “I’ve never opened a terminal” and “I just built something with Claude Code” is about twenty minutes. Most of that is downloading things. The rest is six commands.

That’s the whole gap. Not weeks of learning to code. Not a CS degree. Six commands and a good AI model.

Get a terminal

Two good options: Ghostty is fast and minimal. iTerm2 is friendlier, with easy tab renaming and more settings out of the box. Both are free. Pick either one, you can always switch later.

Open it. You’ll see a blank screen with a blinking cursor. That’s the terminal. It’s a text-based file browser. Instead of clicking folders in Finder, you type short commands to move around and look at things. Same files, same folders, different interface.

The six commands

Here’s the entire vocabulary you need:

Command	What it does
pwd	Shows where you are
ls	Lists what’s in the current folder
cd name	Moves into the folder with that name
cd ..	Moves up one folder
cat name	Shows the contents of the file with that name
clear	Clears the screen
skate	Type it and find out

That’s it. Six commands. Try them in the sandbox below. There are five missions to complete. Tab autocompletes file and folder names.

Everything you just did in that sandbox is exactly how it works in a real terminal. Same commands, same behavior. The only difference is the filesystem is bigger.

Get Claude Code

Two steps.

Install Claude Code. Open your terminal and paste this:

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

Run it. Navigate to any project folder and type:

claude

That’s it. Claude Code is running. You’re talking to an AI that can see, read, and modify every file in your project.

The one thing that trips everyone up

Pasting in the terminal works differently than you expect. On Mac, Cmd+V pastes text, and that works fine. But when you want to paste a screenshot into Claude Code, you use Ctrl+V. Not Cmd+V. Ctrl+V.

This is the one keyboard shortcut that breaks your muscle memory. You’ll forget the first five times. Then it’ll stick. Screenshots are how you show Claude Code what you’re looking at, so this matters. Paste a design comp, a bug, a sketch from your notebook. The visual context is as useful as the text.

Your first conversation

Navigate to a project folder. If you don’t have one, create it with mkdir (make directory):

mkdir my-site && cd my-site

Start Claude Code:

claude

Try asking it something. “What’s in this folder?” “Create an HTML page with a centered heading.” “Add a dark mode toggle.” You describe what you want in plain language and it writes the code. You review what it produces and steer.

The conversation is the interface. Every question you ask, every screenshot you paste (Ctrl+V), every correction you make is shaping the output. The same design instincts you use to critique a mockup work here. “The spacing is off.” “Make the heading more prominent.” “This needs a hover state.” All of that translates directly.

Why this and not the desktop app

Claude.ai is a chatbot in a browser tab. You paste things in, you get answers back. Claude Code is different. It runs inside your project. It can see every file, read your code, create new files, and modify existing ones. It’s not a conversation about your work. It’s a collaborator inside your work.

That distinction matters because it unlocks two things the desktop app can’t do: memory and skills.

Teach it once

Ask Claude to create a CLAUDE.md file in the root of your project. Tell it what the project is, what conventions matter, what you don’t want it to do.

A marketing site with a component library. Design tokens for all
spacing and color, never magic numbers. Components are PascalCase
and live in src/components/.

Claude writes the file. Every time you run claude in this folder from now on, it reads that file first. Your preferences, your conventions, your project structure. You explain it once, it sticks.

This is the simplest version of something bigger: you can shape how Claude works with your project over time. Every rule you add to CLAUDE.md makes the next session smarter. And you never have to write the file by hand. Just tell Claude what matters.

Your first skill

This is where it gets good. Everything up to now was setup. Skills are how you turn Claude Code into your own tool.

A markdown file with instructions becomes a slash command you can run anytime.

Tell Claude what you want:

Create a skill called review that checks the current project for design
issues. It should look at contrast, spacing consistency, alignment,
responsive behavior, and visual hierarchy. Point to specific files and
suggest fixes.

Claude creates the folder structure and the skill file for you. Now type /review in any session and Claude reads your project, applies the checklist, and tells you exactly what to fix. Every time. One command.

That’s the pattern. A skill is just instructions in a markdown file. You can make skills for anything: generating a color palette page, auditing copy, scaffolding a new component. Describe what you want the skill to do, and Claude writes it.

Once you have a few of these, something shifts. The prompts you used to type out every time become single commands. AI stops being a thing you talk to and starts being a natural extension of how you work. Skills turn your best prompts into muscle memory.

What this adds up to

Terminal. Six commands. Claude Code. A CLAUDE.md file. A skill or two. That’s the entire setup. From here, the ceiling is how far you want to push it. Designers are building full prototypes, iterating on live code, shipping directly to production. Not because they became engineers overnight, but because the gap between design intent and working code collapsed.

The twenty minutes are behind you. The interesting part starts now.