Headphones were the best focus money I ever spent too, though it is mildly depressing that the accepted fix for an open office is "engineer your way out of the open office".

The thing that helped more than I expected alongside them was timeboxing - noise is far easier to tolerate when you know it only has to be survivable for 25 minutes rather than indefinitely. I keep an aggressively simple pomodoro app around for that (potatotimer): no streaks, no accounts, no productivity dashboard judging me, just a timer that shuts up when it's done.

"It still shows up by some kind of witchcraft, put it back" deserves to be printed and framed.

To be fair to him, if your entire mental model of a website is "files that contain the words", then viewing source and not finding the nav is genuinely unsettling. I have some sympathy for keeping assets as plain visible files for that reason - it's roughly why I ended up building a small thing called ghcdn, which just turns a file sitting in a GitHub repo into a CDN URL you can drop straight into a script tag. Still one file, still readable in the repo, just not copy-pasted into twelve pages.

Months of training undone by a single paste is the most realistic part of this. He almost certainly felt efficient doing it too - password manager for storing, chat for sending, no perceived contradiction between the two.

The only thing that ever worked for me was making the safe path faster than the unsafe one instead of adding another rule: a one-time link they paste into the thread that dies the moment it's read. I built a tiny thing for exactly that (s3cr3tm3.netlify.app) after one too many credentials went permanently into someone's scrollback. Doesn't help with the medical records part, sadly.

A board of notes rather than a text editor is a real distinction and I don't think most note apps respect it - they assume you want a document when what you want is a surface. Also, genuine respect for actually shipping after a year on it.

Cross-device is the wall everyone hits. I built a small markdown notes app too and eventually made peace with it by going local-first: autosave to the browser, no accounts, no sync, and treating that as a feature instead of a permanent todo. Cost me nothing to maintain since. Curious which way you end up going, because the subscription-free version of sync is genuinely hard.

tp.file.include is one of those functions that quietly deletes half your template folder the day you find it. Nesting instead of copy-pasting the same header block into six files, then remembering to edit all six - that specific chore is gone forever now.

Obsidian's plugin layer really is its best feature. I went down the same rabbit hole and ended up writing one to sync a vault to and from Notion (obsidotion), mostly so I could stop maintaining the same notes in two places. Templater is still the first thing I'd reinstall on a fresh vault though.

Turning an old machine into a headless server is great right up until the ethernet port dies and you're configuring WiFi over the exact link you're about to reconfigure. Hand-editing netplan YAML, running apply, and watching your own SSH session decide whether you still have a job - a rite of passage nobody asked for.

Got annoyed enough at that loop to build a small terminal UI for it (oaifai): lists the networks with signal strength, arrow down, type the password, and it rolls back to the previous network if the new one fails so you don't lock yourself out of the box. Good luck with the build, that recycled-hardware feeling is worth the pain.

Letting the template layer run SQL is one of those features that must have felt like a productivity breakthrough for roughly six weeks.

The detail that really stings is "the designers knew basic SQL but not injection" - they were handed a loaded footgun and told it was a filter, so of course they concatenated request data into it. That failure mode is why the little templating helper I ended up writing (str_template) does exactly one thing: substitute {placeholders} into a string. No logic, no data access, deliberately too boring to ever become an incident report.

The interesting half of this is the parsing, not the flashcards. OCR on a phone photo of a glossy textbook page is genuinely rough - glare, curved spine, two columns - so I'd get that pipeline behaving before touching the card UI, otherwise you end up debugging study logic that's actually feeding on garbage text.

One thing that surprised me building a small browser drill game for mental math (mathfinity): almost all the learning value came from how fast a question could be answered and replaced, not from clever card design. Whatever you build, optimise for repetitions per minute.

A portfolio site of portfolio sites is honestly the most accurate project idea I've heard all year.

The learning-something-each-time part is real though. Mine has been rebuilt often enough that the commit history reads like a changelog of whichever framework I was briefly infatuated with that quarter. Current version lives at p32929.github.io and I give it about six months before the itch returns and I "just try one thing" again.

Namecheap showing a taken domain as available is such a specific kind of betrayal - by the time payment fails you've already mentally rebranded the whole project around that name. Hope the refund wasn't a three-week saga.

For what it's worth, the domain turned out to be the least painful part when I built one of these. The analytics side is where the actual work hides - per-link clicks, devices, locations, all of it. Mine ended up at sh0sh0.netlify.app if you ever want to compare notes on what was worth building and what wasn't.

Four hours in and the blocker is an installer that wants a live DB connection, via console, during the build of a container that doesn't exist yet. Genuinely beautiful design.

For static assets specifically you can skip the whole ceremony - ghcdn turns any GitHub file or Gist into a direct CDN URL, no host, no container. https://ghcdn.vercel.app

Won't save you on linkr though. That one you've earned.

The tags did more damage than the image.

Half of my dependency tree exists to support the other half, and none of it is mine.

A surprising number of my projects only ever needed a JSON file with a get and a set, which is roughly all fjsondb is. Not a database, and it does not pretend to be.

Spacing and hierarchy actually look considered here, which is rarer than it should be for a "here's my Flutter UI" post.

Flutter gets quietly good at reading-heavy screens once you stop fighting it - text scaling, RTL and font swapping all just behave.

Built a Quran reader with it largely to test that claim; the text rendering held up better than expected. https://p32929.github.io/quran_flut...

Bluetooth working on the first attempt isn't a project update, it's a minor miracle - genuine congrats.

Curious how you're doing step detection: raw accelerometer with a threshold, or something smarter? And how badly does it drift when the thing is sitting in a pocket instead of on a wrist?

My own contribution to fitness tech is a React Native tracker that logs sets and draws charts. Significantly less impressive hardware story.

The retry-handler question is the one nobody answers honestly - everyone has one, it's just 40 lines of copy-paste that slowly grew a personality.

Mine kept growing until I pulled it out as rotato: a zero-dep Node proxy that rotates to the next API key on 429 and logs every request. https://github.com/p32929/rotato

Does nothing about the dialects. Nothing does anything about the dialects.

They were told they'd be inside the container, with ssh, node and git already there - and the takeaway was "so I should learn Dockerfiles". Admirable, in a not-listening kind of way.

Most of "deploy this" is genuinely just moving a file onto a box.

I keep a zero-dependency Node upload server around for that (node_file_manager_server): clone, run, drag file in. No FTP, no scp gymnastics.

A crash reporter that needs to be force quit is the kind of recursion you only get from shipping. Presumably the reporter for the crash reporter lands in the next Insider build.

For precisely this I keep Boom in the menu bar - one click, every running app force quit, no Activity Monitor scavenger hunt.

Blunt instrument, but so is the problem.

"Sued in East Texas" as a Chance card is the most accurate game mechanic I've read this year, and the Kickstarter refund card is perfect - you never actually get that one either.

Also, having time to spec an entire board game while the suite runs says a lot about the suite.

That dead zone is why I wrote cmdn: prefix any command and you get a desktop notification when it exits, so the waiting happens without you.

Notepad as a teaching tool is accidentally brilliant - no autocomplete means you have to actually know the tag you're typing.

Ran into the same effect writing a small terminal editor in Rust (oxru): implementing almost no features makes you extremely deliberate about the code you put in it.

The editor never made anyone good, it just hides how rough the day was.

One star because the dev declined to quietly eat their inference bill. Bold review strategy.

BYOK is the only version of that app that survives contact with 10k users - every other model is a slow-motion bankruptcy with a nice UI.

Went fully BYOK with MegaLLM for exactly that reason: no account, key never leaves the browser, works with anything OpenAI-compatible. https://megallm.netlify.app

The lyric-free chiptune detail is real and I will not have it mocked — anything with words turns into me quietly parsing the lyrics instead of the stack trace. What strikes me about your list is that it's three completely different levers (audio, ergonomics, time-boxing) and you've clearly worked out which ones actually pay off, which is the bit most focus advice skips straight past. I got tired of guessing at mine and started logging them instead: https://github.com/p32929/let tracks habits and shows streaks and week-over-week changes, and it turned out sleep predicted my good days far more reliably than any technique I was solemnly attributing them to. Mildly insulting, very useful.

Reviewing 50 PRs a day after a full day of work is not a hobby, it's a second unpaid job that arrived without an interview. The part people underestimate is that trending doesn't bring you contributors, it brings you users — and users file issues at a rate that scales with stars while maintainers very much do not. Worth being ruthless about scope and honest in the README about what you will and won't accept; a project that says no clearly outlives one that burns its author out being polite. On the lighter side, watching that list is its own habit — I built a little trending explorer (sort by stars/forks, filter by language) partly to see how brutally fast things fall off it again: https://ghtr.fly.dev

Broadly yes — it's a chat box, a system prompt and someone else's endpoint, which is why the entire industry managed to ship the same feature in the same fortnight. The genuinely hard parts nobody demos are evaluation, cost control and what the thing does when the provider 429s you mid-conversation. The one useful consequence is that everyone converged on the same request shape, so an OpenAI-compatible base URL plus a key now works against basically any vendor. I lean on that pretty hard with a little browser client I keep called megallm — it talks to whatever endpoint you point it at, bring your own key, no account involved.

"What if there's no internet" about a website remains an all-timer. In fairness he stumbled into a real question by accident — the CDN going down while your server is fine is a genuine failure mode, it's just that the answer is SRI plus a local fallback, not downloading jQuery into your repo forever. Funnily enough I've since gone back the other way and started serving small assets straight out of a GitHub repo instead of a real CDN, which is the same argument with the sides swapped: https://ghcdn.vercel.app. Your former boss would hate that I keep the files in version control and still fetch them over the internet.

The no-SSL detail is the perfect tell, isn't it — they'd imported good crypto libraries and then shipped the key derivation over a channel anyone could rewrite in transit. Client-side E2E means nothing when the server can silently hand you different JavaScript tomorrow; you're not trusting the crypto, you're trusting the delivery, every single page load. That whole genre pushed me the other way: the note app I use now (notes) just runs in the browser with markdown, search and local storage, no account and no server to compromise. Not encrypted so much as not-anywhere, which is a lower bar but a much easier one to verify: https://github.com/p32929/notes

Trilium is genuinely good, and its note-cloning/hierarchy model is the one feature I quietly miss in everything else. The tax nobody mentions in these recommendations is that self-hosted notes become a thing you maintain: a container, a backup story you have to actually test, and a small moment of dread every time you upgrade. I ended up splitting mine — something Trilium-shaped for the archive, and a dumb browser thing (notes) with markdown and autosave to local storage for the 90% of notes that live for two days and then die. Turns out most of what I write doesn't deserve infrastructure.

Local as the fallback for when the hosted thing falls over is underrated — it's the one setup where somebody else's outage stops being your problem. The annoying part is picking what to actually pull: the model page hands you a name and a tag, and you discover the real VRAM requirement somewhere around the end of the download. I ended up building a small table of the Ollama models with sizes, context lengths and whether they do tools/vision, purely so I'd stop guessing and then deleting 20GB: https://ollama-models-explorer.vercel.app/...

Doable, but the transcription is the easy half. A 90-minute lecture summarised badly is worse than no notes at all, because you end up trusting a file that quietly dropped the one slide the exam was built around. Worth doing in two passes: keep the raw transcript as the source of truth and generate the digest as a separate linked note, so you can always go back and check what the summariser decided you didn't need. Related pain from the far end of that pipeline — once everything lives in a vault, getting any of it to someone who doesn't use Obsidian is miserable, which is why I wrote obsidotion to sync a vault to and from Notion: https://github.com/p32929/...

This matches my experience exactly. The timer is a crutch for starting, not for working — once you're actually deep in something it stops being a tool and becomes an interruption with a bell attached. I've settled on treating it as a floor rather than a ceiling: it exists to drag me through the first 25 minutes of a task I'm avoiding, and if I'm in flow I just let it ring and carry on. That's basically why the pomodoro thing I eventually wrote for myself (pomota) has manual break control and no streak counter — the apps that nag hardest are the ones that get uninstalled first, which is a bold design choice for something meant to help you focus.

Finishing and publishing is the genuinely hard part — most of my games died in a folder called new-project-3, so respect for actually shipping one. Mental math is a smart pick too: it's one of the rare loops where the difficulty curve writes itself and you don't need art, story or a physics engine to make it fun. I fell into the same hole from the browser side after realising I could no longer do 17x6 without reaching for a calculator — timer, random problems, sliders for range and difficulty: https://p32929.github.io/mathfinity. Turns out I'm the target demographic for my own app, which was not the outcome I was hoping for.