However, the real value is in complex, non-trivial, and above all novel code. This has been true for a long time, and it's just as true in open source as it is in industry or academia. Here, agents are far less useful. In fact, the only people I've seen have any kind of success using agents on these kinds of "serious" projects are people who are already serious programmers. They already know how to design and test stuff, they already know how to supervise junior developers, they already have an intuition for which aspects of the project the can safely delegate to a less experienced developer. So they're able to use agents as a "better autocomplete" in their own code, or use it to flesh out the non-essential and more routine aspects of the project, or even just delegate the agents to the role of code reviewer.

Here's the thing though. The less experienced ones, the people who don't already have those skills, they do get burned when they "stick the fork in the socket," as you put it, or in other words when they try to use agents to take on projects they don't fully understand... but they don't learn anything! The ones I've seen, anyway. Relying on agents insulates you from the code, which also prevents you from building a mental model of what's going on under the hood, which in turn makes it impossible to learn anything at all. They just keep yelling at the agents, telling them to fix stuff even though each fix introduces yet another regression in an endless loop... they don't know how to dig themselves out of the hole they've dug. And after all, what is the solution? To spend five years down in the code mines, paying your dues as a junior dev, reading and typing and thinking about mere code for the requisite 10,000 hours? Nobody has the time or inclination for that.

Agents, in other words, break the learning loop. You can't learn to program, and therefore can't learn to design or architect software, not really, if you're using agents. I am unfortunately coming to the sad conclusion that the last programmer has already been born; if you didn't have 5+ years of experience and a pretty good handle on the more advanced aspects of programming (such as software architecture, design patterns, optimization, debugging, etc.) before agentic programming became a thing, then I don't see how you ever will.

It'll be like COBOL programmers - the industry will shrink from the top-down, with the first to go being the new college graduates looking to enter the workforce. Inexperienced devs have always been given less interesting projects, but they stuck it out because they were learning valuable skills, building experience, making the economically rational decision to invest in their own career. But anyone entering the market today will never get out of that trench - anyone that actually needs a real programmer for a serious project will hire someone with decades of experience - there will be plenty of supply. And the projects on offer for junior devs won't teach them how to program, only to supervise agents. As a knock-on effect, smart young people already see the writing on the wall and are pivoting to other majors, which just reinforces the trend. This might cause problems in a few decades when all the real programmers start to retire, but when has the market ever considered long term consequences?

Or use a graphical language like LabVIEW. I'd like to see an LLM drag connectors around using Playwright MCP if it doesn't have a DOM and has to script mouse movements and take screenshots. They can probably do it but it would be unbelievably slow and token heavy.

The character counting is interesting but I predict frontier models are going to give up on tokens and just traim end-to-end on characters soon, just as voice models have largely moved past phonemes and for pretty much the same reasons.

https://www.oranlooney.com/docs/jev_eudemonia2.png

Also relevant: https://news.ycombinator.com/item?id=49812769#49824215

https://x.com/oranlooney/status/2102927869974303071

A standard drop of water is 0.05 ml. A standard household bucket is about 3 gallons. So the proverbial "drop in the bucket" is 0.0004%.

So, for all you naysayers out there saying this is just a drop in the bucket, it's literally x10 that.

Why, if they could get this up to a repeatable process and ban 13,000 accounts per day, that would be 1.5% every year. After a couple of years of work, that might even be perceptible to the average user. Sounds like the problem is well in hand.

Given that, all the study found was that harnesses do work when the benchmark is not saturated. It does not provide any evidence one way or the other about the effect harnesses have on frontier model performance. Therefore, the recommendations in the "what this means in practice" section are unsupported.

Comments URL: https://news.ycombinator.com/item?id=49824636

Points: 6

# Comments: 0

But I'm probably never going to write that article because, as your comment correctly points out, the tenor of the discourse isn't very healthy. Everyone is either "clowning on" Jev (as the kids say), or gulping down industrial quantities of Kool-Aid, or talking about the hype and branding instead of the math. I'll have to find a less contentious example if I want talk about calibration.

Edit: I just found something interesting: there already is a preprint case study[4] along the same lines as the one I outlined, posted just 2 days ago!

Unsurprisingly, they found that recalibration helps enormously, as you'd expect. I guess I could still talk about the Dutch book stuff if I gave a gambling/investing example, but that's pretty well-trodden territory. So now I have even less interest in writing that blog post.

[1]: https://en.wikipedia.org/wiki/Brier_score#Decompositions

[2]: https://en.wikipedia.org/wiki/Dutch_book_arguments

[3]: https://scikit-learn.org/stable/modules/calibration.html

[4]: https://arxiv.org/abs/2609.24052

https://www.oranlooney.com/post/playfair/#known-plaintext-at...

Slightly more complicated than the toy examples shown in the documentation above, and hints at one of the real world use cases for Z3 - red teaming cryptography.

That said, I'm not sure the documentation linked above is really doing it any favors in terms of helping popularizing it.

Yes:

https://en.wikipedia.org/wiki/Landauer%27s_principle

But modern computers are nowhere near this theoretical limit, nor any of the other limits I mentioned above. Nevertheless, most of heat generated from modern CPUs does come from bits turning on and off. Each transistor is a tiny capacitor, that holds a charge when its ON. When it switches OFF, it dumps that charge down the drain, creating waste heat. This is a limitation of our technolgy, not a fundamental limit of physics.

Could be worse, though; early chips would disipate heat even when they weren't doing anything. CMOS improved this enormously by pairing up "complementary" transistors so current only flows when something changes.

Still, from the universe's point of view, what we consider a super advanced computer is a lot closer to a space heater than anything that pushes up against its computational limits. Consider, for example, that quarks operate on time scales of 10^23 Hz, and the universe is happy to run three of those in every proton in every star in the universe. In fact, it runs 10^24 of them for one CPU, and that same CPU can't even simulate the quarks of one proton in real time.

Let's face it: we're like kids in Minecraft who think it's cool watch a calculation of 2+2 trickle through a redstone computer in a minute, while the GPU is rendering a billion triangles every second to give them that view.

    main::before { 
        background: 
            linear-gradient(rgba(18, 16, 16, 0) 50%, rgba(0, 0, 0, 0.25) 50%),
            linear-gradient( 90deg, rgba(255, 0, 0, 0.06), rgba(0, 255, 0, 0.02), rgba(0, 0, 255, 0.06) );
    }

    :root { 
        --text-shadow: 2px 0px red, -2px 0px var(--glitch-color-2);
    }

        explorator.dev        
        єӿƿłøгⱥʈøг.ᑻ

Computer scientists are in denial about it, but CS is a branch of theoretical physics, not mathematics. You can point to this or that model of computation, such as lambda calculus or mu-recursive functions and try to claim its abstracted well beyond the particular laws of physics for some specific universe, but they all have some kind of rate limit built into them... and where does the motivation for this idea, that it takes something (time, space, work) to compute something ultimately come from? That's right - from underlying physics itself[1] - from the Bekenstein bound or Bremermann's limit or the like.

Even apparently non-physically-realizable models of computation like non-deterministic Turing machines are ultimately informed by and motivated by concepts in physics... otherwise they would just be examples of chmess[2] and of no interest to anyone. Computer science is of course somewhat abstracted from the details, but no more so than, say, thermodynamics, where concepts like entropy or Gibbs free energy can be studied in the abstract without reference to whether we are talking about a gas of non-interacting molecules or the spins of a bunch of electrons trapped in a lattice.

So, it's of no surprise whatsoever that the fundamental problems of distributed computing are ultimately the same as those found in the relativity of simultaneity[3]. You've all been studying the same things all along, just with different tools and at different levels of abstraction.

[1]: https://en.wikipedia.org/wiki/Limits_of_computation

[2]: https://link.springer.com/article/10.1007/s11245-006-0005-2

[3]: https://en.wikipedia.org/wiki/Relativity_of_simultaneity

Other aspects of strategy, like shortening decision loops[1], forming alliances, or the exploration/exploitation tradeoff[3], are simply not represented by chess because it is a turn-based, zero-sum game with perfect information. That makes chess a poor model of real-world strategy.

Still, the things it does teach are real and useful, so as long as you don't think its the end-all, be-all of strategic thinking you can get something out of it.

[1]: https://en.wikipedia.org/wiki/OODA_loop

[2]: https://en.wikipedia.org/wiki/Cooperative_game_theory

[3]: https://en.wikipedia.org/wiki/Exploration%E2%80%93exploitati...

https://www.oranlooney.com/post/rose-petals/#language-models

It’s popular to dismiss LLMs as “just next token predictors.” This is technically true, but also kind of misses the point. Markov chains, RNNs, and transformers are all language models that can be described as “next token predictors,” but they don’t all work equally well. A better question to ask is: “What is this model’s inductive bias?”

A Markov chain (an -gram model) assumes the next word depends on the previous words, and that each possible combination of words has a completely independent parameter. (Andrey Markov proposed using this language model over a century ago, making it the granddaddy of modern LLMs.) So, for a vocabulary of size , there are parameters to learn. For even a smallish like 5, that already explodes the hypothesis space beyond what can be learned from even a huge text corpus like the entire internet. And, simultaneously, having a context window of only the previous 5 words is grossly inadequate for modeling real-world language. Like our FCNN above, this model suffers from having an inductive bias which is too weak.

RNNs tried to fix this problem by compressing the entire history into a single fixed-size state vector, updated one token at a time. But that compression is itself a brutal assumption: everything worth remembering about the past must survive being squeezed through a tiny bottleneck at every step. In practice, RNN models quickly lose the plot after a handful of sentences. Locally, the text they generate looks grammatically correct and meaningful, but zoom out a little and they’re basically nonsense generators. Like our naïve linear model, this model suffers from having an inductive bias which is too strong.

Transformers manage to hit a sweet spot: by keeping the recent history around as a working memory, and attending to different parts of it at different times, the transformer’s bias matches real structure in language: the referent of a pronoun, the subject of a verb, the parenthesis waiting to be closed. Not only that, but the particular structure of the transformer, basically a weighted sum of semantic vectors from the context window, has empirically been shown to somehow be a “good enough” match for the structure of real-world language found in the wild.

Transformers aren’t “smarter” than other possible language models, they just happen to land in that Goldilocks zone where their inductive bias is just right.

The same book contains an extraordinary number of nascent mathematical ideas. For example, he talks about "circular numbers," which today we would call modulo arithmetic. He gives a method of multiplication involving a cross that gives rise to our modern "X" symbol for multiplication, but was the first to use algebraic juxtaposition (simply putting two letters next to each other to denote multiplication) and the concept of an "exponent:" `E = mc^2` would look a lot different without Stifel's work!

The most amazing thing in the book, in my opinion, is the extraordinary connection between arithmetic progression and geometric progression he mentions in an almost offhand way[1] (link goes to the Internet Archive version of the book.)

    | -3  | -2  | -1  | 0 | 1 | 2 | 3 | 4  | 5  | 6  |
    |-----|-----|-----|---|---|---|---|----|----|----|
    | 1/8 | 1/4 | 1/2 | 1 | 2 | 4 | 8 | 16 | 32 | 64 |

[1]: https://archive.org/details/bub_gb_ywkW9hDd7IIC/page/n539/mo...

Comments URL: https://news.ycombinator.com/item?id=49223635

Points: 1

# Comments: 0

https://en.wikipedia.org/wiki/The_American_Scholar

https://andrewmbailey.com/papers/Higher-order%20truths%20abo...