Build a CLI Bookmark Manager

Master Claude Code workflows by building a Node.js CLI bookmark manager.

Introduction

30 Second Summary

You've probably tried asking an AI to write code and gotten back something that technically works but is a mess. One big file, no tests, no structure. The gap between "it runs" and "it's good" comes down to how you ask.

In this project, you will build a command-line bookmark manager using Claude Code, learning the workflow patterns that turn vague prompts into clean, multi-file, tested code.

What You'll Build

You'll type a single command from your terminal to save a bookmark, then instantly search and retrieve it by keyword, all built by Claude Code from your structured prompts.

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

  • A working CLI bookmark manager where you save a URL with a title and tags, then search for it by keyword across titles, URLs, and tags.
  • A CLAUDE.md file that gives Claude Code full project context from the very first prompt, so every session starts informed.
  • A repeatable Explore-Plan-Code-Commit workflow and session management toolkit you can apply to any project starting tomorrow.
  • Secret Mission: Create a custom Claude Code skill that summarizes your uncommitted changes and flags risks, usable across all your projects.

Are there any prerequisites?

You'll need a Claude subscription with Claude Code already installed, plus Node.js and Git on your machine. Comfort with the terminal is helpful but not required.

Before We Start

Before we dive in, let's lock in what you're about to build and why it matters. This step is your moment to commit to the goal before any hands-on work begins.

Set Up Your Project and Claude Code

Claude Code works best when it has context about your project from the start. Without a CLAUDE.md file and a version-controlled repository, every session begins from zero. Claude has to guess your preferences, tech stack, and file structure each time.

In this step, you will create a git repository, configure your project, and write a CLAUDE.md file that gives Claude Code the context it needs to produce quality output from the very first prompt.

In this step, get ready to:
  • Create a project directory with Git and a configured package.json.
  • Write a CLAUDE.md file that defines your project context for Claude Code.
  • Verify that Claude Code reads and acknowledges your project context.
Create your project directory and initialize Git
  • Move to your Desktop and create the project folder by running these commands:
cd ~/Desktop
mkdir bookmark-cli
cd bookmark-cli
git init

You should see Initialized empty Git repository in the output.

Don't see the initialized message?

Make sure you typed bookmark-cli exactly (with a hyphen, not a space). If you see fatal: not a git repository later, it means git init did not run in this folder. Run pwd to confirm you are inside ~/Desktop/bookmark-cli.

Need help? Why is git init not working in my terminal?

  • Scaffold a starting package.json by running:
npm init -y

You should see a JSON preview of the new file in your terminal output.

What does npm init -y do?

This command creates a package.json file with default values based on your folder name. The -y flag skips all the interactive prompts and accepts defaults.

The defaults from npm init -y need customizing. You need to set "type": "module" for ES module imports and point the entry to src/index.js.

  • Replace the contents of package.json by running:
cat > package.json << 'EOF'
{
  "name": "bookmark-cli",
  "version": "1.0.0",
  "description": "A command-line bookmark manager",
  "type": "module",
  "main": "src/index.js",
  "scripts": {
    "test": "node --test"
  }
}
EOF

What does this configure?

  • "type": "module" tells Node.js to use ES module syntax (import/export) instead of CommonJS (require).
  • "main": "src/index.js" tells Node.js where the entry point lives.
  • "test": "node --test" sets up the built-in Node.js test runner so you can run tests without installing any packages.
  • Confirm the file looks correct by running:
cat package.json

You should see the JSON with "type": "module" and "main": "src/index.js" printed in your terminal.

Write your CLAUDE.md file

CLAUDE.md is a special file that Claude Code reads at the start of every conversation. It gives Claude persistent context about your project so you do not have to repeat yourself each session.

  • Create CLAUDE.md in your project root by running:
cat > CLAUDE.md << 'EOF'
# Bookmark CLI

A command-line bookmark manager built with Node.js.

## Tech Stack
- Node.js with ES modules (import/export)
- No external dependencies for core functionality
- Node.js built-in test runner (node --test)

## Code Style
- ES modules syntax (import/export), not CommonJS (require)
- async/await for all asynchronous operations
- Descriptive function names, no abbreviations

## Structure
- Source files in src/
- Tests in tests/
- Entry point: src/index.js

## Workflow
- Run tests with: node --test
- Run the CLI with: node src/index.js <command> [options]
EOF

What does CLAUDE.md tell Claude Code?

  • Tech Stack tells Claude to use ES modules and avoid external dependencies.
  • Code Style sets expectations for async/await and naming conventions.
  • Structure tells Claude where to place source files and tests.
  • Workflow gives Claude the exact commands to run tests and the CLI.

Every time Claude Code starts in this folder, it reads this file automatically. No need to repeat instructions.

  • Confirm your project files exist by running:
ls

You should see CLAUDE.md and package.json in the output.

Missing a file?

If CLAUDE.md does not appear, the heredoc command may not have completed. Make sure you copied everything from cat > CLAUDE.md all the way through the final EOF line. The EOF must be on its own line with no spaces before it.

Help me figure out why my file was not created.

Commit and verify Claude Code reads your context
  • Save your project state with an initial commit by running:
git add .
git commit -m "Initial project setup"

You should see a commit summary showing two files changed.

Now for the real test. Before you start Claude Code, think about this: what do you expect Claude to know about your project when it launches?

  • Start Claude Code by running:
claude

What happens when Claude Code starts?

Claude Code automatically reads every CLAUDE.md file it finds in the project root and parent directories. This means it already knows your tech stack, code style, and structure before you type a single word.

  • Type the following into the Claude Code prompt:
What do you know about this project?

Claude should respond referencing details from your CLAUDE.md: the project name (Bookmark CLI), that it uses Node.js with ES modules, that source files go in src/ and tests in tests/.

  • Exit Claude Code by typing:
/exit

Claude doesn't mention your project details?

Make sure you are running claude from inside the bookmark-cli directory. Run pwd to check your location. If you are in the right folder, confirm CLAUDE.md exists by running ls.

Claude Code not picking up my CLAUDE.md. What should I check?

✔️ Awesome, I've got everything!

Great. Double check you have saved both files and committed them.

ⓧ I'd like to double check the full code

Here is exactly what each file should contain.

CLAUDE.md:

# Bookmark CLI

A command-line bookmark manager built with Node.js.

## Tech Stack
- Node.js with ES modules (import/export)
- No external dependencies for core functionality
- Node.js built-in test runner (node --test)

## Code Style
- ES modules syntax (import/export), not CommonJS (require)
- async/await for all asynchronous operations
- Descriptive function names, no abbreviations

## Structure
- Source files in src/
- Tests in tests/
- Entry point: src/index.js

## Workflow
- Run tests with: node --test
- Run the CLI with: node src/index.js <command> [options]

package.json:

{
  "name": "bookmark-cli",
  "version": "1.0.0",
  "description": "A command-line bookmark manager",
  "type": "module",
  "main": "src/index.js",
  "scripts": {
    "test": "node --test"
  }
}

Your project foundation is set. You have a git repo, a configured package.json, and a CLAUDE.md that gives Claude Code instant context. Next up, you will give Claude Code a deliberately vague prompt and see what happens when you skip structure.

Experience the Vague Prompt

Your project is set up with a CLAUDE.md and a clean git history. Now it's time to see what happens when you ask Claude Code to build something with zero guidance.

Most developers start with vague prompts and get mediocre results. You need to experience this firsthand to understand why structured prompting and plan mode exist. In this step, you'll intentionally give Claude Code the laziest possible prompt and observe the output.

In this step, get ready to:
  • Give Claude Code a deliberately vague prompt and let it build a bookmark manager.
  • Examine the resulting file structure and test the tool.
  • Commit the result and clear context for a fresh start.
Start Claude Code with a vague prompt

You have your CLAUDE.md ready, your git repo initialized, and your package.json configured. What happens when you throw a bare-bones request at Claude Code and let it run wild?

  • Start Claude Code by running this command in your bookmark-cli directory:
claude

Claude Code starts and reads your CLAUDE.md automatically. You'll see it acknowledge your project context.

  • Type this prompt into Claude Code exactly as written:
Build me a CLI bookmark manager
  • Let Claude Code work. It will ask permission to create and edit files.
  • Accept its file edits and command runs as they appear.
  • Wait until Claude Code finishes and returns to the input prompt.

What is Claude Code doing?

Claude Code reads your CLAUDE.md for context, then generates code to fulfill your request. With a vague prompt like this, it makes all the architectural decisions on its own. It might create a single file, skip tests entirely, or use a structure that doesn't match your CLAUDE.md conventions.

  • Once Claude Code finishes, exit the session by typing:
/exit
Examine what Claude Code produced

Before you test the tool, take a moment to predict what the file structure looks like. Do you think Claude Code created separate modules in src/ with matching test files in tests/? Or something simpler?

  • Check what files Claude Code created by running:
ls src/

You'll likely see a single file or a minimal set of files. The modular separation your CLAUDE.md requested (separate store.js, formatter.js) probably didn't happen.

  • Check whether Claude Code created any tests:
ls tests/

This will likely show nothing, or the directory may not exist at all. The vague prompt gave Claude Code no reason to prioritize testing.

Now the big question. Does it actually work? Before you run the tool, predict whether a basic list command will succeed.

  • Test the bookmark CLI by running:
node src/index.js list

It works. You'll see some kind of output indicating an empty bookmark list or a usage message. The code is functional.

What's the problem then?

The tool runs, but look at what you got. Everything is likely crammed into one or two files. There are no tests. The code style may not match the ES module conventions you specified.

This is the "it works but it's not good" result you get from vague prompts. It's functional enough to demo, but not structured enough to maintain, extend, or trust.

Getting an error when you run the command?

Claude Code's output is non-deterministic. If node src/index.js list throws an error, try node src/index.js without any argument. If that also fails, check the file Claude Code actually created. It may have used a different filename or path.

Help me debug the output Claude Code generated for my bookmark CLI

Commit the result and clear context

You'll reset this code in the next step and rebuild it properly. First, commit it so you have a snapshot to compare against later.

  • Commit all the files Claude Code generated by running:
git add -A && git commit -m "Vague prompt attempt"

You should see a commit summary listing all the files Claude Code created.

Seeing 'nothing to commit'?

This means Claude Code already committed the files during its work. That's fine. Run git log --oneline to confirm you can see the generated code in your history.

Why is git saying there's nothing to commit?

  • Now start Claude Code again to clear the context:
claude
  • Reset the conversation context by typing:
/clear

Claude Code starts a fresh session. All memory of the vague prompt conversation is gone.

  • Exit Claude Code by typing:
/exit

Why clear the context?

Claude Code carries the full conversation in its context window. If you start the next prompt in the same session, Claude will try to build on top of the vague prompt's messy output. Clearing context gives you a blank slate for the structured approach in the next step.

You've seen what a lazy prompt gets you. The tool works, but the code quality is poor. Next, you'll reset this attempt and rebuild the same tool using plan mode and a structured prompt. The difference will be dramatic.

Use Plan Mode and Structured Prompts

In the last step, you saw what a vague prompt produces. The code works, but it's a single-file mess with no tests and no separation of concerns.

Plan mode changes the game. It lets you review exactly what Claude Code intends to do before it writes a single file. Combined with a structured prompt that spells out your requirements, the same tool produces clean, modular, tested code.

In this step, get ready to:
  • Reset the project and start Claude Code in plan mode.
  • Give Claude Code a structured prompt with clear requirements.
  • Verify the new multi-file structure with passing tests.
Reset the project and enter plan mode

Before you can try the structured approach, you need to undo the vague prompt's output. Then you'll start Claude Code in a special mode that shows you the plan before any files are touched.

  • If Claude Code is still running from the last step, type /exit to close the session.
  • Remove the vague prompt commit by running this command:
git reset --hard HEAD~1
  • Confirm the reset worked by running:
ls src/

You should see that the vague prompt's files have been removed. Your project is back to just CLAUDE.md and package.json.

  • Start Claude Code in plan mode by running:
claude --permission-mode plan

What is plan mode?

Plan mode tells Claude Code to describe what it intends to do without actually writing files. You get to review the plan, ask questions, and request changes before anything touches disk.

You'll see plan mode on in the status bar confirming the mode is active.

Give Claude Code a structured prompt

The vague prompt was "Build me a CLI bookmark manager" with no further detail. This time you'll specify exactly what files to create, what each module does, and what patterns to follow.

  • Type this structured prompt into Claude Code:
Build a CLI bookmark manager with these requirements:
- Entry point: src/index.js that parses commands (add, list, delete)
- Storage: src/store.js that reads/writes bookmarks to a JSON file in ~/.bookmarks/data.json
- Formatting: src/formatter.js that outputs bookmarks with color using ANSI codes
- Each bookmark has: id (nanoid-style short hash), url, title, tags (array), createdAt (ISO timestamp)
- Tests for store.js and formatter.js using Node's built-in test runner
- No external dependencies for core functionality

Why does this prompt work better?

This prompt succeeds because it specifies the file structure, module responsibilities, data schema, testing approach, and constraints. Claude Code now has a clear target instead of guessing what you want.

Notice how each bullet maps to a separate file with a single responsibility. That's the structure you want in the output.

After you press Enter, Claude Code will think for a moment and then present its plan. It will describe the files it wants to create and what each one will contain.

Review the plan and let Claude Code build

Claude Code now shows you its proposed approach. This is the moment where plan mode pays off.

  • Read through the plan Claude Code proposes.
  • Look for proper module separation: src/index.js, src/store.js, src/formatter.js, and test files.
  • If you want to tweak the plan, press Ctrl+G to open it in your text editor.
  • When you're satisfied, press Shift+Tab to switch out of plan mode so Claude Code can implement it.

What does Shift+Tab do?

Shift+Tab cycles through Claude Code's permission modes. Pressing it moves you out of plan mode and into a mode where Claude Code can create and edit files. This is how you signal "go ahead and build it."

Claude Code will now create all the source files, test files, and run the tests itself. Let it work until it finishes.

Before you verify the result yourself, what do you think will happen when you run node --test? Will all tests pass, or will some fail?

  • Run the tests yourself to confirm:
node --test

You should see all tests passing with green checkmarks. Every test file in tests/ runs and reports success.

  • Test the CLI by adding a bookmark:
node src/index.js add https://example.com --title "Example" --tags dev,reference

You should see a green checkmark followed by a confirmation message showing the bookmark title and its generated ID.

  • List your bookmarks to see formatted, color-coded output:
node src/index.js list

You should see a formatted list with the bookmark title in cyan, the URL underlined, and the tags in brackets. Compare this to the vague prompt's plain output from the last step.

What changed between the two attempts?

Same tool, same project, dramatically different result. The vague prompt produced a single file with everything crammed together. The structured prompt produced separate modules in src/ with corresponding test files in tests/.

Plan mode gave you the chance to review before anything was written. The structured prompt gave Claude Code a clear target to hit.

  • Commit the result by running:
git add -A && git commit -m "feat: bookmark CLI with modular structure"

Tests failing or files missing?

If node --test shows failures, ask Claude Code to fix them. Type: "The tests are failing. Please read the error output and fix the issues."

If the src/ or tests/ directories are missing, Claude Code may not have finished implementing. Make sure you pressed Shift+Tab to exit plan mode and allowed Claude Code to complete its work.

Ask Claude Code for help.

You've just experienced the core lesson of Claude Code productivity. Next up, you'll learn the Explore-Plan-Code-Commit workflow for adding features iteratively to this project.

Add a Feature with EPCC

Your bookmark CLI can add, list, and delete bookmarks. Now you need to add a search feature so you can find bookmarks by keyword.

Real development is iterative. You rarely build everything in one shot. The Explore-Plan-Code-Commit (EPCC) workflow is how productive Claude Code users add features without losing context or creating messes.

In this step, get ready to:
  • Explore the codebase by having Claude Code summarize the architecture.
  • Plan the search feature before writing any code.
  • Implement the search command and commit the result.
Explore: have Claude understand the current state

Every feature addition starts with exploration. Before Claude Code writes new code, it needs to understand the existing architecture so it builds on top of it cleanly.

  • Return to your Claude Code session by running:
claude --continue

What does --continue do?

The --continue flag resumes your most recent session in the current directory. Claude picks up where you left off with the context from your previous conversation.

  • Ask Claude Code to explore the current architecture by typing this prompt:
Read the current src/ files and explain how bookmarks are stored and retrieved.

Claude Code reads through your source files and responds with a summary of how src/store.js handles data persistence and how src/index.js routes commands.

Why explore before coding?

The Explore step gives Claude Code a mental model of your existing architecture. Without it, Claude might duplicate logic that already exists or break conventions you established in earlier steps.

It also gives you a chance to verify Claude's understanding is correct before it starts writing code.

Plan: request a plan for the search feature

With the architecture fresh in Claude's context, you can now ask it to plan the search feature. The key phrase is "don't write code yet." This forces Claude to think through the design before touching any files.

  • Type this prompt to request a plan without implementation:
Plan a search command that finds bookmarks matching a keyword across title, URL, and tags. Show matched terms highlighted. Don't write code yet.

Claude Code responds with a plan describing what it will add to each file. Review it to make sure the approach makes sense.

  • Look for these elements in Claude's plan:
  • If something looks off, ask Claude to adjust the plan. For example, you could say "Also search across tags" or "Use yellow highlighting for matched terms."

Separating plan from code

Asking Claude to plan without coding is the cheapest mistake-prevention tool you have. Fixing a bad plan takes one sentence. Fixing bad code spread across four files takes much longer.

Code and commit: implement and verify

The plan looks good. Time to let Claude Code implement it and run the tests.

  • Tell Claude to implement the plan and run tests by typing:
Implement the search plan. Add tests for the search function. Run the tests after implementing.

Claude Code creates the search function, formatter, command wiring, and tests. It then runs node --test and shows you the results.

  • Confirm all tests pass in Claude's output. You should see every test marked as passing with no failures.
  • Run the tests yourself to double-check by typing this in Claude Code:
node --test

Tests failing?

If you see test failures, tell Claude Code what went wrong. Paste the error message directly into the prompt and ask it to fix the issue. Claude has the full context of what it just wrote.

If tests pass for Claude but fail when you run them manually, you may have a stale terminal. Exit Claude Code and run node --test from a fresh terminal in your bookmark-cli directory.

Help me debug failing tests in my bookmark-cli project

Now test the search command manually. Before you run this, what do you think will happen if you search for a term that matches a bookmark you added earlier?

  • Add a test bookmark so you have something to search for:
node src/index.js add https://example.com --title "Example Site" --tags dev,reference
  • Search for it by running:
node src/index.js search "example"

You should see your bookmark displayed with the word "example" highlighted in yellow wherever it appears in the title, URL, or tags.

What is ANSI highlighting?

The yellow highlighting uses ANSI escape codes. These are special character sequences that terminals interpret as color instructions. The formatSearchResults function wraps matched text in \x1b[33m (yellow) and \x1b[0m (reset) so your terminal renders it in color.

  • Finally, tell Claude Code to commit the feature:
Commit with a descriptive message

Claude Code stages the changes and commits with a message describing the search feature.

Why let Claude write the commit message?

Claude Code has full context of every file it changed and why. Its commit messages tend to be more descriptive than what you'd write by hand after a long session. You can always ask it to reword the message if you want a different style.

You just added a complete feature using a repeatable workflow. Next up, you'll learn how to manage Claude Code sessions so they stay fast and focused across days of work.

Manage Sessions and Boost Productivity

Your bookmark CLI now has add, list, search, and delete commands with tests passing across the board. The EPCC workflow got you there in a structured, predictable way.

Long Claude Code sessions fill up the context window over time. When that happens, responses get slower and less accurate. In this step, you'll learn how to manage sessions so Claude Code stays sharp across days of work on the same project.

In this step, get ready to:
  • Compact and check your context window usage.
  • Resume a previous session and add a feature with a quick prompt.
  • Use non-interactive mode to pipe code into Claude for instant feedback.
Practice context management

Every prompt and response you exchange with Claude Code fills the context window. Once it's full, Claude starts forgetting earlier details. Three built-in commands help you stay in control.

  • In your running Claude Code session, summarize the conversation and free up context space by typing:
/compact

Claude Code condenses everything you've discussed into a short summary. You'll see it print a confirmation that context has been compacted.

  • Check how much of the context window is currently in use by typing:
/context

You'll see a readout showing the percentage of context consumed. After compacting, this should be significantly lower than before.

  • Exit Claude Code by typing:
/exit

Your terminal prompt returns. The session is saved and ready to resume later.

When should I compact?

Compact when you notice Claude Code's responses becoming less relevant or when you're switching to an unrelated task within the same project. You can also run /compact with a focus keyword (like /compact search feature) to keep specific context while discarding the rest.

Use /clear instead when you want a full reset between completely unrelated tasks.

Resume and continue work

Real development happens across multiple sessions. You close your laptop, come back the next day, and need Claude Code to remember what you were working on.

  • Resume your most recent session by running this command in your terminal:
claude --continue

Claude Code picks up where you left off. It loads the compacted context from your previous session.

  • Confirm that Claude Code remembers your project by typing this prompt:
What have we built so far?

Claude should respond with a summary that mentions the bookmark CLI, its commands (add, list, search, delete), and the modular file structure. This proves the compacted context survived the session break.

What about --resume?

Use claude --continue to jump straight back into your last session. Use claude --resume when you want to pick from a list of previous sessions.

  • Add a --limit flag to the list command by giving Claude Code this prompt:
Add a --limit flag to the list command that shows only the N most recent bookmarks. Run the tests.
  • Let Claude Code implement the feature and run the tests. Accept its file edits when prompted.
  • Verify the feature works by running this command once Claude finishes:
node src/index.js list --limit 1

You should see only one bookmark in the output (the most recent one you added). The full list still works without the flag.

Not seeing the limited output?

If all bookmarks still appear, Claude Code may not have saved the changes. Check that src/index.js now parses --limit from the arguments and passes it to listBookmarks(). Ask Claude Code: "Show me how the list command handles --limit."

help me debug why my --limit flag isn't filtering bookmarks

  • Commit the feature by typing this in Claude Code:
Commit with a descriptive message
  • Exit Claude Code by typing /exit.
Use non-interactive mode for quick tasks

Sometimes you don't need a full conversation. You just want Claude to look at something and give you an answer. Non-interactive mode handles this without starting a session.

Before you run the next command, what do you think will happen when you pipe a file's contents directly into Claude Code with the -p flag? Will it open an interactive session, or do something else?

  • Pipe your store file into Claude Code for a quick review by running:
cat src/store.js | claude -p "Review this file for potential bugs or improvements. Be brief."

Claude reads the file, prints its analysis directly in your terminal, and exits. No interactive session. Your terminal prompt returns immediately after the output.

Where does non-interactive mode shine?

The claude -p pattern works anywhere you'd use a Unix pipe. You can use it in shell scripts, CI pipelines, git pre-commit hooks, or just as a quick one-off review without the overhead of a full session.

Command hangs or returns an error?

Make sure you're running this from your bookmark-cli project directory where src/store.js exists. If you get an authentication error, run claude interactively once to confirm your login is active, then try the piped command again.

help me troubleshoot the piped claude -p command

You now have the full toolkit for keeping Claude Code productive over long projects. Next up, you'll create a custom skill that works across all your projects.

Secret mission

Create a Custom Skill

You've mastered the Claude Code workflow for a single project. Now create a custom skill that summarizes your uncommitted changes and flags risks. It works across all your projects, not just this one.

Clean Up Your Resources

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 beyond your existing Claude subscription.

Resources you used:

  • Project directory: ~/Desktop/bookmark-cli (your bookmark CLI source code, tests, and CLAUDE.md).
  • Bookmark data: ~/.bookmarks/data.json (local file storing any bookmarks you saved).
  • Personal skill: ~/.claude/skills/summarize-changes/ (your custom Claude Code skill).

Keep everything running

No action needed. Choose this if you plan to keep using the bookmark CLI as a real tool and want the summarize-changes skill available across all your projects.

  • Your bookmark CLI works as a real tool. Run node src/index.js add <url> any time you want to save a link.
  • Your /summarize-changes skill works in every git project on your machine.
  • Your CLAUDE.md gives Claude Code full context whenever you return to this project.

Pause - I'll come back to this later

Since everything is local files with no running processes or cloud resources, there is nothing to pause. Your files stay on disk and cost nothing.

  • All project files remain at ~/Desktop/bookmark-cli until you decide to delete them.
  • Your bookmark data stays at ~/.bookmarks/data.json and will be there when you come back.
  • Your skill remains available globally at ~/.claude/skills/summarize-changes/.

Delete - I don't want to use this again

Remove all project resources and start fresh. Run these commands to delete everything this project created.

  • Delete the project directory by running:
rm -rf ~/Desktop/bookmark-cli
  • Delete your bookmark data by running:
rm -rf ~/.bookmarks
  • Delete the custom skill by running:
rm -rf ~/.claude/skills/summarize-changes
  • Confirm everything is removed by running:
ls ~/Desktop/bookmark-cli ~/.bookmarks ~/.claude/skills/summarize-changes

You should see "No such file or directory" for each path.

Nice Work!

Nice Work!

You just built a fully functional CLI bookmark manager and, more importantly, developed a repeatable Claude Code workflow you can apply to any project starting tomorrow.

You've learned how to:

  • Build a multi-file CLI tool entirely through Claude Code prompts, experiencing firsthand how plan mode and structured prompts transform output quality compared to vague requests.
  • Apply the Explore-Plan-Code-Commit (EPCC) workflow to add features iteratively without losing context or creating messes.
  • Manage Claude Code sessions with /compact, --continue, /clear, and non-interactive mode (claude -p) to stay productive across long projects.
  • Secret Mission: Created a reusable /summarize-changes skill with YAML frontmatter and live git diff injection that works across all your projects.

Ready to quiz yourself?