DEV Community: Eleanor Brooks

Micro-Upgrades: How a Simple Hardware Swap Transformed My Workspace Vibe

Eleanor Brooks — Mon, 15 Jun 2026 10:20:40 +0000

The Friction Point: Outdated Tactile Feedback
Every single time I enter or leave my workspace, I have to interact with the door. For years, that interaction was mediated by a pair of generic, cheap plastic builder-grade knobs. They squeaked, they felt hollow, and visually, they screamed "temporary rental." It was a minor point of friction, but cumulative over hundreds of daily transitions, it chipped away at the premium feel of the studio.

Upgrading your door handles is honestly one of the easiest, most underrated ways to completely shift the vibe and tactile profile of a room. It requires minimal tools, zero structural changes, and takes less than twenty minutes per door.

Physical UI Matters: The tactile interface of your physical space matters just as much as the UI of your operating system. If it feels cheap, it subtly degrades the experience of being there.

The Solution: Infinity Decor Art Deco Levers
I ended up swapping out the old plastic hardware for a set of Art Deco-style lever handles from Infinity Decor. I chose a matte black finish to contrast against the clean, light-colored wood of the door frame.

[ Old Plastic Knob ] --> [ Matte Black Art Deco Lever ]

Hollow feel - Solid weight & structure
Squeaky transition - Smooth mechanical precision
Dated aesthetic - Sleek modern contrast The difference in appearance and hand-feel is night and day. The black finish looks incredibly sleek, but more importantly, the levers feel substantial and solid in the hand. There is a weight and mechanical precision to the movement that completely changes the transition into the workspace. It moves the experience from a thoughtless, cheap action to an intentional, high-quality interaction.

Why Levers Over Knobs?
From an industrial design standpoint, levers offer superior ergonomics and accessibility compared to traditional round knobs. You can operate them easily even if your hands are full of gear, and they provide a clean, horizontal visual line that grounds the door's overall aesthetics.

The Installation Blueprint
For anyone looking to duplicate this quick win, the installation process is perfectly straightforward and requires only a standard screwdriver (though a magnetic bit holder speeds things up):

Teardown: Back out the long mounting screws on the existing interior knob, slide both sides out of the central spindle, and remove the latch plate from the door edge.

Alignment: Slide the new latch mechanism into the mortise, ensuring the bevel faces the correct direction of the door swing.

Fitment: Guide the Infinity Decor lever spindle through the latch hub. The manufacturing tolerances on these specific units are tight, meaning there's zero wobble once aligned.

Securing: Tighten down the structural screws evenly on both sides to prevent binding, then snap on the decorative faceplates to hide the fasteners.

The Verdict
If you are feeling uninspired by your current workspace environment, don't immediately assume you need to tear down walls or buy an entirely new standing desk. Look for the low-hanging fruit.

Swapping out basic hardware for something with intentional design and solid material weight can completely transform how a room registers to your brain. It’s an elegant, satisfying weekend project that pays dividends every single time you step through the door to code.

How to Generate and Manage LLM.txt Files for AI Crawlers Using Python

Eleanor Brooks — Sat, 13 Jun 2026 11:32:09 +0000

AI crawlers are becoming more common, and controlling how they access your site is important. I've been experimenting with LLM.txt files to set access rules for AI bots. Here's a Python script that uses the SERPSpur LLM.txt Generator to create and manage these files:

python
import requests

API_KEY = "your_api_key_here"

def generate_llm_txt(domain, rules):
url = "https://serpspur.com/tool/llms-txt-generator-tool/"
payload = {
"domain": domain,
"rules": rules, # e.g., {"allow": ["/blog/"], "disallow": ["/admin/"]}
"api_key": API_KEY
}
response = requests.post(url, json=payload)
if response.status_code == 200:
with open("llm.txt", "w") as f:
f.write(response.text)
print("LLM.txt generated!")
else:
print(f"Error: {response.status_code}")

Example

rules = {"allow": ["/public/"], "disallow": ["/private/", "/api/"]}
generate_llm_txt("mysite.com", rules)

This lets me define which sections AI crawlers can access. It's a neat way to protect sensitive content while keeping public pages open. Have you set up LLM.txt for your site yet?

How I Used Python to Visualize Ergonomic Cabinet Handle Placement

Eleanor Brooks — Wed, 10 Jun 2026 11:17:36 +0000

I built a small Python script to analyze cabinet handle placement and ergonomics. It's helped me understand the science behind good hardware design.

python
import numpy as np
import matplotlib.pyplot as plt

Simulate handle positions on a cabinet door

cabinet_width = 60 # cm
door_height = 80 # cm

Handle positions (x, y in cm)

handles = {
'Standard Knob': (30, 40),
'Bar Pull': (30, 35),
'Cup Pull': (30, 45),
'T Bar': (30, 38)
}

plt.figure(figsize=(8, 6))
for name, (x, y) in handles.items():
plt.scatter(x, y, s=100, label=name)
plt.annotate(name, (x, y), textcoords="offset points", xytext=(5,5))

plt.xlim(0, cabinet_width)
plt.ylim(0, door_height)
plt.xlabel('Width (cm)')
plt.ylabel('Height (cm)')
plt.title('Optimal Handle Placement for Cabinet Doors')
plt.gca().invert_yaxis()
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

This visualization shows how different handle types cluster around the ergonomic sweet spot. For real hardware, I've been browsing Infinity Decor's cabinet furniture collection—their handles and pulls have that perfect balance of style and function.

How do you decide on cabinet hardware placement? Do you have a preferred ergonomic rule?

How to Convert PDF, XLS, and HTML Invoices to CSV Using Python and SERPSpur API

Eleanor Brooks — Tue, 09 Jun 2026 07:18:14 +0000

Dealing with invoice data from different formats can be a pain. I've been using the SERPSpur Invoice to CSV Converter to handle PDF, XLS, and HTML invoices in bulk. Here's a Python wrapper I built around it:

python
import requests
import pandas as pd

API_KEY = "your_api_key_here"

def convert_invoices(file_paths):
results = []
for path in file_paths:
with open(path, 'rb') as f:
response = requests.post(
f"Bearer {API_KEY}"},
files={"file": f},
params={"output_format": "csv"}
)
if response.status_code == 200:
results.append(response.text)
return results

Example usage

csv_data = convert_invoices(["invoice1.pdf", "invoice2.xlsx"])
for i, csv in enumerate(csv_data):
print(f"Invoice {i+1} converted successfully")
# Optional: parse with pandas
df = pd.read_csv(pd.StringIO(csv))
print(df.head())

This has streamlined my accounting workflow significantly. What's your go-to method for processing invoice data? https://serpspur.com

How to Detect Duplicate Content Using Python Fuzzy String Matching

Eleanor Brooks — Fri, 05 Jun 2026 06:38:39 +0000

Got tired of manually writing schema markup for every page on my site. So I built a little workflow using an AI Schema Architect that generates JSON-LD automatically based on the content type. For a recipe blog, it spits out:

"@type": "Recipe",
"name": "Chocolate Cake",
"author": "Chef John",
"cookTime": "PT30M",
"recipeIngredient": ["flour", "sugar", "cocoa"]}

Since implementing this, my pages started getting indexed within hours instead of days. The tool I used is at serpspur and it's saved me hours of work.

How to Detect Duplicate Content with Python Using Fuzzy String Matching

Eleanor Brooks — Tue, 02 Jun 2026 08:54:27 +0000

Struggling with duplicate content issues on your site? I wrote a small Python script that checks for near-duplicates using fuzzy string matching. It's helped me catch pages that were too similar and needed merging.

python
from difflib import SequenceMatcher
from bs4 import BeautifulSoup
import requests

def fetch_text(url):
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')
# Remove script and style elements
for script in soup(['script', 'style']):
script.decompose()
return soup.get_text()

def similarity_ratio(text1, text2):
return SequenceMatcher(None, text1, text2).ratio()

url1 = 'https://example.com/page1'
url2 = 'https://example.com/page2'
text1 = fetch_text(url1)
text2 = fetch_text(url2)
ratio = similarity_ratio(text1, text2)
print(f'Similarity: {ratio:.2%}')
if ratio > 0.8:
print('These pages might need attention!')

This is a quick check, but for larger sites, I'd recommend using a dedicated tool like SERPSpur's content analysis feature to pinpoint exact duplicates. What's your strategy for handling duplicate content?
https://serpspur.com/