Libraries create boundaries, which are in most cases arbitrary, that then limit the way you can interact with code, creating more boilerplate to get what you want from a library.

Abstractions are the source of bloat. Without abstractions you can always reduce bloat, or you can reduce bloat in your glue, but you can't reduce glue.

It takes discipline to NOT create arbitrary function signatures and short-lived intermediate data structures or type definitions. This is the beginning of boilerplate.

So many advances in removing boilerplate are realizing your 5 function calls and 10 intermediate data structures or type definitions, essentially compute a thing that you can do with 0 function calls and 0 custom datatypes and less lines of code.

The abstraction hides how simple the thing you want is.

Problem is that all open source code looks like the bloat described above, so LLMs have no idea how to actually write code that is without boilerplate. The only place where I've seen it work is in shaders, which are usually written to avoid common pitfalls of abstraction.

LLMs are incapable of writing a big program in 1 function and 1 file, that does what you want. Splitting the program into functions or even multiple files, is a step you do after a lot of time, yet all open source looks nothing like that.

Yep, people not understanding the value of abstraction is exactly why LLM coded apps are going to be a shit show. You could use them to come up with better abstractions, but most will not.

> Abstractions are the source of bloat. Without abstractions you can always reduce bloat, or you can reduce bloat in your glue, but you can't reduce glue.

I don’t think I agree. Here is an example.

QTcpSocket socket; socket.connectToHost(QHostAddress::LocalHost, 1234);

Vs:

int clientSocket = socket(AF_INET, SOCK_STREAM, 0);

    sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(1234);
    inet_pton(AF_INET, "127.0.0.1", &serverAddr.sin_addr);

    connect(clientSocket, (sockaddr*)&serverAddr, sizeof(serverAddr))

White colar work is just a lucky place to be, 99% of it is completely made up, there's people doing nothing, and people doing work of 10 people, does not matter, the work itself has no impact on anything.

A nice way to realize why this AI wave hasn't produced massive economy growth, it is mostly touching parts of economy which are parasitic and can't really create growth.

No. There is good signal in IMO gold medal performance.

These models actually learn distributed representations of nontrivial search algorithms.

A whole field of theorem provingaftwr decades of refinements couldn’t even win a medal yet 8B param models are doing it very well.

Attention mechanism, a bruteforce quadratic approach, combined with gradient descent is actually discovering very efficient distributed representations of algorithms. I don’t think they can even be extracted and made into an imperative program.

On reddit it's even worse, I feel like Reddit is internally having their own bots for engagement bait.

As someone who loves LaTeX, I can't imagine ever spending so much time on typography on online forums, italics, bold, emdashes, headers, sections. I quit reddit and will quit hn as well if situation worsens.

I have the sneaking suspicion that reddit has allowed and facilitated astroturfing for over a decade. As in, providing accounts, eliminating rate limits, artificially boosting posts and comments, and aggressively shadow banned contrary opinions. This is definitely a known phenomenon on a auto moderator level but I bet reddit ownership is complicit in it too

This behaviour is also openly acknowledged to have been used in early-Reddit growth hacking. So why not?

They were caught multiple times doing shady automated things. Most recently auto-translating posts and misleading search engine users with this. At this point there is no goodwill.

Funny how pydantic is used to parse and not validate but then there are post conditions after parsing which you should parse actually or which can be enforced with json schema and properly implemented constrained sampling on the LLM side.

Pipelines are often dynamic, how is this achieved?

Pipelines are just a description of computation, sometimes it makes sense to increase throughput, instead of low latency, by batching, is execution separate from the pipeline definition?

It's quite tricky as they optimize the agent loop, similar to codex.

It's probably not enough to have answer-prompt -> tool call -> result critic -> apply or refine, there might be a specific thing they're doing when they fine tune the loop to the model, or they might even train the model to improve the existing loop.

You would have to first look at their agent loop and then code it up from scratch.

I bet you could derive a lot by using a packet sniffer while using CC and just watch the calls go back and forth to the LLM API. In every api request you'll get the full prompt (system prompt aside) and they can't offload all the magic to the server side because tool calls have to be done locally. Also, LLMs can probably de-minimize the minimized Javascript in the CC client so you can inspect the source too.

edit: There's a tool, i haven't used it in forever, i think it was netsaint(?) that let you sniff https in clear text with some kind of proxy. The enabling requirement is sniffing traffic on localhost iirc which would be the case with CC

I would say IMO results demonstrated that. Silver was tiny 3B model.

All of our theorem provers had no way to approach silver medal performance despite decades of algorithmic leaps.

Learning stage for transformers has a while ago demonstrated some insanely good distributed jumps into good areas of combinatorial structures. Inference is just much faster than inference of algorithms that aren’t heavily informed by data.

It’s just a fully different distributed algorithm where we can’t probably even extract one working piece without breaking the performance of the whole.

World/word model is just not the case there. Gradient descent obviously landed to a distributed representation of an algorithm that does search.

Most software is just middlemen collecting money. Thats the reason why there is no economic drastic growth even with 2-3 years of AI.

What you’re worrying about is just bigger middlemen.

If you were not a value extracting middleman there would be no fear of replacement, because you can always create more than what you take.

I’m glad if this causes a shift in the industry and we lose x analysts, x architects, x scientists, data engineers and all other formulaic middlemen that just live in a weird middlemen economy.

It is immense luck that we don’t have to actually produce something and we get paid but it is much better if we’re forced to actually do something that isn’t empty.

Bandits?

Spaced repetition algos