Six years of "someday", shipped in an afternoon

I built my Corne in 2020. Hand-soldered, two halves, 42 keys, OLEDs on both sides, RGB underglow, the whole kit. And then for almost six years I ran essentially stock firmware on it.

Not because I didn't want to change it. I had a list. The OLEDs showed the default QMK splash and a little Corne logo — fine, but I wanted my own font, my own word marks, my layer names rendered the way I wanted to read them. I wanted the RGB to do something that was mine and not a generic rainbow swirl. And somewhere on the right half, three underglow LEDs had died years ago — I'd hardware-bypassed them with a jumper, which kept the chain alive, but the firmware still thought they existed and the colors downstream were always off by a few positions.

Every one of those was a project. Not a hard project in the absolute sense — QMK is open source, the docs exist, people have done all of this before. But each one was its own multi-day rabbit hole: learning the OLED pixel API, designing a font I'd actually want, writing a custom RGB Matrix effect from scratch, figuring out exactly which physical LEDs were dead and how to remap the chain around them. Multiply that by a full-time job, and "someday" stretched out to six years.

Last week I did all three. In an afternoon.

What shipped

A custom OLED font and renderer. Both halves now display vertically-stacked lowercase letters in a font I designed specifically for the Corne's 32×128 pixel OLEDs — rounded, chamfered, with proper baselines and descenders. The right half (master) shows the active layer name; the left half (slave) shows alexi. Every letter is hand-drawn as a bitmap and rendered with pixel-level control over baseline alignment and inter-letter spacing.

A custom RGB Matrix effect: LINTUXT_AMERICAN. Two American flags, one per split half, mirrored so each flag's blue canton sits on its outer edge. Blue canton with stars, five red/dim-white stripes per side, and a 2D wind-ripple wave so the fabric appears to move. Anti-aliased transitions between stripe colors. Live brightness control. Underglow hue tunable from the keymap, persisted to EEPROM, synced across both halves.

The dead-LED workaround. On my right half, LEDs U2, U3, and U4 in the underglow ring are physically dead — bypassed years ago with a hardware jumper to keep the chain electrically intact. U1 is alive but wired in parallel with the bypass, so it shows whatever color the chain's first slot receives, making it a "phantom" of the U5 LED. The firmware now applies a +4 chain-shift on the right half so the logical layout matches the physical reality. Color positions are finally correct.

The demo

Thirty-six silent seconds. Both halves start dark on the desk, then light up with the mirrored flag effect — I flip each half over so you can see the underglow ring from below (the same ring that has three dead LEDs on the right side, hardware-bypassed years ago), then both halves go back down for a typing pass with the OLEDs and the wind-ripple wave running.

The part that's worth paying attention to

I'm not going to claim Claude Code wrote my firmware while I drank coffee — I directed it, I read every diff, I flashed and tested and iterated. But the time cost of getting from "I want this" to "this is on my board" dropped by something like two orders of magnitude.

Designing a 26-letter custom font and writing a pixel-level renderer for it is real work. So is writing a fresh RGB Matrix effect with a sinusoidal 2D wave, palette baking, and split-half mirroring. So is debugging a chain-offset bug across hardware you can't fully probe. Doing all three end-to-end, including throwaway iterations, used to be a multi-week project for me. It's now a single afternoon — because the friction of trying things collapsed.

That's the thing I keep coming back to. It's not that the tools made the work shorter. It's that the gap between idea and working code I can flash and feel under my fingers got small enough that I'll actually do the small ideas now. The customizations that were never going to clear my "is this worth a weekend?" bar — I just do them. The board feels mine in a way it didn't six years ago, and what changed wasn't my skill or my available time. What changed was the cost of trying.

There's a whole class of personal-scale software that lives or dies on that cost. Tiny CLIs. Custom keyboard firmware. The little tool you keep wishing existed but never quite build. The plugin that would save you ten minutes a day but takes a weekend to write. Every one of those is sitting behind a "is this worth it?" gate, and AI tooling is moving that gate. A lot.

The keyboard works. The flags wave. The OLEDs show what I want them to show. The dead LEDs are no longer a thorn. Six years of "someday" — closed in an afternoon.

If you want the actual firmware source it's at github.com/lintuxt/qmk-userspace — it builds against unmodified upstream QMK, no fork to maintain. And if you're working on something similar at the intersection of personal software and AI tooling, I'd genuinely like to hear about it. Reach me at me@lintuxt.ai.