There's also the phenomenon of having a memory of a memory. At age 10, I had a very solid recollection of my life at ages 5 to 6 (not so much of age 4). Now all I remember is that I used to remember a lot more than I do know.

US software devs also make 2x what their European colleagues do, but that never gets called out as bloat. Plus US software devs make that 2x pay without taking our additional loans for medical school at the rate of $75k per year or doing years of low pay residency where their salary doesn’t give them the means to pay off those loans.

There's a lot to be said about publishing in academia being broken and how nearly all the value comes from 10% of publications, while the rest are garbage spewed out for reasons orthogonal to the advancement knowledge. However, IMHO, none of that really applies to PhD theses.

Verbal diarrhea. Excessive passive tense and vagueries to dilute blame (who is the "prior" owner here - Johnson or the woman before they've been trying to scapegoat?) and to top it off multiple grammatical errors in a single sentence.

I can't believe they would let this draft hit the website in its current form this in the midst of what could be an existential crisis for there company.

- Argentinians in particular are over 60% of Italian descent.

- The richest man in Mexico was born to Lebanese immigrants.

- The chief military leader of the Chilean war of independence was born to an Irish immigrant.

- Peru had a president who was born to Japanese immigrants.

These countries have all, at various times, had an influx of overseas immigrants whose birthright citizen children rose to high stations in society.

From Yahoo Finance

GME Jan 1, 2016: $7.09, $5.49 adjusted (accounting for dividend disbursements)

GME Jan 1, 2026: $20.09

266% or 365% return depending on how you count dividends. 365% for GME vs. 306% for S&P 500 over the same period (also using adjusted for dividend numbers).

Tesla has been a meme stock for about five years now, maybe more. Its valuation correlates with Musk's abilities as a showman and media figure, not a businessman.

If you want a particular implementation approach, you need to specify not only the features you want, but the implementation strategy at least at a high level. This could be as simple as adding "use pywikibit" or "use relevant packages from pypi" to the end of your prompt. Or you could seed your project with some manually writtem scaffolding, including a pyproject.toml

While LLMs do tend have NIH syndrome by default, I think this is a good default. I'd much rather have tight control over when and how to include external dependencies as opposed to letting a prompt fire for 40 minutes, and coming back to find 2 GB of newly installed node packages with a dependency tree 300 levels deep.

Quite to the contrary, I think it's extremely trivial to find a task where humans beat LLMs.

For all the money that's been thrown at agentic coding, LLMs still produce substantially worse code than a senior dev. See my own prior comments on this for a concrete example [1].

These trivial failure cases show that there are dimensions to task proficiency - significant ones - that benchmarks fail to capture.

> Is medical diagnosis one of these high judgement tasks?

Situational. I would break diagnosis into three types:

1. The diagnosis comes from objective criteria - laboratory values, vital signs, visual findings, family history. I think LLMs are likely already superior to humans in this case.

2. The diagnosis comes from "chart lore" - reading notes from prior physicians and realizing that there is new context now points to a different diagnosis. (That new context can be the benefit of hindsight into what they already tried and failed and/or new objective data). LLMs do pretty good at this when you point them at datasets where all the prior notes were written by humans, which means that those humans did a nontrivial part of the diagnostic work. What if the prior notes were written by LLMs as well? Will they propagate their own mistakes forward? Yet to be studied in depth.

3. The diagnosis comes from human interaction - knowing the difference between a patient who's high as a bat on crack and one who's delirious from infection; noticing that a patient hesitates slightly before they assure you that they've been taking all their meds as prescribed; etc. I doubt that LLMs will ever beat humans at this, but if LLMs can be proven to be good at point 2, then point 3 alone will not save human physicians.

[1] https://news.ycombinator.com/threads?id=Calavar#47891432

In my opinion the main draw of Ruby is that it's kind of Lisp-y in the way you can quickly build a metalanguage tailored to your specific problem domain. For problems where I don't need metaprogramming, I'd rather use a language that is statically typed.

I have a shell script that automates this. If all tests pass, the shell script prints "200/200 passing" with very little token spend. If only 190/200 pass, the shell script reports the names of every test that failed, and now Claude does a process of

1) run the compiler binary -> 2) get assembly output and inspect for obvious errors -> 3) assemble -> 4) verify that the assembler did not report errors -> 5) run test binary, connect with gdb, and find the issue -> 6) edit the compiler source -> 7) recompile the compiler -> 8) back to 1

multiplied by 10 for the 10 failing tests. This eats up tokens very quickly. I realize that not every use case is going to look like this. But if I didn't have Claude verify against the test suite, then I'd be getting regressions left and right, and then what's the point?

The whole codebase (tests included) is less than 15k lines, so I don't think that's the issue. No MCPs. CLAUDE.md about 1.5k lines.

It writes a separate call to emit_raw for each line, even though there many successive calls to emit_raw before it runs into any branching or other dynamic logic. What if you change this

    emit_raw(ctx, "#include \n");
    emit_raw(ctx, "#include \n");
    emit_raw(ctx, "#include \n");
    emit_raw(ctx, "#include \n");
    // And on for dozens more lines

    emit_raw(ctx,
        "#include \n"
        "#include \n"
        "#include \n"
        "#include \n"
        // And on for dozens more lines
    );

[1] https://github.com/matz/spinel/blob/aba17d8266d72fae3555ec91...