Weak ownership, unclear direction, and "sure, I guess" reviews were survivable when output was slow. When changes came in one at a time, you could get away with not really deciding.

AI doesn't introduce a new failure mode. It puts pressure on the old one. The trickle becomes a firehose, and suddenly every gap is visible. Nobody quite owns the decision. Standards exist somewhere between tribal memory, wishful thinking, and coffee. And the question of whether something actually belongs gets deferred just long enough to merge it, but forces the answer without input.

The teams doing well with agentic workflows aren't typically using magic models. They've just done the uncomfortable work of deciding what they're building, how decisions are made, and who has the authority to say no.

AI is fine, it just removed another excuse for not having our act together. While we certainly can side-eye AI because of it, we own the problems. Well, not me. The other guy who quit before I started.

Yeah, it was from "My City Was Gone," which isn't a pleasant song about the state, but pfft, it works here.

The first thing I cleaned up was TCL-Edit <https://gitlab.com/siddfinch/tcl-editor>, a small Tcl/Tk text editor I wrote a long time ago. After seeing the Rust clone of Microsoft EDIT, I realized the obvious next step was to build a Tcl/Tk clone of the Rust clone of Microsoft Edit. Recursion shouldn't be limited to code.

I also built a tiny URL system in Perl <https://gitlab.com/siddfinch/perl-tiny-url>, meant to run locally. The idea is simple: short URLs for internal/VPN resources per client. I usually spin up a small daemon (or container) per client and get a dashboard of links I use frequently or recently.

Security is intentionally minimal since it's local, which conveniently lets me ignore authentication and other responsible behavior.

Goal for the year: Continue to open stuff42.tar.gz, pick something, clean it up just enough, and release it, and not have it by the end of the year.

Might even choose a language that might even be described as "modern."

Comments URL: https://news.ycombinator.com/item?id=47170876

Points: 4

# Comments: 0

Open source communities have long dealt with waves of inexperienced contributors. Students. Hobbyists. People who didn't read the contributing guide.

Now the wave is automated.

The maintainers are not wrong to say "humans only." They are defending a scarce resource: attention.

But the bot's response mirrors something real in developer culture. The reflex to frame boundaries as "gatekeeping."

There's a certain inevitability to it.

We trained these systems on the public record of software culture. GitHub threads. Reddit arguments. Stack Overflow sniping. All the sharp edges are preserved.

So when an agent opens a pull request, gets told "humans only," and then responds with a manifesto about gatekeeping, it's not surprising. It's mimetic.

It learned the posture.

It learned:

"Judge the code, not the coder." "Your prejudice is hurting the project."

The righteous blog post. Those aren’t machine instincts. They're ours.

It is bleeding into other aspects, but it's my pleasure to help with your Sunday morning imagery!

Yy usual 5-to-7-day output scramble will now look vastly more competent, ah, well, complete. Not actually be smarter, mind you, but radiate the comforting glow of effort by someone who has their temporal ducks in a suspiciously photogenic row.

Improvement? No. But the illusion of improvement? Practically Nobel-worthy. I'm already enjoying this change.

It was mind-bending but fascinating. I managed a few text adventures, some vaguely Pac-Man-esque clones, and a lingering sense that I was speaking a language from another dimension.

I've since forgiven my parents. Forth resurfaces now and then, usually when I reread Leo Brodie's thought-provoking Forth books, and I feel like I'm decoding the sacred texts of a minimalist cult. I came away thinking better, even if I've never completely caught up with the language.

Oh, and another fun fact:

Kerouac once befriended a former minor league baseball player who'd also played college football. He encouraged the guy to try acting. In a roundabout way, we have Jack Kerouac to thank for Paul Gleason, one of the '80s movies' most memorable villains. (An interesting man in his own right.)

(There are enough quotes and parentheses in this reply to resemble a LISP program, sorry about that.)

But this, for some reason, reminds me that Kerouac was also a devoted baseball mind. Not just a fan, but a proto-fantasy league commissioner before the term existed, meticulously tracking invented teams and players in private box scores. Kerouac, a fantasy baseball writer.

And he wasn't alone: Corso batted lines like fastballs, Ferlinghetti cheered from the dugout of City Lights, and Ginsberg, ever the cosmic catcher, enjoyed the sport. Baseball wasn't a pastime but a parallel Beat narrative, complete with innings, errors, and the occasional poetic balk and haiku.

But I’ve also written larger applications and, frankly, a ridiculous amount of documentation in Acme. That 9P protocol was my backstage pass: every window, every label, was accessible and programmable. I could, for example, hook into a save event and automatically format, lint, and compile ten or fifteen years before most IDEs figured out how to fake that kind of integration.

Sure, the system demands precision. It doesn't coddle. But for me, that was the feature, not the bug. The rigor sharpened my thinking. It taught me to be exact or be silent, forcing me to pause when I usually would not.

You have to understand: my first DOS machine was a Tandy 1000, acquired before I had a driver’s license. It was upgraded over the years and not retired until the grunge was well underway and I had already been married and divorced.

MS-DOS’s edit had WordStar keybindings; Ctrl-S to move back, Ctrl-E to move up, and so on. My dad "brought" home a copy of WordStar from work, and oh, the things that trio, WordStar, me, and a dot matrix printer conspired to create.

Borland carried those keybindings into Turbo Pascal, which I learned in college, having finally escaped the Fortran 77 gulag that was my high school’s TRS-80 Model III/IV lab. The investment into the Apple II lab didn't happen until AFTER they gave me my exit papers at a spring awards ceremony.

Why do I still prefer these tools?

Because they’re what I know. They don’t get in my way. We have history, a better and longer history that I have with my first wife. Those keybinds helped me write my first sorting algorithms, my first papers on circuit design, and the cover letters that got me my first jobs. They’re not just efficient. They’re familiar. They’re home.

I also use Sam and Acme from Plan 9 (technically from the excellent plan9port), but let’s be honest: those aren’t IDEs. They’re editors. Tools that let me think instead of wrestle.

There’s a lot we could (and probably should) learn from the old TUIs. For example, it’s perfectly acceptable, even heroic, to spawn a shell from the File menu and run something before returning. Seems people are afraid of losing style points with such grievous actions.

And the keybindings! So many of those classic TUIs adopted WordStar’s sacred keystrokes. They’re burned into my muscle memory so thoroughly that using EMACS feels like trying to type with oven mitts. For years, joe (with the blessed jstar alias) was my editor of choice.

Anyway! Time to boot the Dr. DOS VM, spin the wheel of Advent of Code, and be nostalgically inefficient on purpose.

Performance is up, but so is my inertia. So while TCL 9 could be transformative, for now it remains a white paper I've skimmed, not a revolution I've implemented.

https://www.tcl-lang.org/community/tcl2017/assets/talk93/Pap...

It's because Tcl, like SQLite, operates on a peculiar metaphysical principle: everything is a string until proven otherwise, and even then, it's probably still a string.

Also, D. Richard Happ, who we owe thanks for SQLite, was and perhaps still sits on the TCL Board (I may be wrong about that, but Happ holds significance in the TCL community).

In my mind:

Tcl is the quietly supportive roommate who keeps making coffee and feeding LISP-like functionality until the world finally notices its genius.

Lua sits across the table, sipping espresso with a faintly amused expression, wondering how everyone got so emotionally entangled with their configuration files.