Last summer my nephew Owen sat across from me at the kitchen table, laptop open, looking like a kid being handed the keys to a car for the first time. This was his first lesson in vibe coding for beginners, and he was sixteen, and he had never written a line of code. He wanted, very specifically, to build a website where he could save links to weird YouTube videos and tag them so he could find them again. His current system was a Notes app with 412 unsorted lines.
I made us coffee, the bad kind in the Mr. Coffee that has been in my parents' kitchen since the Clinton administration. I opened my terminal. I said, we are going to build this thing today, and you are going to do the typing.
Six hours later, with two breaks for sandwiches and one small argument about whether a button should be blue or green, Owen had a working bookmark manager deployed on the internet. He showed it to his sister. She said it looked decent. For a sixteen-year-old, decent from your sister is a standing ovation.
This post is the version of that afternoon I wish I could hand to anyone who asks me how to start. It is for the specific person who has never built software, has watched a friend or a coworker do it, and quietly thought, could I do that. Yes. You can do that. Today, in fact. Before dinner.
Let me show you.
What you will build
A personal bookmark manager. You paste in a link. You add a few tags, work, recipes, songs to learn on guitar, whatever. Later you search. The thing finds your link.
I picked this on purpose. It is real (you will use it), it is useful (you have probably tried four browser extensions for the same job and abandoned them), and it is tractable (we are not building Twitter). It also touches every concept a first vibe-coded project needs to touch: a form to enter data, a database to store it, a list view to display it, search, and deploying the whole thing to a public URL.
If you finish, you will have built a small piece of software that lives on the internet, that you actually use, that nobody else on earth has the exact same version of. That is a different feeling than finishing a tutorial about a todo app. Owen still uses his bookmark manager. He has 800 links in it now and a tag called cursed.
I want to be honest about what I mean by "vibe coding" before we go further, because the term has become a little fuzzy. If you want the long version, read what is vibe coding. The short version: you describe what you want in plain English to an AI agent, the agent writes the code, and you steer the result. You are not memorizing syntax. You are making decisions about what the thing should do.
It is closer to working with a contractor than to laying bricks yourself. You still need to know what kind of house you want. You still need to look at the walls and say, no, that is crooked. But you do not need to know how to mix mortar.
Pick your tool
There are five or six reasonable starting points right now, and our vibe coding tools comparison for 2026 covers all of them in detail. I am going to recommend one and explain why, then mention the others honestly.
For absolute beginners, I tell people to use Claude Code. (If you want a full walkthrough of the setup and first session, our Claude Code tutorial for beginners covers it step by step.)
I know that sounds counterintuitive. Claude Code lives in the terminal. The terminal is the black window with the blinking cursor that has scared off generations of would-be programmers. There are prettier options. So why am I sending you there?
Because the terminal is the kitchen counter, and the prettier options are the microwave. With Claude Code, you can see what the agent is doing. It tells you which files it is creating, what it is editing, when it is running into trouble. It pauses and asks before it does destructive things. The friction of typing into a terminal forces you to slow down by half a beat, which is exactly the right amount of slowing down for a beginner. You will not accidentally accept ten files of code you did not understand.
The visual tools, Cursor, Bolt, Lovable, are great. I use Cursor most days. But for someone learning, they tend to encourage a kind of polite blindness, where the AI does a lot and you nod along. Owen and I tried Lovable first. Within twenty minutes he had a beautiful app he could not modify because he did not know what was inside it. We switched to Claude Code and started over.
If you want a deeper comparison, I wrote one here: Cursor vs Claude Code in 2026. For most beginners, just trust me on this and use Claude Code for your first project. You can graduate to anything else later.
The cost: Claude Code's Pro plan is $20 per month. You will use roughly $3 to $5 worth of agent time on this project. If you are nervous about that, the math works out to about the price of one fancy coffee for the experience of building and shipping your first piece of software. I think that is fair. If $20 is genuinely a problem, the free tier of Claude.ai paired with copy-pasting code into a free editor like VS Code can also work, it just takes longer and breaks the rhythm a bit.
Setup, about ten minutes
Three things to install. Do them in order.
1. Node.js. This is the engine that runs the kind of app we are building. Go to nodejs.org and download the LTS version (the one labeled "Recommended for Most Users"). Run the installer. Click through the defaults. When it finishes, open your terminal (on Mac, hit Cmd+Space and type "Terminal"; on Windows, search "PowerShell"). Type:
node --version
You should see something like v22.11.0. If you do, Node is installed. If you see an error, restart your terminal and try again. Most install issues vanish after a restart.
2. Claude Code. In the same terminal, type:
npm install -g @anthropic-ai/claude-code
This downloads Claude Code from the npm registry, which is the warehouse where Node packages live. It will print a lot of output. Wait until it finishes.
3. Sign in. Type:
claude
It will open a small dialog asking you to log in. Follow the prompts. You will end up on a Claude.ai web page, you click "Authorize," you come back to the terminal. Done.
The official setup docs from Anthropic are at docs.claude.com/en/docs/claude-code if you get stuck. I also wrote a longer beginner's walkthrough here: Claude Code tutorial for the complete beginner.
Now make a folder for your project. In your terminal:
cd ~/Desktop
mkdir bookmarks
cd bookmarks
claude
You are now sitting inside an empty folder with Claude Code waiting for you to say something. This is the moment.
Describe what you want
Here is where most beginners freeze. The blinking cursor is asking you a question and you do not know how to answer it.
The single most useful thing I can teach you is how to write your first prompt. The shape of a good first prompt is a paragraph. Not a sentence. Not a novel. A paragraph that tells the agent what you are building, who it is for, and what it should do at minimum.
Here is the actual prompt I had Owen type. I am giving it to you verbatim. Adapt the personal bits.
I want to build a personal bookmark manager web app. It is just for me. I should be able to paste a URL into a form, add a title and a few comma-separated tags, and save it. The saved bookmarks should show up in a list below the form, newest first, with their tags as small pill-shaped labels. I should be able to click a tag to filter to only bookmarks with that tag. There should be a search box at the top that filters bookmarks by title in real time as I type. Use Next.js with the App Router for the framework. Store the bookmarks in a local SQLite database for now. Style it with Tailwind CSS. Keep the design clean and minimal, white background, dark text, a single accent color. Walk me through the steps before you start writing files, and ask me if I have any preferences I have not specified.
Read that prompt out loud. Notice what it does. It says what to build, names the user (me), defines the features in plain language, picks the technical stack so the agent does not have to guess, sets a design direction, and ends with a request to confirm before charging ahead. That last sentence is worth its weight in gold.
A bad prompt would have been: make me a bookmark app. The agent would have built something. It would have been wrong. You would have spent an hour walking it back. Specificity is mercy. It is mercy to the agent and to you.
If writing prompts feels foreign right now, I have a whole post of starter templates here: vibe coding prompts and templates. Steal liberally.
Watch it work
Claude Code will respond to your prompt with a plan. It will say something like, I will set up a Next.js project, install dependencies, create a SQLite database, build a form component, build a list component, add filtering and search, and style it with Tailwind. Should I proceed?
Say yes.
Then watch. The agent will start running commands and creating files. On your screen you will see things like:
Creating package.json
Installing dependencies...
Creating src/app/page.tsx
Creating src/app/api/bookmarks/route.ts
This is the moment beginners often check out. Files are flying past. They feel like a passenger on a plane, looking out the window at clouds, with no idea where they are.
Resist that feeling. Here is the rule for beginners: read the file names, ignore the file contents. You do not need to understand the TypeScript inside route.ts to know that route.ts is the file that handles saving and loading your bookmarks. The names tell you the structure. The structure is the thing you want to learn first. The code inside the files comes later, if at all.
When the agent finishes, it will say something like, Done. Run npm run dev and open http://localhost:3000 to see it.
Do that. Open a browser. Go to that URL. Your app should appear.
I want to acknowledge how it feels the first time this works. Owen actually said whoa out loud. He had typed one paragraph and gotten a working website. The disproportion between effort and result is, briefly, vertiginous. Sit with it. This is the experience the rest of us call vibe coding, and you just felt it.
Iterate, the next few prompts
Now you start adding things. One at a time. The rhythm matters.
A bad rhythm is add tags and search and dark mode and export to CSV and a settings page. The agent will try, get tangled, produce something half-broken, and you will not know which thing broke. A good rhythm is one prompt, one feature, look at the result, then the next prompt.
Here is the sequence we used with Owen. Yours can be different. The point is the cadence.
Prompt 2: The form works but the tags input is awkward. When I type a tag and press comma or enter, turn it into a pill below the input that I can click to remove. Allow up to ten tags per bookmark.
The agent makes the change. Reload the page. Try it. Better.
Prompt 3: Add a small "Open" button next to each bookmark that opens the URL in a new tab.
Tiny prompt. Tiny change. Twenty seconds. This is fine. Most useful prompts are small.
Prompt 4: Add a light/dark mode toggle in the top right corner. Persist the choice in localStorage so it stays between sessions.
This one will involve more files. The agent might add a context provider, a toggle component, and styling tweaks. Read the file names again. Notice the new ones. You are slowly building a mental map of how the app is shaped.
Prompt 5: I want to be able to edit a bookmark's title and tags after I save it. Add an edit button next to each one that opens a small inline form.
Prompt 6: When I delete a bookmark, ask me to confirm first.
You can keep going. Owen and I did about fifteen prompts before we stopped, including one where he asked it to add a feature where his bookmarks would jiggle when he hovered over them, which he later removed because, as he put it, it was annoying. That is a perfectly good lesson to learn from your own software.
If you want a much longer playbook for working with Claude Code as a beginner, including tactics for keeping the agent honest and patterns for productive iteration, I keep a running list here: 50 Claude Code tips. Bookmark it. Pun intended.
The first time something breaks
It will break. Probably around prompt four or five. Owen's app broke when he asked for the dark mode toggle. The page just went white and the terminal showed a stack trace, which is the kind of red wall of text that makes new programmers think they have done something terrible.
He pushed his laptop away from himself by about two inches and looked at me.
I said, good, this is the most important moment. Read the error.
He read it. It was something about an undefined theme value during server-side rendering. He had no idea what that meant. Neither, exactly, did I.
I said, now copy the entire error, paste it back into Claude Code, and ask why it is happening and how to fix it. (We wrote an entire debugging vibe coded apps survival guide around this exact workflow, if you want the longer version.)
He did. The agent came back with a calm, clear explanation. The theme provider is trying to access localStorage on the server, where localStorage does not exist. I will wrap it in a useEffect so it only runs in the browser. It made the change. The page came back.
This is the single most important habit I can give a beginner. When something breaks, paste the error verbatim, ask the agent why, and ask for the fix. Do not panic, do not start randomly editing files, do not Google. The agent that wrote the code is also the best debugger of that code. Use it.
The corollary habit: when the agent fixes the problem, ask it to explain in one paragraph what was wrong. You do not need to understand all of it. You need to understand a little of it. Each broken-and-fixed cycle teaches you a small piece of how the machinery actually works. Owen, by the end of the day, knew what server-side rendering was, sort of, in the way a sixteen-year-old knows what an alternator is after his car breaks down once.
The agent is, in this sense, a tutor that only teaches you the lesson you are currently inside. That is a very efficient way to learn.
Deploy, about fifteen minutes
You have an app that works on your laptop. It is time to put it on the internet so it works from your phone, from your friend's phone, from anywhere.
We will use Vercel. Vercel is a hosting company that makes deploying a Next.js app, which is what you have built, almost suspiciously easy. Their docs live at vercel.com/docs if you want the full picture.
Three steps.
1. Put your code on GitHub. GitHub is a website that stores code. Tell Claude Code:
Initialize a git repository, add all the files, commit them with the message "first version," and walk me through creating a GitHub repository and pushing this code to it.
The agent will literally walk you through it. You will create a free GitHub account if you do not have one, click a few buttons, and run a few commands the agent gives you. Five minutes.
2. Connect Vercel to GitHub. Go to vercel.com, sign up with your GitHub account, click "Add New Project," pick your bookmarks repository from the list, and click "Deploy."
3. Wait two minutes. Vercel reads your code, builds it, and gives you a URL. Something like bookmarks-tasha-xyz.vercel.app. Click it. Your app is on the internet.
There is a small wrinkle. Your bookmarks were stored in a local SQLite file on your laptop. Vercel does not have that file. You have two options. The faster one: ask Claude Code to switch the database to a free hosted option like Vercel's own Postgres or Turso. The simpler one for today: just enjoy that the app is deployed, even if a fresh install starts empty, and worry about persistent storage tomorrow.
I had Owen do option two. He wanted the win first. Persistence came the next weekend.
The point is not to teach you DevOps. The point is to show you that, in 2026, putting your software on the internet is a fifteen-minute task that costs nothing for a small project. The barrier that used to stop people, I do not know how to host things, is gone.
What this taught Owen
I want to slow down for a moment and tell you what I think Owen actually learned that day, because it is the same thing I want you to learn.
It was not Next.js. It was not SQLite. It was not Tailwind. He could not write any of those things from scratch today, and that is fine.
What he learned was: he could build software. Not "could pretend to build software." Not "could click through a tutorial." Could think of a thing he wanted, describe it, watch it appear, fix it when it broke, ship it, and use it. The cycle. The whole loop, end to end.
The other thing he learned, which was harder, was that he could not check out. The temptation with vibe coding, especially with shinier tools than Claude Code, is to nod along while the agent does things and treat the whole process like ordering takeout. The reader who tries that ends up with software they do not understand, that breaks in ways they cannot diagnose, that they cannot extend without paying someone else to do it. That is not building. That is renting.
The version of vibe coding that works, the version that gives you the gift of being a person who can make things, is the engaged version. You read the file names. You ask the agent to explain when you do not get it. You push back when something looks weird. You try the app, you press the buttons, you notice when the spacing is off. You stay in the loop.
That is the real prerequisite. Not knowing JavaScript. Not knowing what a database is. Just being willing to engage, the same way you would engage with a contractor remodeling your kitchen. You do not need to swing the hammer. You need to walk into the room and say that cabinet does not open right.
If you can do that, you can build software now. That is genuinely new. It was not true ten years ago. It was barely true two years ago. It is true today.
Where to go next
You shipped a thing. Take a walk. Tell someone you built an app today. Resist the urge to immediately add ten more features.
When you come back to your laptop, here is what I would do in this order.
Read what is vibe coding for the wider context, now that the activity is no longer abstract to you. The essay will hit different now that you have done the thing.
Pick up 50 Claude Code tips and skim it. You will not retain it all. Bookmark a few that look useful (in your new bookmark manager, ideally) and come back when you need them.
If you want a deeper, slower walk through Claude Code itself, I keep a beginner-focused tutorial here that goes well past what we covered today: Claude Code tutorial for the complete beginner.
Then pick a second project. Something else you actually want. A small inventory tracker for your hobby. A meal planner. A reading log. The second app is faster than the first because you have the muscle memory for the loop.
I am not going to wrap this up neatly, because the truth is I do not know where you are going to take this. Owen built three more small apps that summer and then started high school in the fall and his attention shifted. Maybe you build one app and put the whole thing down. Maybe you build forty. Maybe in a year you are doing this professionally and you write me to complain that I oversimplified.
All of those are fine outcomes. The thing I wanted to give you was the door. The door is open. Walk through whenever.
And if you build the bookmark manager, I would genuinely like to see it. The whole point of making something is showing it to somebody. Find me. Show me. Owen says hi.
