Build a REST API with Claude Code

Direct an AI coding agent to build, test, and validate a REST API.

Introduction

30 Second Summary

Writing code line by line is one way to build software. Directing an autonomous agent to build it for you is another. Claude Code is a terminal-based coding agent that writes files, installs packages, runs commands, and fixes its own mistakes.

In this project, you will build a complete REST API without writing a single line of code by hand. You direct Claude Code with plain English, and it handles everything from file creation to testing.

What You'll Build

By the end, you can open a new terminal, type a sentence describing what you want, and watch a fully tested bookmark manager API appear in your project folder, ready to demo with a single curl command.

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

A working REST API where you can save, list, and delete bookmarks via HTTP endpoints and see JSON responses come back in your terminal.
A plan mode workflow where you review Claude's proposed architecture changes before any code is modified, then approve them for execution.
A CLAUDE.md project memory file that teaches Claude your coding conventions so every new session follows your rules automatically.
A custom skill you can invoke with a single slash command to run tests, fix failures, and commit the result.
Secret Mission: Create a security-reviewer subagent that audits your API code for vulnerabilities in its own isolated context.

Are there any prerequisites?

You need an active Claude Pro or Max subscription to use Claude Code. You should also be comfortable running commands in a terminal and have some coding experience.

No prior experience with AI coding tools is required. This project teaches you the workflow from scratch.

Before We Start

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

In this project, you'll direct an autonomous coding agent to build an entire REST API for you. The skill you're practising is not typing code. It's knowing how to describe what you want, verify the result, and iterate until it's right.

Set Up Claude Code

Claude Code is an agentic coding tool that lives in your terminal. Instead of writing code yourself, you describe what you want and Claude Code builds it, runs it, and fixes it.

Before you can start directing the agent, you need the CLI installed, authenticated, and pointed at a project directory. In this step, you'll get Claude Code running inside a fresh git repository.

In this step, get ready to:

Install and authenticate Claude Code.
Create and initialize the bookmark-api project directory.
Confirm Node.js is available through Claude Code.

Install Claude Code and verify it launches

Claude Code is a CLI you install once. It authenticates with your existing Claude Pro or Max subscription.

Open your terminal by pressing Cmd+Space to open Spotlight, typing Terminal, and pressing Enter.
Install Claude Code by running this command:

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

Prefer Homebrew?

You can also install with brew install --cask claude-code. Note that Homebrew installations do not auto-update. The native installer above updates automatically in the background.

Once the install finishes, launch Claude Code by running:

claude

What happens on first launch?

Claude Code opens a browser window for you to log in with your Claude Pro or Max subscription. Follow the prompts in your browser to complete authentication.

If the browser does not open automatically, press c in the terminal to copy the login URL, then paste it into your browser manually. When login completes, the terminal shows Login successful and prompts you to press Enter to continue.

Complete the authentication flow in your browser.
Press Enter when the terminal confirms login was successful.

You should see the interactive Claude Code prompt appear in your terminal. This is where you'll type natural-language instructions for the rest of the project.

Seeing command not found?

Close your terminal and reopen it so your shell picks up the new PATH entry. Then run claude again.

If the browser login fails or loops, check that you have an active Claude Pro or Max subscription at claude.ai.

help me troubleshoot Claude Code installation

Create and initialize a project directory

Claude Code needs a project directory to work in. It uses the directory context to understand what you're building.

Exit the current Claude Code session by pressing Ctrl+C or typing /exit.
Create the project directory and move into it by running:

mkdir ~/bookmark-api && cd ~/bookmark-api

Initialize a Git repository by running:

git init

You should see a message like Initialized empty Git repository in /Users/.../bookmark-api/.git/.

Start a Claude Code session inside your new project by running:

claude

The Claude Code prompt appears again. This time it is running inside your bookmark-api directory, ready to build your project.

Claude Code not recognizing the directory?

Make sure you ran cd ~/bookmark-api before running claude. Claude Code uses your current working directory as the project root.

help me set up my Claude Code project directory

Verify Node.js is available

The bookmark API you'll build uses Node.js. Instead of checking manually, you'll ask Claude Code to handle it. This is your first taste of directing the agent.

In your Claude Code session, type this prompt and press Enter:

Check if Node.js is installed and show the version

Claude Code runs node --version on your behalf and reports the result.

✔️ Claude reports a version number

Node.js is ready. You can move on to the next step.

ⓧ Claude says Node.js is not found

No problem. Ask Claude Code to install it for you.

Type this prompt into your Claude Code session:

Install Node.js using Homebrew

Claude Code runs the Homebrew install command and confirms when Node.js is ready. It may ask for permission to run the install command. Allow it to proceed.

After the install completes, verify by asking Claude Code again:

Check if Node.js is installed and show the version

This time you should see a version number reported.

Why ask Claude Code instead of running node yourself?

You could run node --version yourself in a separate terminal. But the point of this project is to practice directing the agent. Every task you delegate builds the habit of letting Claude Code handle the execution while you focus on intent.

Your environment is ready. Claude Code is installed, authenticated, and running inside a git-initialized project. Next up, you'll give it your first real task and watch it build an entire REST API from a single prompt.

Build the API with Claude Code

Your environment is locked in. Claude Code is running, the project directory is ready, and Node.js is available.

Now it is time to experience Claude Code's core superpower: describing what you want in plain English and watching it build a multi-file project from scratch. You will not write a single line of code by hand. Instead, you will direct the agent and let it handle file creation, dependency installation, and server startup.

In this step, get ready to:

Direct Claude Code to generate a complete REST API from a single prompt.
Test the API endpoints with curl to confirm they work.
Create your first git commit using Claude Code.

Ask Claude Code to build the initial API

Claude Code works best when you give it a clear, complete description of what you want in one prompt. The more specific you are about endpoints, data shapes, and behavior, the better the result.

In your Claude Code session, type the following prompt and press Enter:

Build a bookmark manager REST API with Express. It should support POST /bookmarks to create a bookmark with a url and title, GET /bookmarks to list all bookmarks, and DELETE /bookmarks/:id to remove one. Store bookmarks in memory. Include a package.json. Install dependencies and start the server.

What happens next?

Claude Code reads your prompt, then autonomously creates files, writes code, runs npm install, and starts the server. You will see each action appear in your terminal as Claude executes it.

This is the key difference from a chatbot. Claude Code does not just suggest code. It runs commands, creates files, and builds the project directly in your file system.

What if Claude asks for permission?

Claude Code asks for permission before executing commands that modify your system (like npm install or starting a server). When you see the permission prompt, press y to accept each action so Claude can continue working.

Watch Claude Code work. It creates index.js, writes a package.json, installs Express, and starts the server on port 3000. All without you switching tools or opening another window.

Test the running API

The server is now running in your Claude Code session. To test it, you need a separate terminal so you can send HTTP requests while the server stays up.

Open a new terminal tab by pressing Cmd+T (macOS) or Ctrl+Shift+T (Windows/Linux).

Before you run the next command, predict: what do you think a brand new API with no bookmarks stored will return when you request all bookmarks?

Request all bookmarks by running this command:

curl http://localhost:3000/bookmarks

You should see [] printed in your terminal. An empty JSON array, because no bookmarks exist yet.

Seeing connection refused?

If you see an error instead of [], the server may not be running. Switch back to your Claude Code tab and check if you see a message like Server listening on port 3000. If the server is not running, type Start the server in Claude Code and approve the command.

help me debug why curl cannot connect to my Express server on port 3000

Create a bookmark by running this command:

curl -X POST http://localhost:3000/bookmarks -H "Content-Type: application/json" -d '{"url": "https://example.com", "title": "Example"}'

You should see a JSON response containing your new bookmark with a generated id, the url, and the title you provided.

Confirm the bookmark was saved by listing all bookmarks again:

curl http://localhost:3000/bookmarks

This time you should see an array with one bookmark object inside it. Your API is working.

What just happened?

You described an API in plain English, and Claude Code built the entire thing: an Express server with three endpoints, a package.json with dependencies, and a running process. You tested it with real HTTP requests and confirmed it works.

This is agentic coding. You direct. The agent builds, runs, and verifies.

Stop the server and commit

The API works, so it is time to save this progress with a git commit. You will direct Claude Code to handle the entire git workflow too.

Switch back to the terminal tab running Claude Code.
If the server is still running in the foreground, press Ctrl+C to stop it. If it stopped on its own, you can skip this.
Ask Claude Code to commit your work by typing this prompt:

Create an initial commit with all files

Claude Code runs git add and git commit for you, choosing a descriptive commit message based on what was built.

Why commit through Claude Code?

You could run git commands yourself, but letting Claude handle it reinforces the pattern. Claude Code is not just a code generator. It manages your full development workflow: writing code, running it, and committing results.

Claude Code not committing?

If Claude says it cannot commit, you may need to configure git with your name and email first. Ask Claude Code: "Set up git with my name and email, then commit all files." It will run the git config commands and then create the commit.

help me configure git so Claude Code can create commits

You just built a working REST API without writing a single line of code by hand. Next up, you will use plan mode to review and approve architectural changes before Claude touches your code.

Use Plan Mode for Validation

In the previous step, you watched Claude Code build a working REST API from a single prompt. That is impressive, but the API has a gap.

Right now, you can POST completely invalid data and the server silently accepts it. An empty title, a nonsense URL, anything goes. Plan mode lets you describe the fix you want, review Claude's proposed changes across files, and approve the architecture before a single line is modified.

In this step, get ready to:

Experience the validation gap by POSTing invalid data.
Switch to plan mode and review a proposed validation architecture.
Approve the plan and verify that invalid inputs now return 400 errors.

Experience the validation gap

Before fixing anything, you need to see the problem firsthand. Your API currently stores whatever it receives, no questions asked.

In your Claude Code session, type the following prompt:

Try posting a bookmark with an invalid URL: curl -X POST http://localhost:3000/bookmarks -H 'Content-Type: application/json' -d '{"url": "not-a-url", "title": ""}'

Before Claude runs this, what do you think the server will respond with for a completely invalid URL and an empty title?

Claude Code starts the server (if not already running) and executes the curl command. You see a 201 or 200 success response. The garbage data is stored without complaint.

Why is this a problem?

Any client can fill your data store with junk entries. Invalid URLs break downstream features like fetching bookmark metadata. In a real application, this leads to corrupt data that is expensive to clean up.

Switch to plan mode and review the proposed changes

You could ask Claude to just fix the validation directly. But for a multi-file architectural change, plan mode lets you see what Claude intends to change before it touches any files.

Press Shift+Tab in your Claude Code session to cycle the permission mode.
Keep pressing Shift+Tab until the status bar shows plan mode on.

What is plan mode?

Plan mode lets Claude read your files and propose changes, but it cannot edit anything until you explicitly approve. The mode cycles through default, acceptEdits, then plan each time you press Shift+Tab.

You can also start a session directly in plan mode by running claude --permission-mode plan.

Type the following prompt to ask Claude for a validation plan:

I want to add input validation to all endpoints. URLs must be valid, titles must be non-empty strings, and invalid requests should return 400 with an error message. What files need to change? Create a plan.

Read Claude's proposed plan. It outlines which files change, what validation logic to add, and how error responses are structured.
Optionally press Ctrl+G to open the plan in your text editor for direct editing.

Review the error response format

Check that Claude's plan returns errors as {error: string, status: number}. This is the convention you will lock into your project memory in the next step.

Approve and execute the plan

Once you are satisfied with the proposed architecture, switch out of plan mode and tell Claude to implement it.

Press Shift+Tab to cycle back out of plan mode (the status bar returns to its default state).
Type the following prompt to execute:

Implement the validation plan. Run the server and test that invalid inputs return 400 errors.

Watch Claude implement the validation, start the server, and run test curls to verify.

What is happening?

Claude edits index.js to validate URLs using new URL() (which throws on invalid strings) and checks that titles are non-empty strings. Invalid requests now receive a 400 status with an {error, status} JSON body.

Now test it yourself. What do you expect to see when you POST the same invalid URL from earlier?

Open a new terminal tab and run this command:

curl -X POST http://localhost:3000/bookmarks -H "Content-Type: application/json" -d '{"url": "not-a-url"}'

You see a 400 error response with a validation message instead of silent acceptance. The gap from earlier is closed.

Still seeing a 200 success response?

Make sure you switched out of plan mode before asking Claude to implement. Plan mode only proposes changes. It does not edit files.

Confirm the server restarted after the changes were made. Ask Claude: "Restart the server" and try the curl again.

Help me debug why my validation isn't returning a 400 error.

Return to your Claude Code session and ask Claude to commit the changes:

Commit with a message describing the validation changes

Claude stages the files and creates a descriptive commit message for you.

Your API now rejects garbage data at the door. Next up, you will give Claude persistent memory of these conventions so it follows them automatically in every future session.

Add Project Memory with CLAUDE.md

Your API now rejects invalid input and you used plan mode to architect the fix before touching code. But there's a hidden fragility in your workflow.

Every time you start a fresh Claude Code session, Claude forgets everything about your project's conventions. It might format errors differently, switch from ES modules to CommonJS, or skip validation entirely. CLAUDE.md solves this by giving Claude persistent context it reads at the start of every session.

In this step, get ready to:

Observe Claude diverging from your conventions without persistent memory.
Create a CLAUDE.md that documents your project standards.
Verify Claude automatically reads your conventions in a fresh session.

Observe the memory problem

Right now, Claude Code has no long-term memory of how your project works. If you reset the session context, it loses all awareness of your error format, module style, and validation rules.

In your Claude Code session, reset the context by typing:
/clear

Before you give Claude a task, think about this: without any memory of your existing code, do you expect Claude to match your error format and module style exactly?

Ask Claude to add a new endpoint by typing this prompt:

Add a PUT /bookmarks/:id endpoint to update a bookmark

Look at the code Claude generates. Notice how it may use different patterns than what already exists in your project. It might format error responses as plain strings instead of {error: string, status: number}, use require() instead of ES module imports, or skip input validation.

Why does Claude forget?

Each Claude Code session starts with a fresh context window. Claude can see your files on disk, but it has no memory of past conversations or decisions you made. Without explicit documentation, it infers conventions from the code it reads, which can lead to inconsistencies.

Undo this change by typing:
/rewind

Your code returns to its previous state. The inconsistent PUT endpoint is gone.

Not sure what /rewind did?

The /rewind command restores the previous conversation and code state. You can also double-tap Escape to open the rewind menu. After rewinding, your files on disk should match what they looked like before the PUT endpoint was added.

help me understand what /rewind does in Claude Code

Create CLAUDE.md

CLAUDE.md is a markdown file at the root of your project that Claude reads at the start of every session. It acts as persistent memory for build commands, code style rules, and project conventions.

Generate a starter CLAUDE.md by typing:

/init

Claude Code analyzes your codebase and creates a CLAUDE.md with detected build commands, patterns, and conventions.

What does /init detect?

The /init command scans your project structure, package.json, and source files. It generates sections for build and test commands, directory layout, and coding patterns it observes in your existing code.

The generated file is a starting point, but it needs your explicit conventions added.

Refine the CLAUDE.md by asking Claude to add your specific rules:

Update the CLAUDE.md to include these rules: use ES modules syntax, return error responses as {error: string, status: number}, validate all inputs before processing, and run tests before committing

What conventions are you documenting?

You are teaching Claude four explicit rules for this project:

Use ES modules (import/export) instead of CommonJS (require).
Format all error responses as {error: string, status: number}.
Validate every input before processing the request.
Always run tests before committing changes.

Commit the CLAUDE.md by asking Claude:

Commit the CLAUDE.md

Claude stages and commits the file with a descriptive message.

Your CLAUDE.md should now contain the build commands, code style, and conventions sections.

✔️ Awesome, I've got everything!

Great. Double check you've saved and committed your CLAUDE.md.

ⓧ I'd like to double check the full code

Your CLAUDE.md should look like this:

# Bookmark API

## Build and run
- Install: npm install
- Start: node index.js
- Test: node --test

## Code style
- Use ES modules (import/export) syntax
- Destructure imports when possible

## Conventions
- Return error responses as {error: string, status: number}
- Validate all inputs before processing
- URLs must be valid (parseable by new URL())
- Titles must be non-empty strings
- Run tests before committing

If yours looks different, ask Claude to update it to match these sections.

CLAUDE.md not created?

Make sure you are in the ~/bookmark-api directory when running /init. If /init suggests improvements instead of creating a file, it means a CLAUDE.md already exists. Ask Claude to show you the current contents.

help me generate a CLAUDE.md for my project

Verify memory works across sessions

The real test is whether Claude remembers your conventions after a full context reset. If CLAUDE.md is working, Claude should know your rules without you re-explaining them.

Reset the session context completely by typing:
/clear

Before you ask anything, predict: will Claude know your error format and module style, or will you need to re-explain them?

Ask Claude about your project conventions:

What are the project conventions?

Claude reads the CLAUDE.md and reports your conventions back to you. You should see it reference ES modules, the error response format, input validation, and the test-before-commit rule.

How does Claude find CLAUDE.md?

Claude walks up the directory tree from your working directory, checking each level for a CLAUDE.md file. It loads any it finds at session start, before you type your first prompt. You can run /context to confirm it loaded and see it listed under memory files.

Now test whether this memory actually guides code generation.

Ask Claude to add the PUT endpoint again:

Add a PUT /bookmarks/:id endpoint to update a bookmark

This time Claude follows your documented conventions. The PUT endpoint uses the same {error: string, status: number} error format, validates inputs before processing, and matches the ES modules style of your existing code.

Commit this new endpoint by asking Claude:

Commit with a descriptive message

Claude stages the changes and commits them. Your API now has a working PUT endpoint built to your documented standards.

Keep CLAUDE.md under 200 lines

CLAUDE.md should contain only what Claude cannot infer from reading your code directly. If it grows too long, move reference material into skills (which you will learn about next).

Claude not following conventions?

Run /context to confirm CLAUDE.md appears in the memory files list. If it does not appear, make sure the file is saved at the project root (~/bookmark-api/CLAUDE.md) and not inside a subdirectory.

help me debug why Claude Code isn't reading my CLAUDE.md

Your project now has persistent memory. Every future Claude Code session starts by reading your CLAUDE.md and following your conventions automatically. Next up, you will add a verification loop that lets Claude run tests, catch failures, and fix them without your intervention.

Set Up the Verification Loop

In the last step, you gave Claude Code persistent memory of your project conventions through CLAUDE.md. Now Claude follows your rules every session.

But conventions alone do not guarantee working code. You have no automated way to verify that what Claude writes actually runs correctly. If Claude introduces a regression later, you would not know until you manually test every endpoint with curl.

The verification loop solves this. You give Claude a verifiable goal (all tests passing), and it iterates autonomously until done. Then you will encode that loop as a reusable custom skill you can trigger with a single slash command.

In this step, get ready to:

Have Claude write and run a test suite for your API.
Watch Claude autonomously fix failing tests until all pass.
Create a reusable skill that automates the test-and-commit workflow.

Ask Claude to write and run tests

Your API has endpoints and validation, but no test suite to prove they work. A test suite gives Claude a concrete pass/fail signal it can act on autonomously.

In your Claude Code session, ask Claude to build a test suite by typing this prompt:

Write a test suite for the bookmark API using the Node.js built-in test runner. Cover all endpoints including validation. Run the tests after writing them.

Before Claude runs the tests, predict: do you think every test will pass on the first try?

Watch Claude create a test file and execute node --test.
Some tests will likely fail on the first run. The server may not be structured for testability (e.g., it starts listening immediately on import, blocking the test runner from importing it cleanly).

This is intentional. Claude now enters its verification loop.

What is the verification loop?

The verification loop is Claude Code's core autonomous pattern. When tests fail, Claude reads the error output, identifies the root cause, edits the code, and re-runs the tests.

You give it a verifiable goal (passing tests) and it iterates until done. This is what makes Claude Code genuinely autonomous rather than just a code generator.

Watch the autonomous fix cycle

This is where Claude Code demonstrates its most powerful capability. Instead of you debugging, Claude handles the entire loop on its own.

Observe Claude reading the test failure output in your terminal.
Watch it identify the issue (often restructuring index.js to export the app separately from starting the server, so tests can import it without binding to a port).
Watch it edit the code, then re-run node --test automatically.
If more tests fail, Claude repeats: read error, fix, re-run.

This cycle continues until all tests pass with green output in your terminal.

What should I see?

You will see Claude make several iterations. Each time it runs node --test, the output shows which tests pass and which fail. Eventually you will see all tests passing with green checkmarks.

The key thing to notice is that you did not write a single fix. You described the goal, and Claude handled every failure on its own.

Claude seems stuck or keeps looping?

If Claude has cycled more than 4-5 times without converging, try giving it a hint about the specific failure pattern. For example: "The issue is that the server starts listening on import. Separate the app creation from the listen call."

Help me debug this

Once all tests pass, verify the result yourself by asking Claude:

Run the tests

You should see all tests passing with green output confirming every endpoint and validation case works.

Commit and create a reusable skill

The tests pass. Now you will commit the working code, then encode the test-fix-commit workflow as a custom skill you can invoke anytime with a single slash command.

Tell Claude to commit the tested code by typing:

Commit with a descriptive message

Claude stages all changes and writes a meaningful commit message based on what was added (test suite, testability refactor).

What are custom skills?

Skills are markdown files that teach Claude repeatable workflows. Unlike CLAUDE.md (which loads every session), skills load on-demand when you invoke them with a slash command.

They live at .claude/skills/<name>/SKILL.md. The directory name becomes the command. A skill at .claude/skills/test-and-commit/SKILL.md is invoked by typing /test-and-commit.

Ask Claude to create the skill by typing this prompt:

Create a custom skill at .claude/skills/test-and-commit/SKILL.md that automates the workflow we just did. It should: run the test suite with node --test, fix any failures and re-run until all pass, then stage all changes and commit with a descriptive message. Set disable-model-invocation to true so only I can trigger it.

Claude creates the directory structure and the SKILL.md file.
Verify the file exists by asking Claude:

Show me the contents of .claude/skills/test-and-commit/SKILL.md

The file should contain YAML frontmatter with a description and disable-model-invocation: true, followed by step-by-step instructions.

✔️ Awesome, I've got everything!

Great. Double check you have saved all files and your skill is committed.

ⓧ I'd like to double check the full code

Your SKILL.md should look like this:

---
description: Runs the test suite, fixes any failures, then commits with a descriptive message. Use when the user wants to verify and commit their work.
disable-model-invocation: true
---

## Instructions

1. Run the test suite with `node --test`
2. If any tests fail, read the error output and fix the failing code
3. Re-run tests until all pass
4. Stage all changes with `git add .`
5. Write a descriptive commit message summarizing what changed
6. Commit with `git commit`
7. Report what was committed

If your file is missing anything, ask Claude to update it to match this structure.

Why disable-model-invocation?

Setting disable-model-invocation: true prevents Claude from auto-triggering the skill. Since this skill commits code, you want to be the one who decides when it runs. Only you can invoke it by typing /test-and-commit.

Test the skill by typing:

/test-and-commit

Claude runs your test suite, confirms all tests pass, and commits. The entire workflow fires from a single command.

Skill not recognized?

Make sure the file is at .claude/skills/test-and-commit/SKILL.md (inside your project directory, not your home folder). The directory name test-and-commit becomes the slash command.

If the slash command still does not appear, try starting a fresh session with claude so it picks up the new skill.

Help me troubleshoot my custom skill

You now have a complete verification loop: tests that prove your code works, an agent that fixes failures autonomously, and a reusable skill that packages the whole workflow into one command. Next up, you will push this further by creating a specialized subagent that audits your code for security vulnerabilities.

Secret mission

Create a Security Reviewer Subagent

Subagents run in isolated context windows, keeping your main session clean while delegating specialized tasks. Build a security reviewer that audits your API for vulnerabilities in its own sandboxed environment.

Clean Up Your Resources

Decide whether to keep your resources running, pause them to come back later, or delete them entirely. This project runs entirely locally, so there are no ongoing costs.

Resources you used:

Local project directory (~/bookmark-api) containing your Node.js API, tests, CLAUDE.md, custom skill, and subagent configuration.
Claude Code sessions stored locally on your machine (no additional charges beyond your existing subscription).

Keep everything running

No action needed. Choose this if you're still actively building or experimenting with Claude Code in this project.

Your project stays on your machine at ~/bookmark-api.
There are no running processes or cloud resources to worry about.
You can resume a Claude Code session anytime by running claude inside the project directory.

Pause - I'll come back to this later

There are no running services to stop. Your files stay on disk until you return.

The project directory at ~/bookmark-api remains untouched.
No processes are running in the background. The Express server only runs when you explicitly start it.
When you're ready to return, open your terminal, run cd ~/bookmark-api, and start a new Claude Code session with claude.

Delete - I don't want to use this again

Remove all project files from your machine. This is permanent.

Delete the entire project directory by running this command:

rm -rf ~/bookmark-api

Confirm the folder is gone by running:

ls ~/bookmark-api

You should see a "No such file or directory" message.

What about Claude Code itself?

Claude Code is a general-purpose tool you can use across any project. Deleting the bookmark-api project does not remove Claude Code from your system.

If you want to keep using Claude Code on other projects, leave it installed. You can start a session in any directory by running claude.

That's a Wrap!

Nice work! You just built a fully tested REST API entirely by directing Claude Code from your terminal. Not a single line written by hand.

You've learned how to:

Built a complete REST API with CRUD operations and input validation without writing a single line of code by hand.
Created a CLAUDE.md that gives Claude Code persistent memory of your project conventions across sessions.
Set up a verification loop where Claude autonomously runs tests, catches failures, and fixes them until everything passes.
Secret Mission: Created a security reviewer subagent that audits your API code for vulnerabilities in its own isolated context.

Ready to quiz yourself?