Kerrick

I laugh every time somebody thinks every problem must have a root cause that pollutes every non-problem it touches.

It's a problem to use a blender to polish your jewelry. However, it's perfectly alright to use a blender to make a smoothie. It's not cognitive dissonance to write a blog post imploring people to stop polishing jewelry using a blender while also making a daily smoothie using the same tool.

I've been working to overcome this exact problem. I believe it's fully tractable. With proper deterministic tooling, the right words in context to anchor latent space, and a pilot with the software design skills to do it themselves, AI can help the pilot write and iterate upon properly-designed code faster than typing and using a traditional IDE. And along the way, it serves as a better rubber duck (but worse than a skilled pair programmer).

I don't want to maintain an information system written in the style of code golf competitions, either.

I like the author's proposed "Comprehension coverage" metric. It aligns well with Naur's Programming as Theory Building.

> the overall level of complexity of a project

The overall level of complexity of a project is not an "up means good" kind of measure. If you can achieve the same amount of functionality, obtain the same user experience, and have the same reliability with less complexity, you should.

Accidental complexity, as defined by Brooks in No Silver Bullet, should be minimized.

I dunno about autonomous, but it is happening at least a bit from human pilots. I've got a fork of a popular DevOps tool that I doubt the maintainers would want to upstream, so I'm not making a PR. I wouldn't have bothered before, but I believe LLMs can help me manage a deluge of rebases onto upstream.

Pretty dang common. OS X and macOS (and maybe iOS and iPadOS, though I'm not certain) have been autocorrecting "--" into "—" for over a decade. Windows users have been using Alt codes for them since approximately forever ago: https://superuser.com/q/811318.

Typography nerds, which are likely overrepresented on HN, love both em dash and en dash, and we especially love knowing when to use each. Punctation geeks, too! If you know what an octothorp or an interrobang are, you've probably been using em dashes for a long time.

Folks who didn't know what an em dash was by name are now experiencing the Baader-Meinhof phenomenon en masse. I've literally had to disable my "--" autocorrect just to not be accused of using an LLM when writing. It's annoying.

> the person writing the prompts knows what a quality solution looks like at a technical level and is reviewing the output as they go

That is exactly what I recommend, and it works like a charm. The person also has to have realistic expectations for the LLM, and be willing to work with a simulacrum that never learns (as frustrating as it seems at first glance).

> JSX/TSX, despite what React people might want you to believe, are not part of the language.

Similarly: TypeScript, despite what Node people might want you to believe, is not part of the JavaScript language.

> To prohibit a great people, however, from making all that they can of every part of their own produce, or from employing their stock and industry in the way that they judge most advantageous to themselves, is a manifest violation of the most sacred rights of mankind.

The Wealth of Nations, Adam Smith, 1776

I've added it to my AGENTS.md for Antigravity too.

RatatuiRuby is pretty new still: its beta launch was Jan 20. Octobox's TUI is built on it [0], and Sidekiq is using it to build theirs [1].

I believe they'll be maintainable long-term, as they've got extensive tests and documentation, and I built a theory of the program [2] on the Ruby side of it as I reviewed and guided the agent's work.

I am getting feedback from users, the largest of which drove the creation of (and iteration upon) Rooibos. As a rendering library, RatatuiRuby doesn't do much to guide the design or architecture of an application. Rooibos is an MVU/TEA framework [3] to do exactly that.

Tokra is basically a tech demo at this stage, [4] so (hopefully) no users yet.

[0]: https://ruby.social/@andrewnez@mastodon.social/1159351822843...

[1]: https://ruby.social/@getajobmike/115940044592981164

[2]: https://www.sciencedirect.com/science/article/abs/pii/016560...

[3]: https://guide.elm-lang.org/architecture/

[4]: https://ruby.social/@kerrick/115983502510721565

> Absolutely agree with this, the ratio of talk to output is insane, especially when the talk is all about how much better output is.

Those of us building are having so much fun we aren't slowing down to write think pieces.

I don't mean this flippantly. I'm a blogger. I love writing! But since a brief post on December 22 I haven't blogged because I have been too busy implementing incredible amounts of software with AI.

Since you'll want receipts, here they are:

- https://git.sr.ht/~kerrick/ratatui_ruby/tree/trunk/item/READ...

- https://git.sr.ht/~kerrick/rooibos/tree/trunk/item/README.rd...

- https://git.sr.ht/~kerrick/tokra/tree

Between Christmas and New Year's Day I was on vacation, so I had plenty of time. Since then, it's only been nights & weekends (and some early mornings and lunch breaks).

> Friction_cost is the energy lost to errors, retries, and misunderstandings when actually using the tool. [...] if the tool is very low friction, agents will revel in it like panthers in catnip, as I’ll discuss in the Desire Paths section.

This is why I think Ruby is such a great language for LLMs. Yeah, it's token-efficient, but that's not my point [0]. The DWIM/TIMTOWTDI [1] culture of Ruby libraries is incredible for LLMs. And LLMs help to compound exactly that.

For example, I recently published a library, RatatuiRuby [2], that feeds event objects to your application. It includes predicates like `event.a?` for the "a" key, and `event.enter?` for the Enter key. When I was implementing using the library, I saw the LLM try `event.tilde?`, which didn't exist. So... I added it! And dozens more [3]. It's great for humans and LLMs, because the friction of using it just disappears.

EDIT: I see that this was his later point exactly! FTA:

> What I did was make their hallucinations real, over and over, by implementing whatever I saw the agents trying to do [...]

[0]: Incidentally, Matz's static typing design, RBS, keeps it even more token-efficient as it adds type annotations. The types are in different files than the source code, which means they don't have to be loaded into context. Instead, only static analysis errors get added to context, which saves a lot of tokens compared to inline static types.

[1]: Do What I Mean / There Is More Than One Way To Do It

[2]: https://www.ratatui-ruby.dev

[3]: https://git.sr.ht/~kerrick/ratatui_ruby/commit/1eebe98063080...

If you're writing it, that's not a slop grenade. From the page:

> They asked you because they wanted your human judgment.

I'd love to hear more about those inconsistencies. Would you be willing to share?

I built RatatuiRuby recently, and I'm currently building Rooibos, its MVU framework to compete with BubbleTea. I'd love to avoid repeating Charm's mistakes.

Relevant: https://noslopgrenade.com

Did the word "Refactoring" become uncool when Design Patterns did the same?

Thanks!

> Q5. For which tasks do you use AI assistance most?

This is really tough for me. I haven't done a single one of those mostly-manually over the last month.

Any chance you'll add Antigravity and Jetbrains Junie? I've been using almost nothing but those for the last month. Antigravity at home, Junie at work.

It took a lot: https://fractaledmind.com/2023/12/23/rubyconftw/ and https://news.ycombinator.com/item?id=39835496

It's becoming so! Rails devs are starting to ship SQLite to production. It's not just for their main database either... it's replacing Redis for them, too.

Yes! While there's nothing built-in for that, you have full control over when you enter or exit raw mode, so your TUI can support opening an external editor. The TL;DR is you need to call `RatatuiRuby.restore_terminal` before handing off to $EDITOR, and you can call `RatatuiRuby.init_terminal` again to re-enter your TUI.

Here's an example: https://www.ratatui-ruby.dev/docs/trunk/examples/app_externa...

Also, if you enjoy Ink and Bubbletea, you probably enjoy MVU. If that's the case, check out the upcoming Rooibos framework I'm building on RatatuiRuby: https://rooibos.run. (Caveat: it doesn't yet have a way to restore/init the terminal, but I clearly need to make that happen.)

That's gotta be part of it. But I think another important part is how TUIs have important restrictions that lead to surprisingly delightful applications despite their downsides:

- You don't have control over font size and your color palette can be limited (and chosen by the user in their Terminal settings), so it's hard to go too off-the-rails in aesthetic design

- You work on a strict character grid, so it's hard to get things like padding, margin, and leading wrong.

- You can't assume the use of a mouse, so everything has to work on keyboard shortcuts. This usually leads to extremely power-user-friendly tools. Plus, keyboard-driven, power-user-friendly UIs are hot right now, even on the web (Linear, Fernand, etc.).

Every person I can enable to write Ruby instead of Go is a win in my book. :-)

Very significant. Nearly every commit has involved the use of one or more LLMs, as evidenced by the commit trailers. I would not have started this project without it, because I do not know Rust. Even the overall direction and architecture has involved roleplay-based "rubber ducking" with LLMs [0].

I've carefully stewarded & heavily edited the Ruby code in lib/ and test/, and the documentation (RDoc and Markdown). The Rust code has been left largely to the AI, with its quality kept presumably-okay by Clippy and extensive automated tests on the Ruby side.

As for the non-library stuff ("internal" to the project), you can tell by browsing the tasks/ folder where I left the AI to its own devices [1], and where I heavily edited the Ruby code [2].

[0]: https://man.sr.ht/~kerrick/ratatui_ruby/history/ecosystem-dr...

[1]: https://git.sr.ht/~kerrick/ratatui_ruby/tree/783a08eabe2307f...

[2]: https://git.sr.ht/~kerrick/ratatui_ruby/tree/783a08eabe2307f...

Thank you very much. I am not proud of the AI slop code [0] it took to get RDoc to generate the HTML for those pages, but I am proud of the result!

[0]: https://git.sr.ht/~kerrick/ratatui_ruby/tree/783a08eabe2307f...

[1]: https://www.ratatui-ruby.dev/docs/v1.0/examples/app_color_pi...

...?

The article is literally about not using web components. FTA:

> What would happen if we took the ideas of HTML Web Components and skipped all the JavaScript? [...] Okay great, we styled some HTML nested inside a custom element.

Thank you! I wrote the code snippets and picked the color palette, but the web design came by way of https://news.ycombinator.com/item?id=46587284

And my wife, wonderful as always, helped critique the writing! My RadioMenu class's comments (in the "See More: Inline menu example" expando-section) were far worse before she helped.

Thank you! Please let me know how you find it. I want to make sure the DX is as good as possible.

Thank you! My first Show HN in 2012 [0] was an inline TUI (of sorts) written in Ruby [1], so this is a great day.

[0]: https://news.ycombinator.com/item?id=4017933

[1]: https://kerrick.github.io/google/