This is a meaningless benchmark - for a small group of trusted big enterprises with insurance policies and mutually signed contracts you could've just as well used OSPF with zero filters.

The benchmark would be adoption by an actual large number of parties that don't/can't talk to eachother spread across the world. With a large chunk of them being malicious or incompetent to the point of being effectively malicious.

'It works' is a low bar. If that's the bar you set you are one bad incident away from finding out who stayed for the product and who stayed because switching felt annoying.

Also “one bad incident away” never works in practice. The last two decades have shown how people will use the tools that get the job done no matter what kinda privacy leaks, destructive things they have done to the user.

Last week I had to reinstall Claude Desktop because every time I opened it, it just hung.

This week I am sometimes opening it and getting a blank screen. It eventually works after I open it a few times.

And of course there's people complaining that somehow they're blowing their 5 hour token budget in 5 messages.

It's really buggy.

There's only so long their model will be their advantage before they all become very similar, and then the difference will be how reliable the tools are.

Right now the Claude Code code quality seems extremely low.

I can’t comment on Claude Desktop, sorry. Personally haven’t used it much.

The token usage looks like is intentional.

And I agree about the underlying model being the moat. If there’s something marginally better that comes up, people will switch to it (myself included). But for now it’s doing the job, despite all the hiccups, code quality and etc.

"Anthropic: Claude Code users hitting usage limits 'way faster than expected'"

https://news.ycombinator.com/item?id=47586176

Anthropic themselves have confirmed that something's wrong on reddit:

https://old.reddit.com/r/Anthropic/comments/1s7zfap/investig...

[0] https://arxiv.org/abs/2603.24755

Reverse-engineering through tests have never been easier, which could collapse the complexity and clean the code.

Obviously they don’t care. Adoption is exploding. Boris brags about making 30 commits a day to the codebase.

Only will be an issue down the line when the codebase has such high entropy it takes months to add new features (maybe already there).

It doesn’t mean every issue is valid, that it contains a suggestion that can be implemented, that it can be addressed immediately, etc. The issue list might not be curated, either, resulting in a garbage heap.

That's all that has mattered in every day and age.

I hope this leak can at least help silence the former. If you're going to flood the world with slop, at least own up to it.

  1. Randomly peeking at process.argv and process.env all around. Other weird layering violations, too.
  2. Tons of repeat code, eg. multiple ad-hoc implementations of hash functions / PRNGs.
  3. Almost no high-level comments about structure - I assume all that lives in some CLAUDE.md instead.

Such state should be strongly typed, have a canonical source of truth (which can then be also reused to document environment variables that the code supports, and eg. allow reading the same options from configs, flags, etc) and then explicitly passed to the functions that need it, eg. as function arguments or members of an associated instance.

This makes it easier to reason about the code (the caller will know that some module changes its functionality based on some state variable). It also makes it easier to test (both from the mechanical point of view of having to set environment variables which is gnarly, and from the point of view of once again knowing that the code changes its behaviour based on some state/option and both cases should probably be tested).

That's exactly why, access to global mutable state should be limited to as small a surface area as possible, so 99% of code can be locally deterministic and side-effect free, only using values that are passed into it. That makes testing easier too.

[0] https://unix.stackexchange.com/questions/38205/change-enviro...

It's extremely nested, it's basically an if statement soup

`useTypeahead.tsx` is even worse, extremely nested, a ton of "if else" statements, I doubt you'd look at it and think this is sane code

  export function extractSearchToken(completionToken: {
    token: string;
    isQuoted?: boolean;
  }): string {
    if (completionToken.isQuoted) {
      // Remove @" prefix and optional closing "
      return completionToken.token.slice(2).replace(/"$/, '');
    } else if (completionToken.token.startsWith('@')) {
      return completionToken.token.substring(1);
    } else {
      return completionToken.token;
    }
  }

What is the problem with that? How would you write that snippet? It is common in the new functional js landscape, even if it is pass-by-ref.

  export function extractSearchToken(completionToken: {
    token: string;
    isQuoted?: boolean;
  }): string {
    if (completionToken.isQuoted) {
      return completionToken.token.slice(2).replace(/"$/, '');
    }
    if (completionToken.token.startsWith('@')) {
      return completionToken.token.substring(1);
    }
    return completionToken.token;
  }

But you can achieve a similar effect by keeping your functions small, in which case I think both styles are roughly equivalent.

Do you care to elaborate? "if (...) return ...;" looks closer to an expression for me:

  export function extractSearchToken(completionToken: { token: string; isQuoted?: boolean }): string {
    if (completionToken.isQuoted) return completionToken.token.slice(2).replace(/"$/, '');

    if (completionToken.token.startsWith('@')) return completionToken.token.substring(1);

    return completionToken.token;
  }

But if you take a look at the other file, for example `useTypeahead` you'd see, even if there are a few code-gen / source-map artifacts, you still see the core logic, and behavior, is just a big bowl of soup

Optimize for consistency and a well thought out architecture, but let the gnarly looking function remain a gnarly function until it breaks and has to be refactored. Treat the functions as black boxes.

Personally the only time I open my IDE to look at code, it’s because I’m looking at something mission critical or very nuanced. For the remainder I trust my agent to deliver acceptable results.

But the man's argument is that since he sees something a given way then it's the truth. What people are doing in return is showing that he can only do so because of who he is.

Are you saying this post is a few edits away from becoming a New York Times bestseller?

But you're right, it did hit the front page, and that says more about my sensibilities not lining up with whoever is voting the article up.

What is this recent (clanker-fueled?) obsession to give everything fancy computer-y names with high numbers?

It's not a '12 stage pipeline', it's just an algorithm.

Do you know this kind of area and are commenting on the code?

https://www.youtube.com/watch?v=PAAkCSZUG1c&t=568s

The redirect only happens when it's configured on the web server, set in HSTS, or on a TLD that enforces HTTPS. None of these apply to this website.

A client side option to force https might still be useful though. But I can imagine at least some enterprise webapp that would die horribly if you tried this.