Build a Bookmark Manager API with Claude Code

Build a REST API using Claude Code's agentic coding workflow.

Introduction

30 Second Summary

Every developer has wished they could describe what they want to build and have the code just appear. With agentic coding tools, that wish is getting close to reality. The catch is that a vague description produces vague results.

In this project, you will use Claude Code to build a bookmark manager API entirely from natural-language prompts. Along the way, you'll discover why giving an AI coder proper project context produces dramatically better code than firing off one-line instructions.

What You'll Build

By the end, you'll type a prompt, watch Claude Code create an entire REST API across multiple files, then watch it autonomously find and fix a bug you planted without you touching a single line of code.

By the end of this project, you'll have:

  • A working Express API you can run locally, hit with curl, and see real JSON responses for creating, listing, filtering, and deleting bookmarks.
  • A CLAUDE.md project memory file that transforms Claude Code from a generic assistant into a context-aware coding partner that follows your exact conventions every session.
  • A plan mode workflow where you review Claude's proposed architecture before it writes a single line, then an autonomous debugging loop where Claude reads test output, traces a bug, and fixes it on its own.
  • Secret Mission: Create a custom skill that generates fully tested API endpoints from a one-line description.

Are there any prerequisites?

You'll need a Claude Pro or Max subscription (Claude Code is included at no extra cost). You should also be comfortable opening a terminal and running basic Git commands. No Node.js or Express experience is required.

Before We Start

Before we dive in, let's lock in what you're about to build and why it matters to you.

Install and Authenticate Claude Code

Before you can build anything with Claude Code, you need the tool itself installed and connected to your subscription. Claude Code is a terminal-based AI assistant that reads, writes, and runs code directly in your project directory.

In this step, you'll install Claude Code and Node.js, create a project folder with Git initialized, and authenticate so Claude Code can start working on your behalf.

In this step, get ready to:
  • Install Claude Code and Node.js on your machine.
  • Create a Git-initialized project directory for your bookmark API.
  • Authenticate Claude Code with your Claude subscription.
Install Claude Code and Node.js

Claude Code runs entirely in your terminal. Let's check if it's already installed.

  • Check if Claude Code is already installed by running this command:
claude --version

✔️ I see a version number followed by (Claude Code)

Claude Code is ready to go. Skip ahead to the Node.js check below.

ⓧ Command not found

  • Install Claude Code by running this command:
curl -fsSL https://claude.ai/install.sh | bash

What does this command do?

This downloads the official Claude Code installer from Anthropic and runs it. The script installs the CLI binary and sets up shell integration so you can run claude from any terminal window.

You should see output ending with a success message confirming the install completed.

  • Confirm the install worked by running:
claude --version

You should see a version number followed by (Claude Code).

Still seeing command not found?

Close your terminal completely and reopen it. The installer adds Claude Code to your shell path, but the change only takes effect in a new terminal session.

help me troubleshoot Claude Code installation

Now let's check Node.js, which your bookmark API will run on.

  • Check your Node.js version by running:
node --version

✔️ I see version 18 or higher

Node.js is ready. Move on to creating your project directory below.

ⓧ I see an older version

Your project needs Node.js 18 or higher for the built-in test runner.

  • Upgrade Node.js to the latest version by running:
brew install node

If Homebrew tells you Node is already installed, run brew upgrade node instead.

  • Verify the upgrade by running:
node --version

You should now see v18 or higher.

Still seeing an old version?

If you use a version manager like nvm, run nvm install node followed by nvm use node to switch to the latest version.

help me upgrade Node.js

ⓧ Command not found

  • Install Node.js via Homebrew by running:
brew install node

What if I don't have Homebrew?

Homebrew is the standard package manager for macOS. Install it first by visiting brew.sh and following the one-line install command on the homepage.

  • Verify Node.js installed correctly by running:
node --version

You should see a version number starting with v18 or higher.

Install failed?

Make sure Homebrew itself is working by running brew --version. If that fails, reinstall Homebrew first.

help me install Node.js on macOS

Create a project directory and initialize Git

Claude Code tracks changes using Git. You need a Git-initialized directory before starting a session.

  • Move to your Desktop by running this command:
cd ~/Desktop
  • Create your project folder, move into it, and initialize Git by running these commands:
mkdir bookmark-api
cd bookmark-api
git init

You should see a message like Initialized empty Git repository confirming the directory is ready.

Seeing 'directory already exists'?

If you already have a bookmark-api folder on your Desktop from a previous attempt, delete it first with rm -rf ~/Desktop/bookmark-api and run the commands again.

help me set up my project directory

Start Claude Code and authenticate

With your tools installed and your project directory ready, it's time to connect Claude Code to your Claude subscription.

  • Start Claude Code by running:
claude

What happens next?

Claude Code opens your browser for authentication. Log in with the same account that has your Claude Pro or Max subscription. Once the browser confirms success, return to your terminal.

You'll see the Claude Code prompt appear with the current model name and your working directory.

  • Follow the browser prompts to log in with your Claude subscription.
  • Return to your terminal once you see the login confirmation.

Before you test a command, what do you think /help will show you inside a Claude Code session?

  • Confirm Claude Code is working by typing this inside the session:
/help

You should see a list of available slash commands and keyboard shortcuts. This confirms your authentication worked and Claude Code is ready to accept instructions.

  • Close the session for now by typing:
/exit

Authentication not working?

Make sure your Claude subscription (Pro or Max) is active. Claude Code requires an active paid subscription to authenticate.

If the browser didn't open automatically, check your terminal for a URL you can copy and paste into your browser manually.

help me authenticate Claude Code

Your tools are ready and Claude Code knows who you are. Next up, you'll give Claude Code your first coding prompt and see what happens when you ask it to build something without any project context.

Prompt Without Context (The Naive Approach)

Your project directory is ready and Claude Code is authenticated. Time to put it to work on a real task.

You'll give Claude Code a single natural-language instruction to build an API. No architecture guidance, no style rules, no project conventions. Let's see what it produces.

In this step, get ready to:
  • Start a Claude Code session and give it a vague prompt.
  • Run the generated API to confirm it works.
  • Reset your project directory for the next step.
Give Claude Code a vague prompt
  • Start a Claude Code session inside your bookmark-api directory by running:
claude

You'll see the Claude Code prompt appear with the model name and your working directory.

  • Type this deliberately minimal prompt into Claude Code:
build me a bookmark API with express

Claude Code starts working. It reads your prompt, decides on a file structure, installs packages, and writes code. You'll see each file it wants to create or modify.

  • Approve each file change when Claude Code asks for permission. Press Y to approve each one.

What is Claude Code doing?

Claude Code is in its default manual permission mode. It plans what to do, then asks for your approval before every file edit or terminal command.

This is the agentic coding loop in action: Claude reads your instruction, decides which files to create, writes the code, and installs dependencies. All from one sentence of natural language.

Claude Code isn't creating files?

Make sure you're inside the bookmark-api directory. Claude Code uses your current working directory as the project root.

If Claude Code seems stuck, check your internet connection. It needs to reach the Anthropic API to generate responses.

Help me troubleshoot why Claude Code isn't generating files from my prompt.

Run the API and examine the output

Claude Code has finished. It created files, installed Express, and built you a working API. Time to test it.

  • Exit the Claude Code session by typing:
/exit
  • Start the server by running:
node server.js

Before you test the endpoint, what do you think the response will look like? An empty list? A welcome message? Something else?

  • Open a new terminal tab and test the API by running:
curl http://localhost:3000/bookmarks

You should see a JSON response. Likely an empty array [] or an object with an empty list. The API works.

What should I see?

Claude Code's output varies between sessions. Your endpoint path might be /bookmarks or something slightly different. If the curl command returns an error, check the server startup output for the correct port and path.

Now look at what Claude Code actually built. Check the files in your directory.

  • List the files Claude Code created by running:
ls

You'll likely see a single server.js file alongside package.json and node_modules. Everything crammed into one file. No separate route modules, no middleware layer, no consistent error-handling pattern.

Why does this matter?

The API works, but Claude Code made every structural decision on its own. Without any guidance about your project's conventions, it defaulted to the simplest possible structure.

In a real project, you'd want separate files for routes, middleware, and configuration. You'd want consistent naming, proper validation, and a style that matches your team's standards. Claude Code had no way to know any of that from a seven-word prompt.

Reset for the next step

You've seen what Claude Code does with zero context. Now you'll wipe the slate clean so you can try the same prompt again with proper project context.

  • Stop the running server by pressing Ctrl+C in the terminal tab where it's running.
  • Delete everything Claude Code created by running:
rm -rf node_modules package.json package-lock.json server.js *.js
  • Confirm the directory is empty by running:
ls

You should see no files listed (or only hidden files like .git).

  • Commit the clean state by running:
git add -A && git commit --allow-empty -m "initial empty project"

What does this command do?

This creates your first Git commit with a clean, empty working tree. The --allow-empty flag lets Git commit even when there are no files to track. You now have a clean baseline to build on.

Seeing leftover files after the rm command?

Claude Code may have created files with names the rm command didn't catch. Run ls to see what's left, then delete any remaining files manually.

Help me clean up all the files Claude Code generated in my bookmark-api directory.

Your directory is clean and you've seen the baseline: Claude Code can build a working API from a single sentence, but it has no way to match your conventions without guidance. Next up, you'll give it that guidance and watch the same prompt produce dramatically different results.

Add Project Memory with CLAUDE.md

In the previous step, you saw what happens when Claude Code works without context. It produced a working API, but the structure, naming, and conventions were all Claude's best guess.

The fix is a file called CLAUDE.md. Claude Code reads this file at the start of every session, treating it as persistent memory about your project's conventions. In this step, you'll write one and immediately see the difference it makes.

In this step, get ready to:
  • Generate a starter CLAUDE.md with the /init command.
  • Replace it with a full project brief encoding your conventions.
  • Re-run the same prompt and see dramatically better output.
Generate a starter CLAUDE.md with /init

Claude Code includes a built-in command that scaffolds a CLAUDE.md file by scanning your project. Since your project is empty right now, the generated file will be minimal. That's fine. You'll replace it in the next substep.

  • Start Claude Code by running:
claude
  • Once the Claude Code prompt appears, run the init command by typing:
/init

Claude Code scans your project and creates a CLAUDE.md file in your project root. Since the project is empty, it will contain only a basic skeleton.

  • Exit the session by typing:
/exit
  • Confirm the file was created by running:
ls

You should see CLAUDE.md listed in the output.

Don't see CLAUDE.md?

Make sure you ran /init inside the Claude Code prompt (the interactive session started with claude), not in your regular terminal. Start Claude Code again and retry.

help me troubleshoot why /init didn't create a CLAUDE.md file

Write a proper CLAUDE.md

The starter file Claude Code generated is a bare skeleton. You'll now replace it with a complete project brief that tells Claude Code exactly how you want your code structured, styled, and organized.

  • Open CLAUDE.md in your preferred text editor.
  • Delete all existing contents and paste in the following project overview and structure:
# Bookmark API

## Project Overview
A REST API for managing bookmarks, built with Express and Node.js.

## Tech Stack
- Node.js with ES modules (use import/export, not require)
- Express for HTTP routing
- Built-in Node.js test runner for tests (node --test)
- In-memory storage (no database)

## Project Structure
- src/server.js - Entry point, starts the Express server on port 3000
- src/routes/ - One file per resource (e.g., bookmarks.js)
- src/middleware/ - Error handling and validation middleware
- tests/ - Test files named *.test.js

What do these sections tell Claude Code?

The Tech Stack section ensures Claude uses ES module syntax (import/export) instead of require. Without this, Claude Code might default to CommonJS.

The Project Structure section is the most impactful. It forces Claude Code to split code across src/routes/, src/middleware/, and tests/ instead of dumping everything into a single file.

  • Directly below what you just pasted, add the coding conventions and rules:
## Code Conventions
- Use const for all declarations unless reassignment is needed
- Use arrow functions for route handlers
- Every route handler must have input validation
- Return consistent JSON responses: { data: ... } for success, { error: ... } for failures
- Use HTTP status codes correctly: 201 for creation, 404 for not found, 400 for validation errors
- IDs are generated with crypto.randomUUID()

## Commands
- Start server: node src/server.js
- Run tests: node --test tests/

## Rules
- Never use var
- Always handle errors with try/catch in async handlers
- Keep route files focused on one resource
- Add JSDoc comments to exported functions

What do these sections tell Claude Code?

Code Conventions locks in the response format ({ data: ... } for success, { error: ... } for failures) so every endpoint is consistent. It also enforces input validation on every route handler.

The Commands section teaches Claude Code how to start and test the project. The Rules section sets hard boundaries Claude Code will follow in every session.

  • Save CLAUDE.md.

✔️ Awesome, I've got everything!

Great. Your CLAUDE.md should have six sections: Project Overview, Tech Stack, Project Structure, Code Conventions, Commands, and Rules. Make sure you saved the file.

ⓧ I'd like to double check the full code

Scroll up and confirm your CLAUDE.md contains both chunks in order:

  • Chunk 1: starts with # Bookmark API and ends with the Project Structure section (tests/ - Test files named *.test.js).
  • Chunk 2: starts with ## Code Conventions and ends with Add JSDoc comments to exported functions.

Make sure there are no extra blank lines between the two chunks. Save the file.

Now it's time to see the difference this file makes. You'll give Claude Code the exact same prompt from the previous step.

  • Start Claude Code again by running:
claude

Before you type the prompt, think about this: what do you expect to be different this time compared to Step 2?

  • Type the same prompt you used in the previous step:
build me a bookmark API with express
  • Watch Claude Code work. When it proposes file changes, press Y to approve each one.

This time, Claude Code reads your CLAUDE.md at session start. You should see it creating separate files in src/routes/, src/middleware/, and using ES module syntax throughout.

Why is the output so different now?

Claude Code reads CLAUDE.md at the start of every conversation. It treats the file as authoritative instructions, not suggestions. The Project Structure section alone is why you now get separate route and middleware files instead of a single monolithic server.js.

Verify the structured output
  • Exit Claude Code by typing:
/exit
  • Check the file structure Claude Code created by running:
ls src/routes/ src/middleware/

You should see bookmarks.js inside src/routes/ and errorHandler.js inside src/middleware/. That multi-file structure came directly from your CLAUDE.md instructions.

  • Start the server by running:
node src/server.js

You should see output like Bookmark API running on http://localhost:3000 in your terminal.

  • Open a new terminal tab or window (keep the server running) and test the API by running:
curl http://localhost:3000/api/bookmarks

Do you expect an empty list or populated data? Make your prediction before checking the output.

You should see {"data":[]}. The API is running, the route is at /api/bookmarks (not just /bookmarks), and the response format matches the { data: ... } convention you specified in CLAUDE.md.

Seeing 'Cannot find module' or 'ERR_MODULE_NOT_FOUND'?

Check that package.json contains "type": "module". Without this, Node.js tries to use require instead of import. Also confirm that node_modules exists. If it doesn't, run npm install manually.

help me debug a module import error when running node src/server.js

  • Stop the server by pressing Ctrl+C in the terminal where it's running.
  • Commit your work by running:
git add -A && git commit -m "feat: initial bookmark API via Claude Code"

You now have a clean commit containing your CLAUDE.md and the entire structured API that Claude Code generated from it.

Your API is structured and working. Next, you'll use plan mode to architect a new feature before Claude Code writes a single line of code.

Use Plan Mode to Add a Tagging Feature

Your bookmark API can create, list, and delete bookmarks. Now you want to add a tagging system so bookmarks can be categorized and filtered.

Jumping straight to code for a feature like this often produces code that solves the wrong problem. Plan mode separates thinking from doing. It lets you review Claude Code's architecture decisions before it touches any files.

In this step, get ready to:
  • Enter plan mode and describe the tagging feature.
  • Review and refine the plan with additional constraints.
  • Test the implemented tagging feature with curl.
Enter plan mode and describe the feature

In the previous steps, Claude Code executed changes immediately after you typed a prompt. Plan mode flips that workflow. Claude Code explores your codebase and proposes an architecture without editing anything.

  • Start Claude Code in your bookmark-api directory by running:
claude
  • Press Shift+Tab to cycle through permission modes. The status bar at the bottom of the prompt shows the active mode.
  • Keep pressing Shift+Tab until the status bar displays plan mode on.

What are the permission modes?

Pressing Shift+Tab cycles through: Manual (asks before every edit and command), Accept edits (auto-approves file edits but asks for shell commands), and Plan (proposes a plan without editing your source files).

Plan mode is ideal when you want to think through a feature's design before committing to code.

  • With plan mode active, type this prompt describing the tagging feature:
Add a tagging system to bookmarks. Users should be able to add tags when creating a bookmark and filter bookmarks by tag via a query parameter like GET /api/bookmarks?tag=dev

Claude Code reads your existing files and CLAUDE.md, then outputs a plan describing which files it will create or modify. It does NOT edit anything yet.

Don't see the plan mode indicator?

Make sure you're pressing Shift+Tab (not just Tab). On Windows, if VT input mode is not enabled, use Alt+M instead.

Help me enter plan mode

Review and refine the plan

Claude Code's first plan might be good, but you can push back on specifics before any code is written. This is the power of separating design from implementation.

  • Read the plan Claude Code proposes. Look at which files it intends to modify and what logic it describes.
  • Add constraints by typing this refinement:
I want the tag filtering to be case-insensitive. Also add input validation that rejects tags longer than 30 characters.

Claude Code revises its plan to include these constraints. Once you're satisfied with the revised plan, you need to switch out of plan mode so Claude Code can execute.

  • Press Shift+Tab until the status bar returns to manual mode on (the default mode).
  • Tell Claude Code to execute the plan by typing:
looks good, implement this plan
  • Approve each file change when Claude Code prompts you (press Y).

Claude Code now creates or modifies files to implement the tagging system, following the conventions from your CLAUDE.md.

Why plan mode instead of just prompting?

When you prompt without plan mode, Claude Code starts writing code immediately. If it misunderstands the requirement, you've already got wrong code to undo.

Plan mode lets you catch misunderstandings at the architecture level. Iterating on a plan costs nothing. Iterating on buggy code costs time.

Test the tagging feature
  • Exit Claude Code by typing /exit.
  • Start the server by running:
node src/server.js

Before you test, predict: when you create a bookmark with tags and then filter by one of those tags, what shape do you expect the JSON response to take?

  • Open a second terminal tab and create a tagged bookmark by running:
curl -X POST http://localhost:3000/api/bookmarks \
  -H "Content-Type: application/json" \
  -d '{"url":"https://example.com","title":"Example","tags":["dev","reference"]}'

You should see a 201 response with your bookmark data, including the tags array containing dev and reference.

  • Filter bookmarks by tag by running:
curl http://localhost:3000/api/bookmarks?tag=dev

You should see only bookmarks tagged with dev returned in the data array. The case-insensitive filtering means ?tag=DEV returns the same results.

Not seeing filtered results?

Make sure the server is still running in your first terminal tab. If you see Connection refused, restart it with node src/server.js.

If ?tag=dev returns an empty array, confirm you created the bookmark first. In-memory storage resets every time the server restarts.

Help me debug my tag filtering

  • Stop the server with Ctrl+C.
  • Commit the tagging feature by running:
git add -A && git commit -m "feat: add tagging system with filtering"

You just used plan mode to design a feature, refine it with constraints, and then execute it. Next up, you'll see Claude Code's most powerful trick: autonomously debugging a failing test without you touching a line of code.

Watch Claude Code Debug Autonomously

So far, you've directed Claude Code step by step. You told it what to build, reviewed its plan, and approved each change. Its real power emerges when you step back entirely and let it solve problems on its own.

In this step, you'll create a test suite, deliberately break something, and watch Claude Code's agentic loop in action. It gathers context, takes action, verifies results, and repeats until the problem is solved. You never touch the code.

In this step, get ready to:
  • Have Claude Code write a test suite covering your entire API.
  • Manually introduce a bug in the delete handler.
  • Watch Claude Code autonomously diagnose and fix the failing test.
Ask Claude Code to write tests, then break something

Your API works, but it has no automated tests. Tests give Claude Code something concrete to verify against. Without them, "looks done" is the only signal available.

  • Start Claude Code by running this command:
claude
  • Ask Claude Code to write tests by typing this prompt:
write tests for the bookmark API using the built-in Node.js test runner. Cover creating a bookmark, listing bookmarks, filtering by tag, and deleting a bookmark.
  • Approve each file change when Claude Code prompts you (press Y).

What is Claude Code creating?

Claude Code reads your CLAUDE.md and sees that tests go in tests/ with filenames matching *.test.js, and that the project uses the built-in Node.js test runner (node --test). It creates tests/bookmarks.test.js following those conventions automatically.

  • Once the test file is written, tell Claude Code to run the tests by typing:
run the tests

Claude Code will start the server and execute the test suite. You should see all tests passing.

Why does this work without you starting the server?

The tests use fetch against http://localhost:3000. Claude Code reads the test file, recognises the server needs to be running, and handles starting it before executing the tests. This is the agentic loop at work.

  • Exit Claude Code by typing:
/exit

Now you'll deliberately break the delete endpoint to set up the debugging demonstration.

  • Open src/routes/bookmarks.js in your text editor.
  • Find this line inside the delete handler:
  const index = bookmarks.findIndex((bookmark) => bookmark.id === id);
  • Change === to !== so the line now looks like this:
  const index = bookmarks.findIndex((bookmark) => bookmark.id !== id);
  • Save src/routes/bookmarks.js.

What does this bug do?

The findIndex call now finds the first bookmark whose ID does NOT match the one being deleted. This means delete requests will remove the wrong bookmark, and the test expecting a 204 followed by the bookmark being gone will fail.

Let Claude Code diagnose and fix the issue

The bug is planted. Claude Code has no idea what you changed or where the problem is. All it will get is a vague instruction that tests are failing.

  • Start Claude Code again by running:
claude

Before you type the next prompt, think about this: do you expect Claude Code to find and fix the bug without you pointing it at the right file or explaining what's wrong?

  • Give Claude Code this prompt:
the tests are failing. diagnose and fix the issue.

Now watch. Claude Code enters its agentic loop and works through the problem autonomously.

What is Claude Code doing?

The agentic loop follows a repeating cycle: gather context, take action, verify results.

  • It runs the test suite and reads the error output.
  • It opens the relevant source file to understand the code.
  • It identifies the !== bug in the delete handler.
  • It edits the file to fix !== back to ===.
  • It re-runs the tests to confirm they pass.
  • Approve the edit when Claude Code proposes it (press Y).

Claude Code runs the tests again and confirms all tests pass. You never pointed it at the right file, never described the bug, and never touched the code yourself.

Claude Code isn't finding the bug?

Make sure you saved src/routes/bookmarks.js after introducing the !== change. If Claude Code reports all tests passing, the file wasn't saved with the bug.

If Claude Code seems stuck or asks clarifying questions, try a more direct prompt: run node --test tests/ and fix whatever is failing.

help me debug why Claude Code isn't finding the bug in my bookmark API tests

Confirm and commit the fix
  • Tell Claude Code to commit the fix by typing:
commit this fix with a descriptive message
  • Approve the git commit command when Claude Code proposes it.

Claude Code generates a meaningful commit message describing the fix and runs git commit for you.

  • Verify the commit landed by typing:
show me the last git commit

You should see a commit with a message describing the bug fix in the delete handler.

Why is this powerful?

You gave Claude Code a single vague instruction. It ran tests, read error output, traced the bug to a specific line, fixed it, verified the fix, and committed the result. That entire workflow happened without you ever opening a file, reading an error message, or writing a line of code.

This is the agentic loop: gather context, take action, verify results, repeat. The better your tests, the more confidently you can hand problems to Claude Code and walk away.

You just watched Claude Code solve a bug entirely on its own. Next up, you'll push Claude Code even further by creating a custom skill that generates API endpoints from a one-line description.

Secret mission

Create a Custom Skill

You've seen how Claude Code follows CLAUDE.md conventions. Now take it a step further: create a custom skill that generates a fully tested API endpoint from a single one-line description. Instead of re-explaining your conventions every time you need a new route, you'll encode the workflow once and invoke it with a slash command.

Clean Up Your Resources

Clean Up Your Resources

This project runs entirely on your local machine. There are no cloud resources or ongoing costs beyond your existing Claude subscription.

Decide whether to keep your project files for future reference, or delete them entirely.

Resources you used:

  • bookmark-api/ project directory on your Desktop (source code, tests, CLAUDE.md, custom skill).
  • Claude Code CLI installed at ~/.local/bin/claude with configuration in ~/.claude/.
  • Node.js installed via Homebrew.

Keep everything running

No action needed. Choose this if you plan to keep building on this project or want to reference the CLAUDE.md and custom skill for future projects.

  • Your bookmark-api/ folder stays on your Desktop.
  • Claude Code and Node.js remain installed for other projects.
  • The Node.js server only runs when you manually start it with node src/server.js. Nothing persists in the background.

Pause - I'll come back to this later

No running processes to stop. The server only runs when you start it manually, so there is nothing to pause.

  • Your project files remain on disk and are ready whenever you return.
  • Claude Code and Node.js stay installed for future use.

Delete - I don't want to use this again

Remove all project files and optionally uninstall the tools you installed during this project.

  • Delete the project directory by running:
cd ~/Desktop
rm -rf bookmark-api
  • Remove Claude Code (native install) by running:
rm -f ~/.local/bin/claude
rm -rf ~/.local/share/claude
  • Remove Claude Code configuration and session history by running:
rm -rf ~/.claude
rm ~/.claude.json
  • Uninstall Node.js (if you installed it for this project) by running:
brew uninstall node

Nice Work!

Nice Work!

You just built a fully functional REST API without manually writing a single line of application code. More importantly, you learned how to direct an agentic coding tool effectively.

You've learned how to:

  • Transform Claude Code from a generic assistant into a context-aware partner by writing a CLAUDE.md project memory file that encodes your conventions and architecture decisions.
  • Used plan mode to separate thinking from doing, reviewing Claude Code's proposed architecture before it touches any files.
  • Watched Claude Code autonomously debug a failing test through the agentic loop: read the error output, trace the bug to the right file, fix it, and re-run tests until they pass.
  • Created a custom skill that extends Claude Code with a reusable workflow for generating new API endpoints from a one-line description.

Ready to quiz yourself?