coffeeaddict1

The question I have is what is an AI assisted contribution? For example, I still write code by hand, but I make many prototypes using AI before committing to a specific implementation. My code is clearly AI "assisted", but all of my final code is written by hand (no autocomplete either).

This has to be one of the most important moments in the history of mathematics. We now have a non-human intelligence capable of solving one of the most difficult problems in mathematics.

Video link: https://drive.google.com/file/d/1tQlzpnbWZfn2WtTFMoJgF93QteB...

This is a beyond remarkable achievement. Finding this lower bound within a few days of prompting is absolutely crazy.

No. This is not what I meant. I absolutely agree that std::indirect is an improvement. My point is that when dealing with C++ code, now there is yet another way of doing the same thing. I will have to remember both ways, because people will still keep using the old way.

Because I will still encounter people who use the old of writing pimpl. So I now I'm forced to remember the old way + new way. People aren't magically switching to use std::indirect. I bet that even in 10 years, half of projects will still be using the old way.

This is actually useful, but despite it is another extra thing you will have to remember when reading C++ code. I guess with LLMs things aren't so bad.

> Novel mathematical methods precede their application by at least a decade and widespread use by about a century.

This isn't really a good argument. The assumption here is that the "applications" were possible because of the math itself, but it leaves out the possibility if the math didn't exist somehow it will be discovered/invented because the applications demand so.

> There is a lot of mathematics created but we don’t yet know how to use it.

The vast majority of mathematical work is complete useless. Only a small percentage finds use in the real world (even if you consider the maths from centuries back).

For beginners that's irrelevant. WebGPU has more than enough features for beginners to learn about graphics programming. Not just that, once you're used to WebGPU, going to Vulkan will be much easier than the transition from OpenGL.

> The core problem with the modern apis is that they are so incredibly complicated that they will kill any newbie on the spot.

I would agree if by modern you mean DX12 or Vulkan, but WebGPU (and maybe even Metal) are quite decent.

Honestly, in 2026 I would not really bother with OpenGL. Just start with WebGPU, it's much nicer. You can use it easily on most modern browsers or better can even use native libraries like Dawn or WGPU.

> It might then seem reasonable to think that writing with a stylus on an iPad or similar would be best, since no force is needed and friction is minimized. I don’t think this is true. A small amount of friction is actually desirable.

I find digital handwriting quite pleasant and almost better than writing on paper. Friction is indeed an issue, but you can just buy a dedicated screen protector to address this problem.

> Has anything really important been solved by AI yet

Alphafold essentially solved the protein folding problem and it's arguably one of the biggest (if not the biggest) scientific achievements of the 21st century.

C++ would also introduce a myriad other subtle safety problems that would require years of expertise to even notice.

I disagree. Not all skills are useless. For example, I sometime use Qt for GUI projects and I have found their skills [0] very useful to improve the quality and performance of my projects. I their absence, I would each time have to direct the agents to find the docs or specific tools, wasting tokens and thus decreasing the quality of the output.

[0] https://github.com/TheQtCompanyRnD/agent-skills

An interesting opinion on this by Chandler Carruth: https://hachyderm.io/@chandlerc/116694268329657881.

This is what you can with Qt:

    #include <QApplication>
    #include <QWidget>
    #include <QPainter>

    class widget : public QWidget {
    void paintEvent(QPaintEvent*) override {
        QPainter(this).drawEllipse(QPoint(320, 240), 100, 100);
    }
    };

    int main(int argc, char *argv[]) {
        QApplication app(argc, argv);
        widget w;
        w.resize(640, 480);
        w.show();
        return app.exec();
    }

It doesn't seem too complicated to me.

I use AI mostly to prototype features in my existing projects. If I have an idea, I use the AI to implement it and try out different ways in which it could be implemented. Then I throw away the code and mostly write the code manually, with AI used primarily for review or docs.

While I agree that shared pointer are problematic (I almost never use them in C++), I don't think they're ever really the reason for performance issues in GUI apps. I've been doing GUI programming for more than a decade now and the overwhelming majority GUI performance issues come down to issues like poor use of concurrency (blocking GUI thread), unoptimised algorithms (e.g. for layouts), overdrawing, GPU/CPU sync issues or inefficient input handling.

I have never encountered a performance issue that was to due to reference counting (in fact I'm a big user of the CoW idiom when it comes to UI).

Ok fair enough, thanks for letting me know.

> Will any of this translate to Windows programs like File Manager?

Did you not read the thread? That's literally stated as an explicit goal.

I have to give it to Apple though in this case. Waves or warps are ridiculously uninformative, while simdgroups at least convey some useful information.

While the linked study is interesting, using standardised tests is a terrible way to judge if someone is "intelligent".

Also imo is very difficult to come up with a universal definition of intelligence. For example, I hold Lionel Messi to be a very "intelligent" footballer, but I would judge his intelligence to be of vastly different nature to that of Albert Einstein.

> I feel like an average human wouldn't pass some of these metrics yet they are "generally intelligent". On the other hand they also wouldn't pass a lot of the expert questions that AI is good at.

I think this approach is intentional. The philosophy is simply "extraordinary claims require extraordinary evidence". What you're saying is true, but producing a system that exhibits all human cognitive capabilities is a better threshold for the (absolutely wild) claim of the existence of AGI.

> And accountability can still exist? Is the engineer that created or reviewed a Pull Request using Claude Code less accountable then one that used PICO?

The point is that in the human scenario, you can hold the human agents accountable. You cannot do that with AI. Of course, you as the orchestrator of agents will be accountable to someone, but you won't have the benefit of holding your "subordinates" accountable, which is what you do in a human team. IMO, this renders the whole situation vastly different (whether good or bad I'm not sure).

But how can you be a responsible builder if you don't have trust in the LLMs doing the "right thing"? Suppose you're the head of a software team where you've picked up the best candidates for a given project, in that scenario I can see how one is able to trust the team members to orchestrate the implementation of your ideas and intentions, with you not being intimately familiar with the details. Can we place the same trust in LLM agents? I'm not sure. Even if one could somehow prove that LLM are very reliable, the fact an AI agents aren't accountable beings renders the whole situation vastly different than the human equivalent.

Usually, I tell the agent to try out an idea and if I don't like the implementation or approach I want to undo the code changes. Then I start again, feeding it more information so it can execute a different idea or the same one with a better plan. This also helps the context window small.

What I really want from Codex is checkpoints ala Copilot. There are a couple of issues [0][1] opened about on GitHub, but it doesn't seem a priority for the team.

[0] https://github.com/openai/codex/issues/2788

[1] https://github.com/openai/codex/issues/3585

> That's probably because we have yet to discover any universal moral standards.

This is true. Moral standards don't seem to be universal throughout history. I don't think anyone can debate this. However, this is different that claiming there is an objective morality.

In other words, humans may exhibit varying moral standards, but that doesn't mean that those are in correspondence with moral truths. Killing someone may or may not have been considered wrong in different cultures, but that doesn't tell us much about whether killing is indeed wrong or right.

I hate it too, but to my surprise, all of my colleagues (with an iPhone) said they love because it looks great.