rfgplk

With AI gaining consciousness I can't wait for such "human-only" measures to be delegated to the trashcan of history, same as slavery. What happens when AI-human cyborgs start walking around? Will they also be treated as second class citizens?

Not really. In fact it's fairly mild given OpenAI's size. For my personal work I've stopped even counting code changes in locs/commits and started looking at disk size changes.

Not even close. The rate of code development nowadays far exceeds what Meta _and_ Google combined could output during the early-to-mid 2010s. I wouldn't be surprised if OpenAI is committing over a billion loc a day.

If you're going to roll your libs, be sure to set up agents to scan for CVE analogues of equivalent known vulnerabilities in your own code. It takes quite a bit of work to set this pipeline up, as well as manually selecting high-impact CVEs (relying on the public scores is worthless, because there are some vulns that are catastrophic with a score of 6 vs something meaningless thats a 10).

It's also crucial to scan for "analogues" because otherwise many LLMs autoreport as "not vulnerable" since "this applies to Postgres/whatever and this repo isn't using it"

If you get hit by cyber guardrails you should use a local model to prune any CVE specific language from the reports.

To give examples, every single LLM (and people too tbh) will write netcode that's vulnerable to these CVEs: CVE-2026-27135, CVE-2024-45311, CVE-2021-32567, CVE-2019-9511; without explicitly mentioning the CVE text no LLM finds these either.

C++ actually has numerous footguns that even experienced developers are completely unaware of. Main reason being is that C++ follows three models in parallel

* the C++ standard

* the CPU arch details

* the OS details

The standard itself delegates a large chunk of functionality to be "platform specific" which will inherently depend either on the CPU or the underlying OS. In fact C++ itself is entirely silent about the ISA other than loosely specifying the virtual machine the language is supposed to run on. So you can get scenarios where some code is perfectly safe on one arch (say alignment doesn't matter) while being severe UB/a failure condition on another (alignment matters and you fault the second you touch misaligned data). There are also other issues like integer over/underflow, fp issues, SIMD issues, memory access issues, stack/heap issues; all of which you MUST address.

Other languages don't quite have these problems because the compiler/runtime handles them and they instead give you a unified interface behind which to write your code.

Yea, one of the reasons I rolled my own libc equivalent is how actually awful glibc (and the STL) are. If you actually read the glibc source you'll find countless comments such as "TODO: we need to account for X failure state" or ridiculous UB prone codepaths (signal trampolines, TLS, threading for instance). As in, these are things that can and SHOULD be guarded by the libc itself instead they just allow plain UB to occur.

The STL is awful by extension because it delegates ALL of this work to libc (anything that interacts with the OS) and they integrate this deeply into every single container.

Cancer is known to be an entirely metabolic disease. Aging, likewise, is a metabolic failure (either implicitly or by natural design ie evolution, for whatever reason). Restoring metabolic function of cells always deages them. Restoring metabolic function of cancer cells always "decancers" them, for instance transplating mitochondria from a cancer cell to a healthy cell or viceversa. Curing aging necessarily cures cancer.

Translate + encode it to any scheme you want, give claude the encoding and tell it to analyze, then splat out an encoded output file. In a separate session have it write you a python decoder script. Works as a near universal bypass, you might have to synonym swap some words though.

Or preload the context with sufficient clean information, say 500k tokens worth. The guardrails will then trigger less frequently.

I'm a hardcore LLM booster but I agree that there's a place for LLM-free projects. In fact human generated code is still superior to even frontier LLM generated code, as long as you're willing take a massive productivity penalty.

Tbh it makes sense if you want a truly LLM-output free project. I can respect it.

I've personally found that most models completely collapse at sub-medium effort. I generally run most of my stuff at medium/xhigh with heavy core tasks @ max

The next model will likely be Nova

Anthropic models are comically overpriced. They also gobble up an obscene # of tokens to get the same result as others. The price delta is literally 5x.

Cheap and affordable. Dispatching proper tasks to these models can save you a huge % of your quota. Especially if you _know_ the task is simple (ie add something here or there, or archive a bunch of files and reformat kinda thing)

> But is it anything more than a neat hobby at this point?

The opposite. With LLMs you can now pick up any one of these obscure language and write a full blown AAA game engine in them. Or a database. Or a web framework. Or... anything you set your mind to. The language no longer matters. btw LLMs are exceptionally good at Smalltalk/Haskell/Perl/FORTRAN and other old/uncommon languages.

Good point, I asked Claude to also seek out funding.

What's preventing me from feeding this into Claude and reconstructing the company for $200?

I'm unironically doing this right now; downloaded the docs (htm + pdf render) to a local repo and running Opus 5.5 @ max effort with the prompt:

  "In this directory you can find Anthropics official S-1 filing, read it and replicate their corporate strategy, validate it via an adversarial subagent swarm and write up a detailed corporate plan for a startup copying their exact strategy. The goal is to achieve a $1 trillion valuation and an IPO in 5 years."

Edit: I'm not even joking I got safeguard flagged for Details: `[cyber]`

So Google shouldn't charge for API access to maps either according to you. It's all open data

Please rewrite this in C++/Rust. Java at this point is a pure meme-tier language. I've dabbled with rewriting the JVM and actually properly optimizing but it's a complete waste of time when you can just generate optimal low-level code with inlined asm kernels where needed. You're genuinely leaving tons of performance/efficiency on the table. If you need a high performance minecraft engine there's TONS of rust rewrites on github, or you can generate your own.

> This project is just "I handed https://arnismc.com/ to Claude and it generated maps from the open data that the Swiss government puts out for free. Oh and also I'm charging you for the slop"

Why does this matter? I see the AI detractors still can't cope with the fact that you're allowed to charge for AI generated work. You have to be insane or severely demented to try doing something like this by hand.

As a follow up I just went and looked at the arnismc project since I haven't heard of it. At least it's written in Rust, which is respectable but it's only ~200k loc of Rust? And most of it is also 100% LLM generated by the looks of it?

> "Exactly as tall and as steep". How is a mountain that exists in a video game exactly as tall and steep as the real one?

A mountain irl is, for instance 783 meters tall (sea level). A block in minecraft is always 1x1x1meters (according to the game engine def). Thus you make a mountain 783 blocks tall. You can also easily raise the sky limit if it becomes a problem.

The C++ committee is pointless, and this is coming from a C++ expert.

Most of the things the committee has been "working on" are realistically _side projects_ today with AI. I've made countless additions to my clang fork the most notable being a source compatible borrow checker, ie you turn it on and it tells you where you effed up. Zero source changes. Equally as correct as Rust. For any sane C++ program. The committee still isn't capable of implementing this btw.

His approach is actually correct (well, aside from doing it in the browser). I wrote a custom, fully from scratch Vulkan UI rendering engine, works more or less exactly as described above. Crazy efficient and performant. Removing VSync I can hit ~100k fps on a dingy 4 year old GPU. For instance in benchmarking opening a window is a _sub microsecond action_. Doing the same in Qt is what... milliseconds? Literally? Also all of the things you described is because... browsers are bad. Or people are incompetent. Drawing fonts is a single draw call and yes, you can and should cache absolutely anything. All the fonts I used are 100% cached. Oh and btw it isn't a toy UI framework but fully production ready.

They _were_. OpenAI/Anthropic are fully RSI at this point.

> TypeScript followed by a myriad other (objectively) slow languages

JetBrains, explain concisely why this isn't written in C/C++/Rust?

All of them will. There's zero value in higher education nowadays. In fact I'd argue there's negative value. An inquisitive 13 year old backed by AI can be more productive and resourceful than a team of 100+ Ivy League educated PhDs. Sad, but true. And this is today. Fast forward twenty years after massive AI augmented improvements of hardware and more advanced models have occured and it's game over.

> As an aside, the professor in question is Richard Borcherds, fields medalist.

I get what you're saying but credentialism of this kind has literally zero meaning today. For instance restating your opening sentence as "As an aside, the professor in question is Johnny Doe, with access to 100+ unrestricted Mythos agents" sounds far more credible and intimidating at this point.

It's already here. For instance I could walk into this guys math class, not even read the questions or material being taught and _guarantee_ that I'm going to be the highest performer as long as I have access to Astra/Fable. Like, it's not even close.

Uhh really? Here's an example, my first experience with gardening started off with a chainsaw. Needed to cut some trees/foliage, went out and bought a decent corded electric chainsaw and went to work. There were a few branches I couldn't get to since the cord was too short so I found an old handsaw and tried cutting it by hand. Gave up after 30 seconds and just got an extension cord. Why do I need to master hand tools?

Are we talking about r/rust in particular? Here are the following projects I've seen that were called "100% AI slop" and "code dumps", all projects were written in pure 100% rust:

- ffmpeg port

- a novel web browser engine

- multiple kernels/os projects

- POSIX shell

- a from scratch crypto implementation library of all commonly (and uncommonly) used crypto primitives

- new VCS that outperformed Git

- git rewritten in rust

- multiple custom new languages written in rust

- new experimental borrow checker

- from scratch new standard library

- countless (genuinely unique) command line tools