not exactly the same, but worth noting that in a spectacular display of being too early, microsoft shipped this 30 years ago (active desktop in 1997 merged the windows explorer with internet explorer, turning folders into web pages).
all three are isomorphic. but in some languages if you define a function via something like `function myFun(x: Int, y: Bool) = ...` and also have some value `let a: (Int, Bool) = (1, true)` it doesn't mean you can call `myFun(a)`. because a parameter list is treated by the language as a different kind of construct than a tuple.
i can't speak for everyone, but in the above assertion am using 'roughly exponential' to mean that world population between say 1880 and 1960 followed a curve that is, roughly, exponential, in the technical sense. much of the discourse 50 years ago, e.g. the population bomb, was predicated on this observation.
not obvious to me this makes things better as opposed to worse? sure, the time bound helps but in the runup to a crunch won't we get vastly more devices in causal range at an asymptotically increasing rate?
never thought about it before but after playing with it a while i notice i tend to approach from the right, which means moving out if i'm inside on the right side. i think this is because my positioning accuracy seems to be higher moving leftwards than rightwards...
I've yet to be convinced by any article, including this one, that attempts to draw boxes around what coding agents are and aren't good at in a way that is robust on a 6 to 12 month horizon.
I agree that the examples listed here are relatable, and I've seen similar in my uses of various coding harnesses, including, to some degree, ones driven by opus 4.5. But my general experience with using LLMs for development over the last few years has been that:
1. Initially models could at best assemble a simple procedural or compositional sequences of commands or functions to accomplish a basic goal, perhaps meeting tests or type checking, but with no overall coherence,
2. To being able to structure small functions reasonably,
3. To being able to structure large functions reasonably,
4. To being able to structure medium-sized files reasonably,
5. To being able to structure large files, and small multi-file subsystems, somewhat reasonably.
So the idea that they are now falling down on the multi-module or multi-file or multi-microservice level is both not particularly surprising to me and also both not particularly indicative of future performance. There is a hierarchy of scales at which abstraction can be applied, and it seems plausible to me that the march of capability improvement is a continuous push upwards in the scale at which agents can reasonably abstract code.
Alternatively, there could be that there is a legitimate discontinuity here, at which anything resembling current approaches will max out, but I don't see strong evidence for it here.
I actually did something similar recently for my website* and it was actually a Claude failure case; helped a little but ultimately cost me more time than doing it entirely myself. For my version I wanted the actual book spine images; since there's no database for these, I took pictures of my shelves (milkcrates) and wanted clickable regions. I also wanted the spines to link to a reasonable webpage for the book, falling back to goodreads if nothing else was available.
It was very surprising to me that claude wasn't very good at even the latter. It took several rounds of prompt refinement, including very detailed instructions, to get even 75% non-broken links, from ~30% on first attempt. It really liked to hallucinate goodreads URLs with the book title in them but an invalid ID (the title part of URLs is ignored by goodreads).
The former was less surprising... It attempted a very rough manual strategy for generating superimposed SVG outlines on the books, which often started okay but by the right side of the the image often didn't even intersect the actual spines. I tried to verbally coax it into using a third party segmenter, but with no luck. We eventually found a binary search style iterative cropping strategy that worked well but was taking 6 minutes and nearly a couple dollars per spine so I killed that and just did the SVG outlines in figma myself.
* https://andrewblinn.com
scroll down to find the bookcase and drag down on it to zoom and unlock the books
this is somewhat true but i'm not sure how load bearing it is. for one, i think it's going to be a while until 'we asked the model what bob said' is as admissible as the result of a database query
interesting!! is BABLR yours? is there a page that talks about your error-correcting/embedding-gaps approach? couldn't immediate find one in the docs. btw new version of tylr (hazel's core editing engine) is multi-language from the ground up, with a javascript grammar underway; new version is not yet online though
there are approaches to ensure you always or almost always have syntactic validity, e.g. structured editing or error correcting parsing, though of course it's true that the more permissive the system is the more tortured some of the syntactic 'corrections' must be in extreme cases. the approach we're taking with http://hazel.org (which we approximate but don't fully succeed at yet) is: allow normal-ish typing, always correct the code enough to be ran/typechecked, but insert placeholders/decorations to telegraph the parse structure that we're using in case of errors or incompleteness.