stiiv

The abstract appeals to a few intuitions, and then vaguely waves toward a kind of slippery slope based on those intuitions, while adding that we ought to not use spatial distribution as bearing on parthood for certain kinds of entities. This has further intuitive appeal for folks who think that consciousness is a kind of emergent property.

It's a little cheeky and seems a little undergrad-ish to me, but I wouldn't call that either absurdist or postmodern.

Also what's wrong with the ship of theseus? If _you're_ tired of hearing that kind of argument, that's fine, but why dismiss it? It's thought-provoking at least, and the kind of thought it provokes has, in my opinion, some practical import

> but it's nothing like the code generating models we're all using today for code and automation.

Is this true? Code is structured output. At the very least it seems like a question of degree rather than kind.

While the LLMs we're using today are limited to sequenced text, it seems that a model like Jev could excel at coding on a more structural level (factoring, controls) by working within the constraints of an actual language specification and supplemental domain model. I don't know, though -- maybe that's too deep and complex.

I think Martin F's team tied outcomes to factoring https://martinfowler.com/articles/exploring-gen-ai/refactori... which is crucial to code quality. Even grug brain developer agree.

On the other hand, there are claims that the best languages for robots tend to be terse (allegedly); I tend to regard a rich domain model (static types, not terse) as a major facet of high-quality code.

When is the best time of year to read it?

LLM-based code generation requires disciplined operation to lead to the best outcomes. Shops who only ever had taste as a proxy for discipline were missing this before, and they're missing it now. The fact that it's missing is why so many organizations are tolerating ever-growing mountains of slop. (Not new, by the way; just dramatically accelerated.)

Discipline can be linked to system design standards and your review process, and it can be translated to measurable outcomes at scale and over time, regardless of how agents are involved: unplanned work, time to recovery, employee retention, etc. When outcomes like these become your priority, you see that you can't rely on taste alone.

Yes in both theme and style, I agree. While I appreciate pretty much everything by Borges, his dives into the infinite were the most memorable.

Congratulations on the launch! Really intriguing product.

How well would it work for a company that has the kinds of artifacts that you mentioned, but that lacks the quality/precision/accuracy that Hyper might need?

I'm especially thinking about mature companies that don't sell software and that have made a lot of mistakes and memorialized inconsistencies.

Is Hyper just a bad fit for them? Or could there be a path toward refinement and correction that eliminates ambiguities, etc.? For companies like this, Hyper could provide the clarity that such a company lacks day-to-day.

For building web applications or a system that includes logic that needs to run on the web? TypeScript is mature enough, and it's top tier for domain modeling. As long as you stay disciplined, Claude Code will write excellent TypeScript for you, and you can run it pretty much anywhere.

The only reasons to hesitate, imo, are (A) you're worried that it won't perform as well as you need on your servers, or (B) you're scared of npm supply chain attacks.

Agreed -- it's a wonderful film, and deserves a special place right up there with Star Wars and Harryhausen for its practical effects.

While the article mentions Moebius, I think this level of praise still merits an extra Incal callout, even if it just serves as a recommendation to those who want more of this stuff: https://en.wikipedia.org/wiki/The_Incal

Agreed! Investing lightly at this stage seems smart if your time/attention budget is tight.

> Claude Code and its ilk can turn "maybe one day" internal projects into live features after a single hour of work. You really, honestly, and truly are missing out if you're not looking for valuable things like that!

You're right, it's possible. But you might be both overestimating the ease of onboarding and underestimating the variety of tasks and constraints devs are responsible for.

I've seen Claude knock out trivial stuff with a sufficiently good spec. But I've also seen it utterly choke on a bad spec or a hard task. I think these outcomes are pretty broadly established. So is the expectation that the tech will get better. Waiting isn't unwise.

> If this tech is as amazing as you say it is, I'll be able to pick it up and become productive on a timescale of my choosing not yours.

Broadly speaking, I think this is a wise assessment. There are opportunities for productivity gains right now, but it I don't think it's a knockout for anyone using the tech, and I think that onboarding might be challenging for some people in the tech's current state.

It is safe to assume that the tech will continue to improve in both ways: productivity gains will increase, onboarding will get easier. I think it will also become easier to choose a particular suite of products to use too. Waiting is not a bad idea.

> On exception it exits dirtily and crashes, which is good enough for now

Silent failures and unexplained crashes are high on my list of things to avoid, but many teams just take them for granted in spite of the practical impact.

I think that a lot of orgs have a culture of "ship it and move on," accompanied by expectations like: QA will catch it, high turnover/lower-skill programmers commit stuff like this all the time anyway, or production code is expected to have some rough edges. I've been on teams like that, mostly in bigger orgs with high turnover and/or low engineering standards.

I'm wondering: why now, in early 2026? Why not last year? Why not in July? What changed? What does this teach us about Anthropic and what can we infer about their competition?

YMMV, of course. I set up our actions pipeline four years ago and basically never have to worry or even think about it. The UI isn't perfect, but it's good enough.

Our scenario: relatively simple monorepo, lots of docker, just enough bash, trunk-based dev strategy. It's great for that.

Last I knew, Rider was pretty much the only IDE available for a large codebase when you weren't on Windows. Much love for Ionide, but it was a serious struggle.

Is this any better now?

I think I agree with you. When I was part of a growing F# team a number of years ago, everyone we hired was an enthusiast who just loved coding in F# and wanted an opportunity to do it professionally. It turned out that this love, combined with the constraints of the language, led to a super-clean and legible code base. The quality was (in my estimation) outstanding, and I was sad to leave it.

For a great sci-fi treatment of the dangers of mirror life, see Fantastic Four 5-6 (2023) by Ryan North. Yes, that Ryan North, and no, it's not your "typical" comic book.

Flatland is a classic, though it's almost a pamphlet. While you asked for a novel, I can't resist recommending the short fiction of Borges.

Perfection for Leibniz might be considered more of a logical concept than an observable state. After all, he uses the same thing to argue (somehow) for the existence of god! https://plato.stanford.edu/entries/leibniz/#ExiGod

This leads to some strange conclusions about perfection that aren't intuitive, and sometimes seem monstous.

Justifiably! Supply-chain attacks have occurred via npm, and have been widely reported. A lack of oversight and lack of standard libraries are often cited as the cause.

I don't know if it's a problem for Rust (or other platforms like Python, .NET, or Java afaik).

As someone who primarily writes TypeScript to run in browsers and on node.js, this kind of threat requires an extra level of vigilence, and often nudges me toward writing my own things rather than importing them.

Would you kindly clarify your point? A supreme court justice is not a state or local official (as I understand the terms), so the ruling won't protect him.

dotenv has zero npm dependencies. dotenvx has 21, including a few I have never heard of. Is this really more secure?

fwiw Global Specialties has been making "protoboards" like this for decades. They're pretty expensive, though.

There is still something to be said for "real world uniqueness" (GIS coordinates) or deferring to a third party to establish identity (license plate numbers).

Identifiers like these aren't always available, but within many domains will be sufficient.

The idea here is not that these keys can't be somehow "invalid," but rather that it isn't our system's problem -- it belongs to some other authority.

Big thank you for clarifying -- I missed that. This approach is far less unsavory that some other attempts that I've seen.

Verbatim from OP.

It depends on what you're trying to achieve. If there are sufficient structural differences, you're fine (`"foo" in myThing` can discrimate) but if two types in your union have the same structure, TS doesn't give you a way to tell them apart. (This relates back to branded types.)

A good example would be `type Money = Dollars | Euros` where both types in the union alias `number`. You need a tag. In other languages, you don't.

Sure! You need a `type` field (or something like it) in TS.

You don't need that in a language like F# -- the discrimation occurs strictly in virtue of your union definition. That's what I meant by "native support."

> A runtime bug is now a compile time bug.

This isn't valuable to you? How do you get this without nominal typing, especially of primatives?