I'm actively moving away from Node.js and JavaScript in general. This has been triggered by recent spike in supply chain attacks.

Backend: I'm choosing to use Golang, since it has one of the most complete standard libraries. This means I don't have to install 3rd party libraries for common tasks. It is also quite performant, and has great support for DIY cross platform tooling, which I anticipate will become more and more important as LLMs evolve and require stricter guardrails and more complex orchestration.

Frontend: I have no real choice except JavaScript, of course. So I'm choosing ESBuild, which has 0 dependencies, for the build system instead of Vite. I don't mind the lack of HMR now, thanks to how quickly LLMs work. React happily also has 0 dependencies, so I don't need to switch away from there, and can roll my own state management using React Contexts.

Sort of sad, but we can't really say nobody saw this coming. I wish NPM paid more attention to supply chain issues and mitigated them early, for example with a better standard library, instead of just trusting 3rd party developers for basic needs.

I don't know about the other UIs, but on the web, some things impinge on the model you (and Redux) are proposing.

One thing is: you, in the gamedev world, have the luxury of having a frame buffer to write to. You fully control what gets rendered. Unfortunately, React and its cousins all have to deal with the idiosyncracies of the legacy browser environment. You have CSS, which applies and cascades styles to elements and their children in often non-obvious ways, and is a monster to deal with on any given day.

In addition to CSS, you have multiple potential sources of state. Every HTML slider, dropdown, input field, accordion, radio button, checkbox has its own browser-native state. You have to control for that.

On top of all of this, the browser application is usually just a frontend client that has to interact with a backend server, with asynchronous calls that require wait-state and failure-state management.

One thing that's in common with all of the above problems is: they're localized. All of these things I'm describing are specific to the rendering layer and therefore the component layer; they are not related to central state. A central state trying to capture all of these problems will fail, because component state has to be wrangled locally near where the HTML is; CSS also is component-level; and the network states are often very closely related to each component. If we maintain a central "game state", the data complexity just proliferates endlessly for each instance of the component.

So, the default these days is to keep state very close to each component, including network state, and often business logic also gets sucked into the mix. I try to avoid putting business logic in components, but people do it all the time unfortunately. But it does add to the complexity.

In other words, there is -real- complexity here, stemming from the fact that the web was never built to be a distribution+execution layer for rich applications, but evolved to become exactly that. It's not just bad application architecture or bad decisions by React maintainers.

Maybe I'm wrong, since I'm not a game developer and don't see what you're seeing on your side.

Shunyata means everything is empty. Empty of what? Empty of inherent, independent existence. That means everything is connected -- not only connected, but mostly illusory, sitting on top of a reality that cannot be understood in terms of objects, processes, distinctions, or boundaries between objects. Sometimes, this connection takes on strange forms.

For example: The horrible reality of war was a direct cause for your compassionate unease. I.e. war acted as a cause for compassion. This is strange. How do we reconcile this disturbing relationship, where a compassionate response is directly the child of war? In other words, horrific war has given rise to compassion, and this is a causal relationship, in the same way that a child arises from a mother. So, violence and love can arise from each other? What? Are they not supposed to be opposites?

The next step is a bit more provocative. Shunyata seems to imply that, since everything lacks inherent and independence existence, then suffering is not a part of the human condition. Instead, it is a mental construct. It isn't that the suffering of humanity does not exist; it's that it is constructed by the mind.

Deleuze and Guattari offers an interesting viewpoint on this. There are various intensities that do arise naturally. Injury, for example, is an intensity. But, suffering itself is not "really-real" unless we reify the intensities as suffering. And eliminating suffering partially involves the non-reification of intensities into suffering.

Obviously, easier said than done.

Anyway I'll leave it there. It's probably quite easy to destroy my points here, so I would appreciate it if people steelmanned my comment instead of strawmanning it. Shunyata is a genuinely useful discussion from a mental health and human flourishing standpoint. And has some very interesting and rigorous logic behind it. (see Mulamadhyamakakarika by Nagarjuna)

It will be interesting for me, trying to figure out how to differentiate from Claude Cowork in a meaningful way, but theres a lot of room here for competition, and no one application is likely to be "the best" at this. Having said that, I am sure Claude will be the category leader for quite a while, with first mover advantage.

I'm currently rolling out my alpha, and am looking for investment & partners.

Code has two aspects, tree-like and web-like:

* In its tree-like aspect, code is seen like an express train on rails: full of branching pathways. Forks on the highway and roads not taken. Extremely technical and complex. This is more of an 'algorithmic' view.

* In its web-like aspect, code is seen like a city: diverse places of interest that have grown unevenly across your project. Those spaces can be zoned in different ways: low-rise commercial, high-density industrial. This is more of an 'architectural' view.

With LLMs, I'm interpreting my code less and less like a tree... and more and more like a web. It's less about the branching logic now, and more about the places and spaces. The LLM takes care of the algorithmic details, while I can do the higher-level urban planning.

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

Points: 1

# Comments: 0

I've noticed a fundamental shift in how I engage with longform text — both in how I use it and how I perceive its purpose.

Longform content used to be something you navigated linearly, even when skimming. It was rich with meaning and nuance — each piece a territory to be explored and inhabited. Reading was a slow burn, a cognitive journey. It required attention, presence, patience.

But now, longform has become iconic — almost like an emoji. I treat it less as a continuous thread to follow, and more as a symbolic object. I copy and paste it across contexts, often without reading it deeply. When I do read, it's only to confirm that it’s the right kind of text — then I hand it off to an LLM-powered app like ChatGPT.

Longform is interactive now. The LargeLanguageModels is a responsive medium, giving tactile feedback with every tweak. Now I don't treat text as a finished work, but as raw material — tone, structure, rhythm, vibes — that I shape and reshape until it feels right. Longform is clay and LLMs are the wheel that lets me mould it.

This shift marks a new cultural paradigm. Why read the book when the LLM can summarize it? Why write a letter when the model can draft it for you? Why manually build a coherent thought when the system can scaffold it in seconds?

The LLM collapses the boundary between form and meaning. Text, as a medium, becomes secondary — even optional. Whether it’s a paragraph, a bullet list, a table, or a poem, the surface format is interchangeable. What matters now is the semantic payload — the idea behind the words. In that sense, the psychology and capability of the LLM become part of the medium itself. Text is no longer the sole conduit for thought — it’s just one of many containers.

And in this way, we begin to inch toward something that feels more telepathic. Writing becomes less about precisely articulating your ideas, and more about transmitting a series of semantic impulses. The model does the rendering. The wheel spins. You mold. The sentence is no longer the unit of meaning — the semantic gesture is.

It’s neither good nor bad. Just different. The ground is unmistakably shifting. I almost titled this page "Writing Longform Is Now Hot. Reading Longform Is Now Cool." because, in McLuhanesque terms, the poles have reversed. Writing now requires less immersion — it’s high-definition, low-participation. Meanwhile, reading longform, in a world of endless summaries and context-pivoting, asks for more. It’s become a cold medium.

There’s a joke: “My boss used ChatGPT to write an email to me. I summarized it and wrote a response using ChatGPT. He summarized my reply and read that.” People say: "See? Humans are now just intermediaries for LLMs to talk to themselves."

But that’s not quite right.

It’s not that we’re conduits for the machines. It’s that the machines let us bypass the noise of language — and get closer to pure semantic truth. What we’re really doing is offloading the form of communication so we can focus on the content of it.

And that, I suspect, is only the beginning.

Soon, OpenAI, Anthropic, and others will lean into this realization — if they haven’t already — and build tools that let us pivot, summarize, and remix content while preserving its semantic core. We'll get closer and closer to an interface for meaning itself. Language will become translucent. Interpretation will become seamless.

It’s a common trope to say humans are becoming telepathic. But transformer models are perhaps the first real step in that direction. As they evolve, converting raw impulses — even internal thoughtforms — into structured communication will become less of a challenge and more of a given.

Eventually, we’ll realize that text, audio, and video are just skins — just surfaces — wrapped around the same thing: semantic meaning. And once we can capture and convey that directly, we’ll look back and see that this shift wasn’t about losing language, but about transcending it.

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

Points: 3

# Comments: 1