Introduction: The Problem Isn’t Lack of Resources

If you’re learning to code, you don’t have a resource problem.

You have a processing problem.

You already have:

• A bookmarks bar full of “read later” links
• Tutorial tabs permanently open
• Saved Twitter/X threads, Discord messages, YouTube playlists
• A growing pile of “I’ll come back to this” in your notes app

Most of this never turns into real skills, code, or projects. It just quietly piles up and makes you feel behind.

The fix isn’t more tools or better resources. It’s a tiny, repeatable routine that turns random links into progress.

This post walks you through a simple workflow: The Three-Bookmark Coding Routine. It’s deliberately small, visual, and low-friction. By the end, you’ll have a concrete system you can set up in 20–30 minutes and actually stick to.

The Core Idea: Three Bookmarks, One Flow

Forget elaborate knowledge management systems. You only need three buckets:

1. Inbox – Random, interesting, unprocessed links
2. In Progress – Links you’re actively working through
3. Library – Links you’ve processed, summarized, and can reuse

Almost every coding resource you save should follow this path:

Random → Captured → Processed → Applied

The three-bookmark routine is about designing a tiny workflow that moves each link along that path with minimal friction.

Why three?

• Fewer choices → fewer decisions → more follow-through
• You always know what to do next
• You avoid the “30 tags, 12 folders, 0 consistency” trap

You can implement this with:

• Browser bookmarks (three folders)
• A note-taking app (three main pages/sections)
• A simple wiki or dashboard (Notion, Obsidian, Logseq, etc.)

The tool doesn’t matter. The flow does.

Step 1: Build Your Three-Bookmark Structure

Create three top-level folders or pages named exactly:

1. 01 – Inbox
2. 02 – In Progress
3. 03 – Library

The numbers keep them ordered and visible.

1. Inbox: Capture Without Thinking

Rules:

• Any link you might care about goes here
• No reading required before saving
• No tagging required on capture

Goal: Make capture brainless. You see something potentially useful? It goes into 01 – Inbox.

Your only job at this stage: don’t lose the link.

2. In Progress: Commit to a Few Things

This is your short, focused queue.

Rules:

• Max 3–5 items allowed at a time
• These are the links you’ve chosen to actively work on
• You’re either reading, coding along, or experimenting with them

If your In Progress is full, you must finish or drop something before adding a new link. This forces you to be realistic.

3. Library: Only Processed, Tagged, and Summarized

This is not a graveyard. It’s your personal coding knowledge base.

A link only enters the Library if it meets three criteria:

1. You’ve read or worked through it
2. You’ve created at least one tiny action (snippet, note, or experiment)
3. You’ve added a short summary and tags

Your Library becomes a place future-you can search and reuse, not a random dump.

Step 2: Add a Tiny Action to Every Link

Information doesn’t become skill until you do something with it.

For every In Progress link, pair it with a tiny action:

• A code snippet you write yourself
• A note capturing the key idea in your own words
• A mini-experiment in a scratch file or REPL

Examples:

• Reading a JavaScript article? → Recreate the main example from memory in a js-scratchpad.js file.
• Watching a React video? → Build a 20-line demo that uses the hook they explained.
• Browsing a data structures tutorial? → Implement the structure in your own repo and add one extra method.

This doesn’t need to be big. The goal is:

One link → one small artifact.

This shift turns your system from passive hoarding into active learning.

Step 3: Design the Flow: Random → Captured → Processed → Applied

Now let’s make the workflow explicit.

Stage 1: Random → Captured (Inbox)

Trigger: You find something interesting.

Action:

• Hit your “save to Inbox” shortcut (bookmark, extension, or share-sheet)

Design note:

• Absolutely no extra decisions here
• The question “Is this really worth it?” comes later

Stage 2: Captured → Processed (Inbox → In Progress)

Pick a regular time: e.g., 10–15 minutes every day or 30 minutes twice a week.

During review:

1. Open 01 – Inbox
2. For each item, choose:
   • Delete – not actually useful
   • Defer – leave in Inbox
   • Do – move to 02 – In Progress (if there’s space)

When you move something to In Progress, define its tiny action:

• Write a 1-line goal: “Implement the main example and tweak it.”
• Or: “Summarize this in 5 bullet points and try it on my side project.”

Stage 3: Processed → Applied (In Progress → Library)

Once you:

• Complete the tiny action
• Feel you’ve extracted the main value of the link

Then you:

1. Move it to 03 – Library
2. Add three things:
   • Title – Clear and searchable
   • Summary (2–4 bullets) – What did you actually learn?
   • Tags – Language, topic, and context

Example entry in your Library:

Title: Debouncing vs Throttling in JavaScript (Article)

Summary:

• Debounce: wait until the user stops triggering the event
• Throttle: run at most once within a time interval
• Great for scroll, resize, search inputs
• Implemented both in js-utils/debounceThrottle.js

Tags: javascript, frontend, performance, utils

You now have knowledge you can search, reuse, and build on.

Step 4: Make It Visual and Low-Friction

Your system should be something you actually see and touch daily.

A few options:

• Browser-only: Three folders on your bookmarks bar: Inbox / In Progress / Library
• Notion/Obsidian: A simple database or page with three views
• Kanban-style board: Columns named Inbox / In Progress / Library

Design principles:

• One-click capture – Use a browser extension / bookmarklet
• One-screen overview – You can see all In Progress links at once
• Zero fancy features required – Avoid automation rabbit holes

You are not building a “productivity setup.” You’re building a habit-friendly workflow.

Step 5: Add Lightweight Tags and Naming

Your future self should be able to find things in seconds.

Use simple, consistent tags:

• Language: python, javascript, go, rust
• Domain: backend, frontend, devops, ml
• Type: article, video, doc, issue, answer
• Use-case: testing, performance, refactoring, design-patterns

And standard naming patterns, e.g.:

[Topic] – [Specific Focus] (Type)

Examples:

• React – useEffect patterns (Article)
• Python – list comprehensions cheatsheet (Doc)
• PostgreSQL – indexing basics (Video)

Don’t over-engineer this. Two goals only:

1. You can search by tag and immediately filter
2. Titles make sense when you glance at your Library

Step 6: Prune Regularly to Avoid Information Hoarding

A system that only grows becomes unusable.

Schedule a review once a week (15–20 minutes):

1. Inbox cleanup

   • Delete anything that no longer feels relevant
   • If something has sat untouched for weeks, either:
     • Move it to Someday (optional fourth folder), or
     • Admit it’s not important and delete it

2. In Progress reality check

   • If you haven’t touched a link in 2+ weeks, either:
     • Commit to finishing it this week, or
     • Move it back to Inbox or delete

3. Library sharpening

   • Skim a few old entries
   • Improve summaries or tags if they’re too vague
   • Mark especially useful ones as favourites or core

Pruning keeps your system lean and trustworthy. When you open it, you know you’re looking at signal, not noise.

Example: A Day Using the Three-Bookmark Routine

Imagine your day:

• Morning: You see a tweet about a great blog post on database indexing → save to Inbox.
• Lunch: You find a YouTube playlist on React performance → last video you needed, so you ignore; first one looks great → save to Inbox.
• Evening review (15 minutes):
  • You scan Inbox (10 items)
  • Delete 3 that aren’t really relevant
  • Move the database indexing article to In Progress with a tiny action: “Read section 1–2 and create 1 example query in my test DB.”
  • Move the first React performance video to In Progress with a tiny action: “Apply 1 optimization to my side project.”
• Coding session:
  • You do the tiny actions for the database article
  • You move the article to Library, with a short summary and tags

By the end of the week, you may only have fully processed 3–5 links—but each one became:

• Code in your repo
• Notes in your own words
• A searchable entry in your Library

That’s real progress.

Conclusion: Small System, Compounded Learning

The Three-Bookmark Coding Routine isn’t meant to impress anyone. It’s meant to be used.

• Three folders or views: Inbox → In Progress → Library
• Every link gets a tiny action before it’s “done”
• Each step moves you from random → captured → processed → applied
• Light tags, short summaries, and consistent naming make your knowledge reusable
• Regular pruning keeps the system focused and trustworthy

You don’t need a perfect system. You need a small, durable one that quietly turns your pile of random links into skills, code, and confidence.

Set up your three bookmarks today, and let tomorrow’s learning flow through them.