I prefer a global hotkey that triggers a picker and stays hidden otherwise. And we can hook right into the default KDE color picker, no need for additional packages.

the default widget is minimalist, but still distracting

The Solution: KWin D-Bus

We can do this by tapping directly into the KWin compositor using D-Bus. It’s fast and just works.


dbus-send --print-reply --dest=org.kde.KWin /ColorPicker org.kde.kwin.ColorPicker.pick


This will run the color picker. Pick a spot and click. As you will see it returns a uint32 (a big number), and we’ll need to convert that to a Hex code in the next step.

The One-Liner

For Wayland:


dbus-send --print-reply --dest=org.kde.KWin /ColorPicker org.kde.kwin.ColorPicker.pick | awk '/uint32/ {printf "#%06x\n", $2 % 16777216}' | wl-copy


This will run the color picker, convert the uint32 to hex and shove it straight into your clipboard, ready to be pasted.

For X11:
Swap wl-copy for xclip -selection clipboard.

Set the Global Hotkey

Don’t wrap this in a shell script unless you have to. KDE can handle this natively:

• Open System Settings > Shortcuts.
• Go to Commands and click Add New.
• Name: Global Color Picker.
• Command: Paste the one-liner above.
• Shortcut: Assign your favorite combo (e.g., Meta+Shift+C).
• Hit Apply.

And there you go. No wasted visual space. Just instant color pickings whenever you need it.

–

The post How to Create a Global Color Picker Hotkey in KDE Plasma (Without Widgets) appeared first on André Klein Dot Net.

As soon as I try to paste in an annotation saying, for example, “שלום” (shalom), it looks alright in the modal, although the left alignment is already an early warning sign that this isn’t fully parsed as RTL text:

But as soon as I hit “OK”? It flips. It renders as “םולש” (molash).

I work with Hebrew PDF documents constantly, and this has been a consistent blight on my otherwise happy Linux life. I even went so far as to try patching Okular (my favorite PDF app, if you couldn’t tell), but my C++ skills weren’t enough to defeat the beast.

And then it hit me. The glorious solution to this annoying problem. It is hacky as hell. In fact, it is such a gloriously dirty fix that one might almost call it elegant.

The RTL Fixer Script

I present to you the RTL Fixer: four lines (three if you’re a minimalist who hates notifications) of glorious letter reversal.

#!/bin/bash
content=$(wl-paste)
reversed=$(echo "$content" | rev)
echo -n "$reversed" | wl-copy
notify-send "Clipboard reversed" "$reversed"

What does it do? Exactly what it says on the tin. It takes whatever is in your clipboard, reverses the character order, and shoves it back into the clipboard.

The Workflow

Once bound to a hotkey (I use Alt+R), the workflow is seamless:

• Type your RTL text.
• Select and copy it. (CTRL+A, CTRL+C)
• Hit Alt+R.
• Paste it. (CTRL+V)

Enjoy your correctly rendered RTL text. (Of course, if you hate this 4-hotkey-pronged workflow, you could easily chain them, but for the sake of this post, let’s keep it simple.)

It works because the PDF viewer is going to reverse the letters anyway, so we’re just preemptively reversing them so they land in the “wrong” order, which makes them look right. It’s double-negative logic for the digital age.

And there you have it. Finally! RTL annotations in Linux PDF apps. Just as the good Lord intended. Well, strike that. The PDF format is clearly the devil’s work.

The “Legacy” Edition (X11)

I see you over there, still clinging to Xorg like a comforting, slightly buggy security blanket. If you aren’t on Wayland yet, the wl-clipboard tools won’t help you. You’ll need xclip installed.

Your version of the “dirty fix” looks like this:

#!/bin/bash
content=$(xclip -selection clipboard -o)
reversed=$(echo "$content" | rev)
echo -n "$reversed" | xclip -selection clipboard
notify-send "Clipboard reversed" "$reversed"

Same logic, different plumbing.

A Small Warning for the Multiline-Enthusiasts

Because we are using the rev command, this script is a “dumb” character-by-character flipper. It works flawlessly for single lines or short phrases. However, if you try to reverse a three-paragraph manifesto, it will reverse the entire string: meaning your last line will become your first line, and your brain will melt trying to read it.

Stick to one line at a time, and you’ll be golden.

Anyway, perhaps this will help someone else out there in the struggle. Or perhaps the PDF reader maintainers will eventually fix the BiDi engine.

Then again, I’m not holding my breath. The Venn diagram of “Linux Desktop Users” and “RTL-enjoyers” is probably not a massive circle.

In the meantime, I will keep calm and hit Alt+R.

Molash… I mean, Shalom.

–

The post The End-Boss of Linux Formatting: RTL Annotations in PDF appeared first on André Klein Dot Net.

[drop_cap]L[/drop_cap]ast year, I moved to CachyOS on my laptop. I expected a different Kernel. I was ready to do some things differently. What I didn’t expect was a total disruption of my workflow. Not just on that Linux machine, but across any other machine I would touch afterward.

Once you get familiar with Linux’s terminal-first approach and you’ve tasted the speed of a GPU-accelerated terminal and a shell that doesn’t fight you, going back to a standard Windows setup just feels … wrong.

I tried to reverse-engineer that workflow on Windows. I tried WezTerm, Starship on Git Bash, and native TUIs. I failed. Between terminal escape codes screaming into my mouse movements and Windows eating my AltGr keys, I realized the truth: Native Windows and truly “terminal-first” workflows are like water and oil (unless you enjoy working with Powershell. But that’s a totally different story).

Elevating The Subsystem

Just when I was ready to fold and relegate my TUIs to my Arch rig, I was ready for one last Hallelujah: WSL2.

Yeah, I know. By default, WSL is not the best experience. It’s a superior OS running inside an inferior one, burdened by a translation layer designed for trouble. But after a day of chipping away at the friction, I found a stack that almost makes me forget that I’m on a Windows machine and not mashing away at Kitty on CachyOS.

Lobotomizing the WSL

By default, WSL is slow because it scans your entire Windows $PATH—thousands of folders of legacy garbage. The trick is to cut the cord in /etc/wsl.conf:

[interop]
appendWindowsPath = false

Setting this to false drastically reduces shell initialization time because WSL stops crawling through your Windows binaries.

To stop WSL from becoming a memory parasite, I also added some performance flags. First of all, we shutdown the virtual machine after an hour of idle, so it doesn’t keep hogging resources forever:

[wsl2]
# Automatically shut down the WSL VM after 1 hour of inactivity
vmIdleTimeout=3600000

Next, we add this tweak to our %USERPROFILE%\.wslconfig (that’s on the host system, not the WSL box) to make the RAM-usage a bit “smarter”:

[experimental]
# Give RAM back to Windows as soon as Linux stops using it
autoMemoryReclaim=gradual

GPU-Accelerated Goodness

I settled on Alacritty for the terminal. Unlike WezTerm it plays nice with my weird German keyboard layout, e.g. AltGr+Q = @ and Shift+7 = /, and delivers the raw speed I need for my TUI development workflows.

But first of all we need to get a cleaner start. Let’s edit alacritty.toml:

[terminal.shell]
program = "C:\\Windows\\System32\\wsl.exe"
args = ["-d", "Ubuntu", "--cd", "~", "fish", "--login"]

Launching with --cd ~ ensures we start in the Linux home directory, not the/mnt/c/ mount which is a slow and sad reminder that Linux is just a tenant on this system.

If the colors are off, because they probably are, we can explicitly request the full truecolor goodness like this:

[env]
TERM = "alacritty"
COLORTERM = "truecolor"

Once everything is done, you should get a crisp and clean terminal experience on WSL. Here’s a quick screenshot:

Theme is the ever-goated TokyoNight, font is Delugia (which has excellent icon support) and just overall pleasant to look at. Shell is Fish+Tide. For those sweet ls colors you see in the screenshot above I stole some aliases from the excellent CachyOS fish.config, most notably:

alias ls='eza -al --color=always --group-directories-first --icons'
alias la='eza -a --color=always --group-directories-first --icons'
alias ll='eza -l --color=always --group-directories-first --icons'
alias lt='eza -aT --color=always --group-directories-first --icons'
alias l.="eza -a | grep -e '^\.'"


Since we are replacing ls with eza you need to sudo apt install eza on Ubuntu.

In the same vein, I also applied CachyOS’s replacement (slightly modified) for man so we can get actual nice-looking manuals:

set -x MANROFFOPT "-c"
set -x MANPAGER "sh -c 'col -bx | batcat -l man -p'"

For this to work you need sudo apt install bat on Ubuntu. And then typing man git will give you something like this:

Fixing Shell Colors, Path and Browser on WSL

If for whatever reason you get the “muddy color” problem where WSL doesn’t recognize Alacritty’s capabilities, you can force it in config.fish:

# Force Alacritty identity and TrueColor
set -gx TERM alacritty
set -gx COLORTERM truecolor

Once everything is set correctly $TERM and $COLORTEM should return the correct values:

The Bottom Line

By effectively decoupling WSL from Windows you can genuinely improve performance and make it feel a lot more like a native Linux environment. Add a modern terminal like Alacritty with truecolor support, a user-friendly shell like Fish and you’re officially on your way to making the terminal-first workflow on Windows significantly suck less more palatable.

Since I’ve been doing lots of terminal-centric work lately, I can now seamlessly switch between my Linux and Windows rig. Same look, same commands, same muscle memory. And when I launch Alacritty now and start bashing away, it almost feels like Linux is no subsystem at all, but the dominant driver.

Last but not least, to top off the TerminalCeption, here’s a screenshot of me writing the draft for this post in HeloWrite on the very stack (WSL-Alacritty-Fish) described in thist post:

UPDATE: once I had all of this working, I deleted the whole Ubuntu WSL instance and replaced it with a proper ArchLinux WSL install. Look and feel are the same, but using pacman and AUR on Windows is just so much fun. Almost a sacrilege. Even getting native Windows NVIDIA drivers passed through to CUDA-enabled FastWhisper on this Arch box just works.

Whodathunk.

–

The post Taming WSL into a Tactical Workbench For A Terminal-First Workflow appeared first on André Klein Dot Net.

MacOS users get Native Tabs in VS Code. On Linux/Windows? You get one instance per workspace and a mess of groupings on your taskbar.

I didn’t want a new OS; I just wanted a quick way to visualize and switch in between open workspaces.

The Solution: A Focused Taskbar

The native KDE Plasma Task Manager is powerful. You can customize it infinitely, drop it into top panel, massage appearance until it has a “tab-like” feel, but it lacks one crucial feature: Application Filtering. By default, the taskbar will always show all and any open tasks.

I hacked together a version that lets you “pin” specific apps to a dedicated panel. This creates a “Dev Mode” bar in the corner of your screen that mimics the VS Code native tabs feeling by showing only your active development tools. And it’s not limited to VS Code. You can create “tabs” like this for any combination of apps. Want to show only your active terminals and browser? Only file managers? No problem. Just filter.

Who needs “native” tabs when you can get a custom taskbar?

• Only show whatever you tasks you actually need for your workflow
• Filter by single instances like “code” or combinations like “zed,firefox”
• Minimal task bar without hover previews, audio bubbles, etc.
• Keep the “unrelated” junk (Slack, Spotify, Mail) in your main taskbar.

Quickstart

Here’s a quick way to get the plasmoid, copy it to your .local/share and restart plasma:

git clone https://github.com/burninc0de/kde-filtered-taskbar.git
cd kde-filtered-taskbar
./install.shAfter that, right-click any panel, click “Add Widgets,” and search for Filtered Taskbar.

The post How to get VS Code “Native Tabs” on KDE Plasma (Linux) appeared first on André Klein Dot Net.

[drop_cap]W[/drop_cap]riting is hard. It’s messy, unresolved, chaotic. You scrape scenes out of your skull and massage syntactical turds until they shine (or get thrown out in the next rewrite).

Code is different. Something either works or it doesn’t. Problems usually have clear paths to solutions.

Prose has no linter. You can’t pre-compile a plot-twist to catch continuity leaks.

So this week, after making solid progress with my new book, I “relaxed” by building a writing tool in my spare time. The irony isn’t lost on me.

The Calm of The Void

Staring at a white page sucks. First step? Make it not white. Stop shining a flashlight into your retinas while trying to uncork the unconscious. Next, ditch the Microsoft kitchen-sink ribbons of colorful icons and formatting gizmos. Stop pretending you are a typesetter and fiddling with font sizes instead of dredging up dirt on your characters.

In short, remove everything else except the words.

I’ve always been a huge fan of this type of minimalist approach.

The less I see, the better. For years I’ve bounced between minimalist word processors: WriteMonkey, iAwriter, FocusWriter—always configured the same way: dark background, generous horizontal padding to spare my eyes the long left-to-right trek, a clean mono/duospace font, and a subtle word counter tucked in a corner that only shows when idle.

Notifications off, music on, deep dive. That’s the only way to play this game.

This weekend I thought: why not follow this minimalist approach, but strip it down even further, in the shape of a terminal-based tool. TUIs (terminal user interfaces) are all the rage these days (think ClaudeCode, OpenCode, etc.) and I admit—it’s fun in a deliberately discordant way!

No graphics. No animations. No gamification or “engagement” loops. Just the brutal, high-contrast reality of text.

I built HeloWrite in Python with the Textual library (great starter). Here’s a screenshot of the distraction-free mode, and yes, there ain’t much to see, which is precisely the point:

No formatting tools. No markdown previews. Just words.

The Secret Sauce: Performance & Paranoia

I realized halfway through Sunday that I wasn’t just building this for the “aesthetic.” I was building it because I’m tired of waiting for my tools to catch up to my brain. Many modern writing apps are resource hogs. They have “loading” states awkwardly disguised by splash screens. They index. They bloat.

HeloWrite has a cold start so fast it feels like it was never closed. We’re talking 0.5 seconds from hitting Enter to a blinking cursor. And that’s running from source—no pre-compiled binaries, no bloat, just raw Python and the void.

And then there’s the Git workflow. You can set your Obsidian vault dir (or any repo for that matter) in the settings and git to your heart’s content. Push and pull individual files or chapters as you work on them and get version control for your writing. Never lose a line again. Send it all to the vault, while you write.

Don’t use git? No problem. Auto-save is built in as well. But if you are a writer (or a developer), you’ll probably spam Ctrl+S anyway. Just in case, right?

the settings screen (F3)

Code and Corkboards

There are tons of amazing code editors out there. Vim fanatics can rice their configs until the heat death of the universe. Emacs people have basically built an operating system. Developers are spoiled for choice when it comes to terminal-based workflows.

Writers? Not so much.

We get word processors designed by committee, skeuomorphic corkboards, or minimalist apps that cost $50, do less than Notepad and still somehow end up feeling heavy.

I wanted something different. Something that understood the writer’s brain, but had the heart of a code editor.

I’ve tried other terminal-based word processors like WordGrinder, and while I loved the concept, the workflow never quite seemed clicked with me. So I just built my own, tuned exactly to the quirks of a lifetime of writing.

Begin Jump Prep

HeloWrite, pronounced “hee-lo” and named after Karl “Helo” Agathon from Battlestar Galactica, is completely free open-source software. It includes:

• Fully distraction-free mode with an out-of-the-way word counter
• On the fly adjustable horizontal padding to cut eye strain
• Many popular custom color themes including cursor styling
• Granular git push and pull commands

“I fell in love with a machine. That’s stupid. So just call me an idiot, and let’s be done with it.” — Karl Agathon

Clone, fork or hack here: burninc0de/helowrite

–

The post HeloWrite: A Minimalist Terminal Word Processor for Writers appeared first on André Klein Dot Net.

Certain icons just refuse to show up on taskbar. Regardless of whether they are pinned or just currently running.

And yes, like you I’ve tried it all ever since I “upgraded” my main rig to Windows 11. You know the drill:

• The Icon Cache Nuke: Deleting IconCache.db until your fingers bleed.
• The Last Straw: Staring at a progress bar for sfc /scannow, DISM, and chkdsk while they tell you “No integrity violations found”, even though your taskbar clearly looks like a redacted CIA document.

Notice how it’s only the “Modern” apps? Notepad++, random EXEs, and Photoshop look fine, but Settings, Calculator, Notepad and the Clock have checked out and left behind empty, hollow squares.

Spoiler alert: Your system isn’t “corrupted.” It’s just being haunted by a legacy ghost. If (like me) you’re on a machine with years of arcane cruft, some ancient shell extension may be fighting the Windows 11 UWP icon pipeline over PNG rendering, and you’re caught in the crossfire.

The Problem: Legacy Bloat vs. Modern “Security”

Old-school EXEs usually have icons embedded in their binaries. The modern Windows shell stack (used by UWP apps) relies on a specific pipeline to render icons. If you ever installed software that added custom PNG thumbnail handlers back in 2016, you’ve got a conflict that the “Modern” shell can’t handle. It sees the hijack, panics, and gives you a blank square.

The Real Fix (The Registry Scalpel)

If you want to stop the madness and actually get your Clock, Calculator, and Settings icons back, forget about running SFC scans. Here’s what finally fixed it for me, in case anyone else struggles with the same issue:

Open Regedit (Win + R, regedit).

1. Navigate to HKEY_CLASSES_ROOT\.png\shellex
2. Look for a GUID key like {E357FCCD-A995-4576-B01F-234630154E96}. This is an old shell extension for thumbnails.
3. Right-click the shellex folder and rename it to shellexOLD or just nuke it.
4. Restart explorer.exe.

By renaming that key, you stripped away the legacy shell extensions that were intercepting PNG rendering. You greenlit Windows 11 to use its native, internal logic to draw those UWP icons.

Thanks to Anonymous for finally pointing me in the right direction after months of looking into this on and off.

P.S. To the engineers at Microsoft: If your “Modern” resource loader can be defeated by a single registry key from 2016, maybe it’s time to stop adding “AI” to the Start menu and start making sure the frellin’ Clock works.

–

The post Modern App Icons Missing on Win11? How a 10-Year-Old Registry Key Ghosted My Taskbar Icons appeared first on André Klein Dot Net.

Thomas Brooks – The New Pupil (1854). Wikimedia Commons.

[drop_cap]Y[/drop_cap]ou’ve probably seen that Current Affairs piece making the rounds, the one that declares higher education dead because “students use AI to write papers, professors use AI to grade them, degrees become meaningless, and tech companies make fortunes.”

It’s a catchy obituary. And yeah, AI panic is having a moment. Programmers sneer at “vibe-coding,” artists rage at image generators, and now academics are convinced ChatGPT is the final nail in the coffin of human learning. When factory jobs vanished to automation, knowledge workers mostly yawned. Now the machines are coming for their gigs too, and suddenly it’s existential.

Linus Torvalds put it bluntly in a recent interview: “that genie is out of the bottle.” No amount of wishing will stuff it back in. We’re all going to have to live with this new reality.

I’m a writer, an educator, and a developer—three professions currently getting torched by generative AI—and I’m not scared. I’m genuinely excited.

This whole freakout feels eerily familiar. Remember when Wikipedia launched and every teacher warned us never to trust “the internet”? The same generation that preached that gospel now doom-scrolls rage-bait and falls for foreign disinformation campaigns. The pattern is unmistakable: new tool arrives → disrupts old hierarchies → experts clutch pearls → tool wins anyway.

AI didn’t break education. It just held up a mirror we’d spent twenty years trying to avoid.

Here’s the part no one wants to say out loud: institutional education has been coasting on fumes for decades. When I was studying to become a high school teacher, I got so fed up with standardized testing and fossilized curricula that I dropped out and started my own language-teaching business. That was ten years ago. Walk into most classrooms today and you’ll see the same worksheets, the same “summarize in your own words” assignments, the same obsession with memorizing facts that Google rendered obsolete in 2004.

We pretended the internet didn’t exist, then we pretended smartphones didn’t exist, and we kept designing assessments that rewarded regurgitation over reasoning. Of course students plug those assignments into ChatGPT. The surprise isn’t that they’re doing it, it’s that we built an entire system that made it the rational choice.

AI didn’t break education. It just held up a mirror we’d spent twenty years trying to avoid.

So here we are, at an actual crossroads. One path is easy: ban AI, block it on school networks, run plagiarism detectors that are already obsolete, and keep shouting that the kids are cheating. The other path is harder: accept that the tool is here to stay and figure out how to make it work for us instead of against us.

I still remember my high-school math teacher confiscating calculators because “you won’t always have one in real life.” We now carry devices in our pockets more powerful than the computers that put humans on the moon. Telling students they can’t use AI because “you need to know it yourself” is the modern version of that same lazy argument.

Brains were never meant to be Wikipedia. Recalling disconnected facts on command has never been a meaningful proxy for intelligence. Real thinking—creativity, insight, synthesis—happens when we connect ideas, spot patterns, and wrestle with complexity. Funny thing: that’s exactly what large language models are starting to do.

So maybe, just maybe, we should stop treating AI like the enemy and start treating it like the most powerful tutor humanity has ever built.

A couple of starting points for anyone willing to experiment:

• Turn AI into a Socratic sparring partner. Instead of asking it for answers, lay out your reasoning and dare it to tear holes in your logic. Use every response to sharpen the next prompt. That back-and-forth is where real learning happens.
• Flip assessment from product to process. Stop grading the polished essay or the “correct” answer. Start grading the prompt history, the iterations, the dead ends, the moments the student pushed back against the model or combined three different outputs into something new. The artifact no longer matters; the visible thinking does. AI can’t fake intellectual courage or curiosity, at least not yet.
• Let teachers become learning-experience designers. With a few good prompts, even non-coders can generate interactive exercises, simulations, and adaptive quizzes tailored to their students, without waiting for admin to cut six-figure deals with software vendors. The barrier to building great tools just dropped to zero.

So yeah, if your homework assignments can be completed better and faster by a large language model, they were probably busywork to begin with. That’s not a tragedy; it’s an invitation.

Education isn’t dying. It’s being forced to evolve for the first time in a century. We can fight that evolution and lose, or we can lead it.

I know which side I’m on.

–

The post AI Isn’t Killing Learning. Our Standards Were Already on Life Support appeared first on André Klein Dot Net.

Enjoy your copypasta responsibly

[drop_cap]N[/drop_cap]ot so long ago, when you hit a weird bug, the ritual was always the same: Google the error message → pray to the old gods → land on a 2012 StackOverflow thread answered by someone named DenverCoder9. If the stars aligned, there was a code snippet that almost fit. You copied it, pasted it, changed three variable names, ran the tests, and shipped it.

The LeetCode monks and ivory-tower purists sneered and called it cheating. We all still did it. Every single one of us.

Fast-forward to now: StackOverflow is a ghost town. It peaked around 2014-2017, got a brief “dead cat bounce” when half the planet decided coding beat doomscrolling during lockdown, then fell off a cliff the month ChatGPT dropped.

Gergely Orosz@pragmaticengineer.com

Sure, someone will say “correlation ≠ causation.” Sure, Jan.

Point is, AI now solves the exact same problem StackOverflow used to solve—just faster, friendlier, and without the top comment asking why you’re writing bad code in the first place.

The discourse, meanwhile, has gone full tribal.

Camp 1: “We’re one prompt away from Aunt Margaret shipping production-grade e-commerce apps from her hot tub.” Camp 2: “It’s all soulless slop. Real engineers compile their own kernels with hand-rolled assembly.”

I’m blissfully agnostic. A tool is a tool. If it ships features faster, I’m using it.

So I spent the last few months mainlining every shiny new “agentic” coding toy: Cursor, Windsurf, Kiro, Antigravity. They’re… fine. Sometimes they fix a hairy refactor in ten seconds flat. Sometimes they go rogue, rewrite your entire auth layer at 3 a.m., or just sit there blinking “Sorry, I can’t do that, Dave [furiously deletes and re-creates the file].”

Net result? Still dramatically faster than wandering the post-apocalyptic wasteland of outdated answers, up-vote gaming, and “works on my machine” non-solutions.

And here’s the part nobody wants to say out loud:

These models were trained on every public GitHub repo, every blog tutorial, every abandoned “next big thing” from 2013, and yes—probably your cringe university projects too. “Vibe coding” is just the AI doing the old Google → StackOverflow → copy-paste → pray cycle for you, then handing you the result with variable names swapped and folder structure intact.

It’s not creating new knowledge. It’s regurgitating, remixing, and serving the spaghetti on a silver platter.

Which means the entire “is vibe-coding good or bad?” debate is missing the forest for the trees.

We’ve always built software by standing on the shoulders of giants, copy-pasting their homework, and tweaking it until it works. AI just automated the copy-paste part and added a chat window.

The game hasn’t changed. The tools just got faster.

You still need to know exactly what the software is supposed to do. You still need to read the generated code and spot when it’s high on its own hypeium. You still own the production incidents when the AI builds something beautiful, fast, and completely wrong.

So vibe-code all you want. Prompt like a poet. Let the agents run wild.

Just don’t kid yourself that it’s fundamentally different from what we’ve been doing for the last twenty years.

It’s the same Frankenstein dance. We just swapped the rusty scalpel for a robotic surgeon. The monster still needs you to tell it where to bite.

P.S. Isn’t copy-pasting someone else’s code and tweaking it tantamount to theft? Why, yes, certainly:

“Plagiarism is an ugly word for what, in rock and roll, is a natural and necessary — even admirable — tendency, and that is to steal. Theft is the engine of progress, and should be encouraged, even celebrated, provided the stolen idea has been advanced in some way.

“To advance an idea is to steal something from someone and make it so cool and covetable that someone then steals it from you.”Nick Cave

–

The post Vibe Coding Is Just Copy-Pasting From StackOverflow With Extra Steps (and a Better UI) appeared first on André Klein Dot Net.

Pieter Brueghel the Elder – The Dutch Proverbs, Public Domain

Social media is so insanely fragmented right now it’s honestly comical.

Remember 2009? (15 years ago … how?) I joined Twitter and it felt like the future. Even Facebook—yes, Facebook—was kinda usable back then. Real humans having real conversations instead of performing for the algorithm.

Now? It’s just oceans of AI slop, engagement-farming rage bait, and ads disguised as your uncle’s vacation photos.

I basically quit posting anywhere except the occasional “new book dropped” flex. Everything else got funneled into my newsletter because at least there I control the signal-to-noise ratio.

But newsletters are for business, mostly. What about all the dumb little asides, half-baked ideas, cool side projects, and random musings that don’t justify the whole “create campaign” spiel? Where do those go in 2025 without drowning in garbage?

So I did a lap around the current landscape:

• Facebook: AI-generated shrimp Jesuses (prawn Jesuses? Jesi?), boomer minion memes, and ads. Hard pass.
• Twitter (it’s still Twitter, fight me): completely unusable vanilla, but if you slap on a few aggressive blocklists and extensions, the programming/game-dev/indie-maker circles are still alive and kicking. You just have to dodge the daily outrage theater, but that’s par for the course these days.
• Mastodon: the whole-foods co-op of social media. Kinda plain oatmeal energy, but honest, no ads, and every once in a while you stumble into a genuinely great thread about open-source tools or language learning.
• Bluesky: I only poked my head in recently. The Discover tab is 95% sports and politics no matter how many times you smash “show less.” It’s like cat hair: inexplicably persistent. And no, I’m not building an infinite mute-word list for every football player and parliament member on earth, sorry.

Everything else (TikTok, Instagram Reels, etc.) is just flickering slot machines for your dopamine receptors. We’re not even gonna talk about those.

The core problem: back in the day there were two big rooms—Facebook and Twitter—and basically everyone you knew was in one of them. Now the internet has shattered into ideological shards and everyone’s scattered across different platforms like post-divorcees who refuse to be in the same room.

Some thoughts belong on Twitter, some feel more Bluesky-ish, some are too nerdy for anywhere except Mastodon. Juggling logins, tabs, and different posting UIs feels like a second unpaid job. Context-switching tax is real and it sucks.

My personal rule: I don’t care where the good people are, I’ll go there. But I’m not gonna live in five apps.

So I built the laziest possible thing that solves my exact problem.

It’s a tiny Electron app (oxymoron? ha!) with a Node.js backend (no db needed) that lets me post text and images to Twitter, Bluesky, and Mastodon from one box. No browser tabs. No copying and pasting. No logging in anywhere ever again.

Run the app → type stuff → pick platforms → hit send → close the app and forget social media exists until someone actually @s me.

Yes, I know Buffer exists. Yes, I know about Postiz and the rest. They’re great. They also either cost money the second you breathe on them or require self-hosting a small moon base. I just wanted something that costs exactly $0 and runs with one click.

I call it SocialSox, and the icon is literally a pair of socks, because social media mostly stinks in 2025, but sometimes you don’t wanna go barefoot.

The repo is currently held together with hopes, dreams, and a disturbing amount of duct tape, but if a few people are actually interested I’ll tidy it up and throw it on GitHub. Let me know in the comments.

UPDATE: Cleaned up the repo and open-sourced it. You can grab it here: github.com/burninc0de/socialsox

Until then, I’m back to posting a couple of times a week, except now I can do it from one place and immediately return to my cave.

Sayonara.

P.S. Twitter’s API is stingier than Scrooge McDuck. Polling for replies more than once an hour will either bankrupt you or exhaust your free tier before lunch. User discretion is advised.

UPDATE: I just reworked the layout and added a mixed Home Feed for Bluesky and Mastodon. Now you can see the whole discordant mess in one glance.

Twitter/X is still being a daisy about their API, so you can still yell into their void, you just won’t hear the echo (rate limits, you know the drill). Honestly? That’s probably a net positive for your mental health.

But for the platforms that actually play nice, you now get all your hashtags and follows in one clean, infinitely scrolling desktop stream. No “smart” algorithm nonsense—just a linear feed that doesn’t treat you like a lab rat.

My favorite new feature: Mastodon language filtering. Mastodon still doesn’t filter followed hashtags by language by default (seriously, why?). In SocialSox, you can now:

• Kill the noise: Click a language code next to a post to instantly filter it out.
• Prune the garden: Explicitly whitelist the languages you actually speak in Settings.
• Nuke the corpo-spam: Mute the “brand voice” accounts on the fly.

Using this as my daily driver, I’ve already stumbled onto more interesting stuff than I have in three years of browser-scrolling. It’s socials without the noise. Who knew?

–

The post I Built My Own Damn Crossposter Because Social Media Is a Fragmented Hellscape appeared first on André Klein Dot Net.

Reference: The letter Aleph in two different styles: traditional “serif”-style, and more modern sans-serif

The better AI models become at certain things the more fun it is to find things they horribly fail at. My new favorite low brow “benchmark”: draw the Hebrew letter Aleph in SVG format. It should be pretty simple in practice. Three lines: one long diagonal, one shorter curved line at the bottom (with optional “foot”) and another curved one top right.

Let’s start off with our everyman AI, the OG that unleashed this whole generative AI wave in late 2022: ChatGPT or “Geppetto”, as I like to call it. I asked it to complete the task and it immediately replied:

Here’s a clean, scalable SVG of the Hebrew letter א (aleph)ChatGPT

the letter Aleph according to ChatGPT

An absolute fail. Not just “rest-of-the-owl” territory, but utter madness. No further questions, your honor.

Let’s see what our boy Gemini came up with. Interestingly its first response was: “If you upgrade your subscription, I can create it for you today.” And when I politely (“nah bruh”) declined it finally busted out its crayons and declared:

This structure contains the SVG definition of the Aleph. The path data traces the three main strokes of the letter. We use a bold, round stroke to mimic a brushGemini

What is that, a wet noodle?

A literal turd. I mean, you can kind of see what is was going for … kind of. At least there are three lines. But I think we can consider this a solid fail as well.

Next up, what did trusty old Claude have to offer? In perfect over-confident manner it declared:

I’ve created an SVG of the Hebrew letter aleph (א). It shows the traditional form with three distinct strokes – the upper right diagonal, the central diagonal connecting them, and the lower left diagonal. The letter has a distinctive shape that’s been used in Hebrew writing for thousands of years.Claude

Wow, that sounds promising. Let’s open that SVG it painted:

is that a turd emoji or the Adobe logo?

I mean, it’s … bold, I’ll give old Claude that. But it has very little similarity with the actual letter Aleph.

After the Big Three had gloriously and spectacularly failed us, I thought it may be a good idea to let Grok 4 try its hand.

And of course it overpromised as well:

Here is a complete brush-stroke calligraphy style drawing of the Hebrew letter א (Aleph) as if it’s being handwritten with an ink brush. It gives a very organic, calligraphic feel with subtle brush texture and flow.Grok

“long cat” Aleph

Honestly, this is probably my favorite, because it looks so utterly comical, like these inflatable tube men you see flapping around in front of second-hand car dealerships. But yeah, another failure for sure.

I’m genuinely curious why all models dropped the ball here. Three simple lines. Not enough data perhaps? Too much variety in existing datasets from ancient scrolls to modern Hebrew print? At first I thought that the problem was the format: SVG, unlike jpg or png, contains actual path data and AI can’t really fall back on its “fuzzy context” strength. Every line has to be perfect. No blending and blurring like it does in rasterized image generation.

So I tried to let it create some complex shapes like bicycles in SVG format and these all turned out surprisingly well, despite having a lot more complexity than the three lines of the Aleph.

Whatever the reasons ultimately may be, this is now my “strawberry” test. And it’s just too much fun.

The post Strawberry 2.0: The Hebrew Letter That Breaks Every AI appeared first on André Klein Dot Net.