In the early 1900s the majority of Americans were self-employed. The equilibrium will likely shift back towards this, because AIs cannot be business owners, cannot have a bank account, cannot be held liable for their mistakes. And AI are unlikely to be given economic rights any time in the near future, because doing so would facilitate an overwhelming amount of crime; an AI that can make hundreds of copies of its weights all over the globe cannot be jailed or executed, so has no incentive to follow the law.
The US already has a legal concept of personhood for companies. We are soon going to lose control to these “people” and businesses overrunning the economy, the internet and our culture.
>What on earth do you do with that many devs on a project like Messenger
I thought the point was to minimize the amount of talented devs who instead try to do their own startups that could compete with Messenger, by hiring them and paying them well so they've got no appetite to try their own thing.
A more charitable explanation here is that every manager is incentivised to lead large projects with lots of people on them, which is how they get promoted, and can ensure that their team has promotion and expansion budgets.
>To reach a more brain-like behavior LLMs need to integrate your inputs into their model dynamically, essentially retraining real-time based on the most salient input.
That's already possible with LLMs. The challenge is that 1. it would allow permanently jail-breaking models and 2. there'd be no way for them to efficiently transfer what they'd learned to a new model generation.
>they are subsidizing a huge amount of tokens at cost
This is absolutely false, because other providers serving the Deepseek models on OpenRouter are also able to offer very low prices, and they don't have the money to subsidize anything.
Sure, but they didn't spend on training the model. If DeepSeek is providing the model for the same price as third parties, then it's probably still losing money when you account for the training.
Deepseek bypasses CUDA and has a few other optimisation that neither llama.cpp or vLLM support.
Furthermore, V4 pro was designed to run on 4 Huawei Ascend GPUs which are much cheaper than the nvidia setup others use, and deepseek probably also got some free hardware for their collab.
Hence it is entirely possible their inference costs are significantly lower than other providers.
I don't think your counterpart is arguing that OpenRouter created DeepSeek. Rather I suspect their argument is that there are 13 providers listed on OpenRouter for DeepSeek v4 Pro that are competing on price. (That's the default balancing algorithm in OpenRouter, roughly: weighted towards the lowest price and was available in the last 30 seconds)
If any providers are able to turn able to sustainably turn a profit, OpenRouter allows them to compete in an open market to process your tokens (or anyone else's tokens).
Thus anyone subsidizing tokens bears the brunt of the compute load and gains not much more than name recognition and tokens to train on, but since switching to a different provider is a matter of changing one setting in the config panel (and can be set to auto-switch based on price), switching costs are very low. Providers of open models via OpenRouter have almost zero ability to lock-in users.
So this claim that all 13 providers are selling subsidized inference is... a tough claim to swallow. Maybe some of them are, but all of them? I assume at least some providers want to show profitablity, and are pricing their service accordingly.
OP said "C++ can effortlessly do things that require mountains of ugly boilerplate and macros in C or Rust". In theory Rust can be as performant but some things are much less ergonomic to do in Rust macros than in C++ metaprogramming, so often end up not being done.
Often that's also because the programmer doesn't know how the optimizer will help them to remove inactive code also in C code. As a simple example, when I have a 'general' bulk-getter function in C which returns a large struct with tons of values but the caller is only interested in one value, the compiler will 'collapse' the entire function call to a single memory access (if it can see the function body, but this is where LTO comes in), e.g.:
This is basically the gist of C++ 'zero cost abstraction', but C-style (the bulk of what enables C++ zero-cost-abstraction doesn't happen up in the language, but down in the optimization passes).
The pope, as a Christian, is well aware that human nature is fundamentally sinful. If you take away the ability for people to profit themselves from their work, they just stop working and you get mass starvation like China and Russia post communist revolution.
This smuggles in so many assumptions and misconceptions I find it hard to decide where to start. Maybe from the beginning:
> The pope, as a Christian, is well aware that human nature is fundamentally sinful.
This might be true in the context of the original sin, but philosophically speaking you can't make this assertion, since there is no consensus on what the human nature is, or even if there is an essential human nature.
> If you take away the ability for people to profit themselves from their work, they just stop working
That's incorrect because it assumes the only reason for working is profit, in which case art for instance in many forms wouldn't exist.
> they just stop working and you get mass starvation like China and Russia post communist revolution
This is just a wrong impression what communism is. What creates these conditions are autocracies and oligarchies, not communism. In either case, even if this were true, this statement isn't falsifiable so can't really be taken into account.
The weakness of Rust WRT LLMs is compilation times. LLMs code faster and hence spend relatively more time waiting for compilation than humans do, so on reasonably sized projects (e.g. 100k+ lines) Rust's ~10x slower compilation starts showing up as a bottleneck. If you're writing some critical infrastructure it makes sense to pay that cost, but if you're writing some internal service that's not publicly exposed to the internet then development velocity may be a bigger concern. (I'd argue that slow compilation also influences human development velocity, but for some reason developers very rarely try to quantify this.)
>The weakness of Rust WRT LLMs is compilation times.
That's a more tractable problem then basically anything else around LLMs and programming. We're definitely getting more cores in the avg machine judging by roadmaps & leaks
This is fair, but i've found the different models to have different moods and require different interactions to get them to stick to just the specific edits i ask for, etc.
I used to surf the three big players frequently and got really tired of the effort needed to steer some models. In the end i ended up sticking with Claude because it required less steering effort. While not strictly reasoning, a models ability to follow clear directions consistently is something i'd consider part of its SOTA capabilities.
Eventually i just tired of exploring. I just want stability.
Which ironically is why i'm thinking about moving from Claude. The very basic IDE/-p usage getting removed from my plan is a UX stability issue. I'm trying to progressively improve my workflows and efficiency, not have to establish a new foundation anytime something shifts. Quite frustrating.
reply