The Box of Old Cables No Developer Should Throw Away

⏱️ Lectura: 13 min

A developer printed out a Bluesky post, trimmed it with a paper cutter, and taped it onto his cable box. The line that saved years of loose cables from the trash read, in essence: never let anyone take away your cable box.

📑 En este artículo

1. TL;DR
2. What happened
3. Context and history
4. Technical details and performance
5. How to start organizing your own cable box
6. Impact and analysis
7. What’s next
8. Frequently Asked Questions
   1. Why do developers keep old cables instead of throwing them away?
   2. Which cables are worth keeping in 2026?
   3. How do I organize a cable box without losing hours searching for one?
   4. Does keeping cables actually help reduce electronic waste?
   5. Does it make sense to keep a proprietary cable the brand no longer manufactures?
   6. How do I move my cable inventory from paper to something digital?
9. References

Jim Nielsen tells the story on his personal blog, and it sums up something almost every developer with more than five years in the trade knows by heart: that box full of “useless” cables in the closet ends up saving a project, sooner or later.

TL;DR

• Tyler Gaw shared on Bluesky that he found two cables he needed at the bottom of his box after more than ten years in storage.
• Jim Nielsen recounted the episode on blog.jim-nielsen.com under the title “Don’t Let Anyone Take Away Your Big Box of Cables.”
• Nielsen printed the post, trimmed it, and taped it onto his box, nicknamed FAMILY TECHNO BOX by his wife.
• The anecdote sums up a widespread practice among developers: keeping old cables as a hardware backup.
• USB-C and HDMI dominate today, but VGA, Molex, and proprietary power barrel connectors are still found on equipment over a decade old.
• Keeping cables reduces the need to buy replacements and delays that hardware ending up as e-waste.
• A simple Python script, with no external dependencies, lets you catalog a cable box in minutes.

What happened

It all started with a Bluesky post by Tyler Gaw, a designer and developer who shared something very simple: he dug through the bottom of his cable box looking for two specific pieces he needed for a project. He found them. They had been sitting there, unused, for more than ten years. His conclusion, summed up in a single line, went viral among developers: “never let anyone take away your cable box.”

Jim Nielsen read that post and wrote about it on his personal blog, blog.jim-nielsen.com, under the title “Don’t Let Anyone Take Away Your Big Box of Cables.” But Nielsen didn’t stop at sharing the link: he took a screenshot of the post, printed it in black and white on a Brother printer, cut it out with scissors, and taped it with clear tape onto the front of his own cable box, the same one his wife labeled years ago as “FAMILY TECHNO BOX.”

By his own account, the idea is that every time he opens that box to toss in “one more cable” (YAC, yet another cable, as his own inside joke goes), the taped-on paper reminds him why he keeps it, and doubles as a warning to any family member tempted to throw it out. Nielsen even speculates that, someday, his kids will find that box in the attic among his belongings, with the message still taped on top.

Context and history

Keeping cables “just in case” isn’t a modern quirk: it’s a habit as old as home electronics itself, and among developers and makers it has an almost folkloric name: the junk drawer, the cable box, the adapter corner. Before the cloud existed, before git, and before automatic backups, the only way to have hardware redundancy was to literally keep the hardware.

That logic connects to a much bigger problem: electronic waste. Every cable, charger, or adapter that gets discarded ends up, at best, at a recycling point, and at worst, in a landfill. Electronic waste is today one of the fastest-growing waste categories in the world, driven precisely by the habit of buying a new cable instead of checking whether a working one is already sitting in storage.

💭 Key takeaway: every time you solve a problem with a cable you already had instead of buying a new one, you’re not just saving money: you’re subtracting one more unit from the global e-waste pile.

The right-to-repair movement has been pointing this out for years: repairability and the availability of spare parts (including cables and adapters) are the difference between a device that lasts a decade and one that ends up in the trash at the first problem. Keeping a cable box is, at its core, a practice aligned with that same philosophy, even if no one has formally branded it that way.

Technical details and performance

Not all cables age the same way, and not all of them deserve the same space in the box. The table below summarizes the most common types that tend to pile up in any developer’s cable box and whether they’re worth keeping:

Cable type	Devices that still use it	Worth keeping?	Why
USB-A to Micro-USB	Old peripherals, some routers, dev boards	Yes	Still the standard on many Arduino boards and embedded hardware
USB-C	Modern laptops, phones, tablets	Yes	It’s the current standard; there’s always a need for a longer one or one with fast charging
HDMI	Monitors, TVs, consoles	Yes	No universal replacement in sight; older monitors still use it
VGA / DVI	Old projectors and industrial monitors	Depends	Increasingly rare, but saves the day in offices with legacy hardware
Power barrel (DC jack)	Routers, switches, old networking hardware	Yes	Every manufacturer uses a different diameter; impossible to guess which one you need
Molex / SATA power	Internal hard drives, old cases	Depends	Useful if you still build or repair desktop PCs
Ethernet Cat5e / Cat6	Home networks, home servers, home labs	Yes	Cheap to replace, but you always need one of the exact right length

The pattern repeats: standardized connectors (USB-C, HDMI, Ethernet) are worth keeping because almost every new device uses them today. Proprietary or discontinued connectors (a power barrel from a brand that no longer exists, a rare VGA adapter) are worth keeping for the opposite reason: they’re impossible to track down the day you actually need them.

To avoid digging through the box cable by cable every time, a simple inventory solves the problem. You don’t need a complex app: a script of a few lines is enough. Here’s a minimal example in Python, with no external dependencies, that saves the inventory to a local JSON file:

import json
from pathlib import Path

INVENTARIO = Path.home() / ".cablebox.json"

def cargar():
    if INVENTARIO.exists():
        return json.loads(INVENTARIO.read_text())
    return []

def guardar(cables):
    INVENTARIO.write_text(json.dumps(cables, indent=2, ensure_ascii=False))

cables = cargar()
cables.append({"tipo": "USB-C to HDMI", "nota": "for the office monitor"})
guardar(cables)
print(f"Cables cataloged: {len(cables)}")

With that, you already have basic persistence: every cable you add is saved to ~/.cablebox.json and isn’t lost between restarts. The next step is turning it into a real CLI with subcommands to add and search, using only the standard argparse library:

import argparse
import json
from pathlib import Path

INVENTARIO = Path.home() / ".cablebox.json"

def cargar():
    return json.loads(INVENTARIO.read_text()) if INVENTARIO.exists() else []

def guardar(cables):
    INVENTARIO.write_text(json.dumps(cables, indent=2, ensure_ascii=False))

parser = argparse.ArgumentParser(prog="cablebox")
sub = parser.add_subparsers(dest="comando", required=True)

add_p = sub.add_parser("add")
add_p.add_argument("--tipo", required=True)
add_p.add_argument("--nota", default="")

find_p = sub.add_parser("find")
find_p.add_argument("--query", required=True)

args = parser.parse_args()
cables = cargar()

if args.comando == "add":
    cables.append({"tipo": args.tipo, "nota": args.nota})
    guardar(cables)
    print(f"Added: {args.tipo}")
elif args.comando == "find":
    resultados = [c for c in cables if args.query.lower() in c["tipo"].lower()]
    for r in resultados:
        print(f"- {r['tipo']}: {r['nota']}")

With this second version, cataloging a new cable is one command (cablebox add --tipo "..." --nota "...") and finding it is another (cablebox find --query "hdmi"). The maintenance cost is minimal compared to the time lost digging through a physical box looking for “that cable I know I have.”

To quickly decide whether a new cable goes into the box or straight to recycling, this decision tree sums up the criteria:

flowchart TD
    A["New cable to evaluate"] --> B{"Is it broken or frayed?"}
    B -->|"Yes"| C["Recycle it at an e-waste point"]
    B -->|"No"| D{"Is it a standard connector (USB, HDMI, Ethernet)?"}
    D -->|"Yes"| E["Keep it: high chance of reuse"]
    D -->|"No, it's proprietary or discontinued"| F["Keep it anyway: it'll be impossible to find again"]

How to start organizing your own cable box

Replicating Nielsen’s system doesn’t require anything sophisticated. Here are the concrete steps:

1. Take all your cables out of storage and lay them on a table.
2. Set aside the ones that are physically damaged (frayed, with a broken connector) and take them to an e-waste recycling point.
3. For the rest, photograph each one with your phone next to a piece of paper describing it.
4. Save the cablebox.py script in your personal projects folder and catalog each cable with the add command.
5. Put everything back in the box, but this time with the digital inventory as backup.

To run the script you don’t need to install anything besides Python 3, which comes preinstalled on macOS and most Linux distributions. On Windows you’ll need to install it first from python.org or from the Microsoft Store.

💡 Tip: label the box on the outside, like Nielsen did. A taped-on note explaining why you keep it is worth more than a thousand explanations when someone else at home wants to “make space.”

The commands to run the inventory are practically identical across all three operating systems, since Python uses the same syntax on all of them:

# Linux
python3 cablebox.py add --tipo "USB-C to HDMI" --nota "monitor adapter"

# macOS
python3 cablebox.py add --tipo "USB-C to HDMI" --nota "monitor adapter"

# Windows (PowerShell)
python cablebox.py add --tipo "USB-C to HDMI" --nota "monitor adapter"

The only real difference is the binary name: python3 on Linux and macOS, and python on Windows (unless you’ve manually configured the alias). To confirm the inventory was saved, just open the generated file:

# Linux / macOS
cat ~/.cablebox.json

# Windows (PowerShell)
Get-Content $HOME\.cablebox.json

Impact and analysis

What makes this anecdote interesting isn’t the box itself, but what it represents: a way of thinking about systems that any developer recognizes immediately. Keeping hardware “just in case” is exactly the same instinct that drives backups, replicas, and redundancy in a production system’s infrastructure. No one designs a critical system with a single point of failure; no one should get rid of the only low-cost source of spare parts they have on hand, either.

In Latin America, that calculation carries even more weight. Buying a specific cable or adapter in countries with high import tariffs on electronics, or in cities where the nearest specialty store is hours away, can mean weeks of waiting and several times the list price in the United States. Having a well-organized cable box isn’t just convenience: it’s avoiding an unnecessary expense or delay in the middle of a project.

The flip side is clutter. A cable box with no criteria at all becomes, sooner or later, indistinguishable from the trash it’s supposed to prevent generating. That’s why cataloging, even one as simple as the script in this article, is what separates “I have a spare-parts system” from “I have a drawer nobody wants to open.”

What’s next

The long-term trend points to fewer and fewer different connector types in circulation. The consolidation around USB-C as the single standard for charging and data on laptops, phones, and peripherals reduces, year after year, the number of obscure adapters needed. But that consolidation takes decades to complete: there are still servers, switches, monitors, and lab hardware in use that depend on connectors that stopped being manufactured years ago.

In the meantime, the cable box, physical, cataloged, or both, remains the cheapest way to have hardware redundancy on hand. The next time someone suggests throwing out those old cables that supposedly serve no purpose, it’s worth asking first how much it would cost, in time and money, not to have them the day they actually do.

📖 Summary on Telegram: View summary

Try it today: open your own cable box, set aside anything broken, and catalog the rest with the cablebox.py script from this article before you get the urge to throw out that odd cable that seems useless.

Frequently Asked Questions

Why do developers keep old cables instead of throwing them away?

Because they work as a low-cost spare-parts inventory. A cable or adapter that seems useless today can be, a few years from now, the only cheap and fast way to connect legacy hardware that’s still in production.

Which cables are worth keeping in 2026?

Current standards (USB-C, HDMI, Ethernet Cat5e/Cat6) because almost every new device still uses them, and proprietary or discontinued connectors because they’re impossible to track down the day you actually need them.

How do I organize a cable box without losing hours searching for one?

With a simple catalog: a JSON file or a spreadsheet where you note the cable type and what it’s for is enough. The Python script in this article is a working starting point in under thirty lines.

Does keeping cables actually help reduce electronic waste?

Yes, to the extent that it avoids buying a replacement when a working unit is already available. Every avoided purchase is one less unit that eventually ends up as e-waste.

Does it make sense to keep a proprietary cable the brand no longer manufactures?

Yes, for exactly that reason: if the manufacturer discontinued that connector, the only way to replace it the day it breaks is to already have a spare one put away.

How do I move my cable inventory from paper to something digital?

Photograph each cable, jot down its type and a usage note, and enter that information with the add command from this article’s script. Everything stays in a local JSON file you can version or back up like any other data.

References

• Don’t Let Anyone Take Away Your Big Box of Cables: Jim Nielsen’s original post that started this story.
• Electronic waste, Wikipedia: general context on the growth of electronic waste.
• iFixit: reference for the right-to-repair movement and the availability of spare parts.
• Bluesky: the social network where Tyler Gaw posted the original message that inspired Nielsen.

📱 Enjoy this content? Follow @programacion on Telegram for daily tech content in Spanish: quick summaries, fresh content every day.

Imagen destacada: Foto de Brett Jordan en Unsplash