wild_egg

Napster??

To be honest, I think I meant to put that reply on a different comment.

In any case, we're on the same page about REST. OpenAPI was mentioned though and I don't think that's ever actually compatible with that type of usage.

I don't think I've ever encountered an API following OpenAPI that was completely self describing and could be discovered and navigated from a single entry URL. They're always paired with some swagger docs or other external content. That instantly makes them not RESTful.

But you're totally right that my comment didn't fit. Might have meant it for the grandparent comment? Not sure.

Sadly not. One of the constraints of REST is that the API be completely self-descriptive. If you need out-of-band information like an API spec, then it's basically not RESTful by definition.

I'm using a REST API to read your comment and submit my response — I didn't need to reference external HN API docs. The interface here is fully self-describing.

LLMs work great with REST so that's always still an option. MCPs have that nice third party plug and play experience but that doesn't mean we all have to build them.

I make tons of little REST APIs for my agents to use and in the AGENTS.md there's just a list of API entry points with descriptions on what they offer. Agents drive them with `curl` and it all works great.

Been thinking about this. Curious why you positioned it as Nano Banana having more utility than agents when it seems like the next level even would be Nano Banana with agents?

The two are kind of orthogonal concepts.

I don't think they're suggesting AI could one-shot a whole movie. It would be iterative, just like programming.

Claude is amazing at brownfield if you take the time to experiment with your approach.

Codex is stronger out of the box but properly customized Claude can't be matched at the moment

> Nano Banana has so much more utility than agents.

I am so far removed from multimedia spaces that I truly can't imagine a universe where this could be true. Agents have done incredible things for me and Nano Banana has been a cool gimmick for making memes.

Anyone have a use case for media models that'll expand my mind here?

Not just Python and Node. Package anything you want with them, that's what makes them convenient.

They're completely orthogonal features.

Skills are just reusable prompts in a convenient package.

Subagents get their own pristine context window to go off and perform some task. They can also run skills and do lots of context-heavy work and report back some small sliver of it to the main agent as a report.

Single vs double quotes is also semantically significant in Ruby. Double quoted strings support interpolation whereas single quoted does not.

Some weird strawman against OOP here when the whole post boils down to a rant against the overapplication of design patterns

The Uncanny Valley of prose.

Literally the heading as soon as you click the submitted link

> Learning Zig is not just about adding a language to your resume. It is about fundamentally changing how you think about software.

The "it's not X, it's Y" phrasing screams LLM these days

There's some OO design fallacy here but not sure what to call it.

The reason the aqua-plane broke the inheritance tree is because the modeling is being done backwards.

Objects should be defined by behaviour first and only incidentally contain whatever state is required to support that behaviour.

A well designed object is much more similar to a closure than it is to a data structure.

They're a dead end for whatever their definition of "AGI" is, but still incredibly useful in many areas and not a "dead end" economically.

Chicago95 theme for XFCE is great

Get your favourite coding agent to make one. These things are incredibly simple. You really only need a few ingredients:

- `sherpa-onnx` bindings for your favourite language

- package for capturing your mic input

- package for hotkey capture

- package for clipboard management (or shell out to `xclip`)

- shell out to `xdotool key --clearmodifiers "ctrl+v"` to paste

Tell it to go research all the above and then assemble into whatever form you want. I had Claude write a Go daemon that loads parakeet and runs as a systemd user service listening for Alt-Space in about 20 minutes.

A Smalltalk with all reflexivity removed just sounds pointless, no?

If you're into Haskell, you may like Coalton. It's an FP language written in CL with seamless interop.

https://github.com/coalton-lang/coalton

It supports basically all styles which makes it wonderfully useful in whatever domain you happen to find yourself in.

With a custom compression dictionary made against your JSON schema, I would bet you could still pack a surprising amount of data into 256 bytes that way.

You generally can't just have a quarterly check-in with humans either.

There's a significant fraction of humanity that would not clear the bar to meet current AGI definitions.

The distribution of human cognitive abilities is vast and current AI systems definitely exceed the capabilities of a surprising number of people.

I saw a twitter thread recently where someone tried to make this point to someone shilling AWS spaghetti architectures. They were subsequently dog-piled into oblivion but the mental gymnastics people can do around this subject is a sight to behold.

Simplicity is uncomfortable to a lot of people when they're used to doing things the hard way.

This was on my TODO list for the week, thanks for sharing!

Now I just need to make a skill for using Jira and I can go back to the MCP-free life.

In Smalltalk those methods don't return `true`. They take a block and evaluate it if the boolean receiving the message

    (a > b) ifTrue: [ "do something" ]

EDIT: to clarify what's happening there, `>` is a message sent to `a` that will result in a boolean. The True class and False class both understand the ifTrue: message and `True>>ifTrue:` executes the block whereas `False>>ifTrue:` just throws it away.

There's no `if` keyword in the language. Control flow is done purely through polymorphism.

Tell it to use subagents more. I often say something like "you're banned from taking direct actions, use subagents for everything" and it can run easily for 60-90 minutes before a compaction.

This actually makes a disturbing amount of sense and I think I'm going to need to chew on it for a while. Thanks for sharing!

If I understand the code for these correctly though, you're not actually doing the "idiomatic" datastar things as the article describes? No diffing/patching individual elements, just rerender the entire page?

Tbh that mental model seems so much simpler than any or all of the other datastar examples I see with convoluted client state tracking from the server.

Would you build complex apps this way as well? I'd assume this simple approach only works because the UI being rendered is also relatively simple. Is there any content I can read around doing this "immediate mode" approach when the user is navigating across very different pages with possibly complicated widget states needing to be tracked to rerender correctly?

Really love that a main criticism is missing static typing in a Ruby system. I assume the Rails devs know how to work with dynamically typed code on the backend — the same practices will work fine on the frontend with vanilla JS.

If static types are so fundamental for you, I'd suggest skipping Rails entirely and reading other content.