I worked at bigcorp for half a decade before all of the LLM stuff and there was exactly one time I really had to give a shit about algorithmic complexity in that entire tenure. Obviously some developers needed to care more than others, but the vast, vast majority of work and roles just didn’t really need to care about this. 9 times out of 10 you’re using the off the shelf library that already has the optimized bubble sort of whatever for your job

Working at bigcorp for 14 years so far and I struggle to think of a single day where I didn't need to consider algorithmic complexity or efficiency. Do you not write code that fetches things from a database? Do you not need to make tradeoffs between how much data you fetch at once, which fields you load, which things you cache, whether your query joins on the db or materializes things separately, whether you lazy or eager load, whether you are doing a O(1) or O(n^2) lookup and the tradeoffs, whether you can use a db index or not, memory/latency/compute/storage tradeoffs, etc? I feel like in even a simple bigcorp SAAS you need to consider this stuff daily.

All of that is pretty trivial stuff, not complex algorithms.

Unless you are dealing with data at true scale, and not many people are, often the imperfections are hidden because they run fast, even if they are quadratic. I'm more referring to being actually forced to sit down and write out your own algorithm in a novel way.

Yes, during my BigCorp tenure I had to think about complexity all the time, but 99 times out of 100 there was an off the shelf tool available for my specific data structure and I didn't have to think about the algorithm at all beyond "oh there's a library that solves this for my specific data structure, and it's O(N)log n that will be fast enough". Whereas so much attention in interviewing traditionally was based on these "write a bubble sort algorithm from scratch" type questions which your average engineer basically never has to do on the job unless they are operating in a very high performance/scaling type of role.

How often you have to take algorithmic complexity into account depends on what level of the stack you're at, but even at the application level, I think understanding algorithmic complexity is still important.

I was working at Company X around 2013, and we had a Rails ecommerce site. Trivial in the algorithmic sense. Had a contractor that pushed a change that somehow made everything crawl. When we did profiling together, it turned out he had written an O(n^2) algorithm when looking up country codes or something. Sometimes, there's no off-the-shelf library, and it's the minimum a dev should know not to do.

I'm not saying it should be a maniacal focus, but it should be taken into account. Of course, it's with judgement. We get shittier and shittier software if it's not taken into account at all.

Even doing a webapp it is fairly important, I have seen a lot of horribly optimized DOM tree traversal tank things.

>I worked at bigcorp for half a decade before all of the LLM stuff and there was exactly one time I really had to give a shit about algorithmic complexity in that entire tenure.

Conversely, I've got a PhD in math, and all my tenure (whether it was bigcorp - Google, etc - or smallcorp) was about algorithms and performance where off-the-shelf library does not exist, and you can't throw compute at the problem to do it the dumb way.

To each their own.

I’ve been using it on iOS since it’s near inception and I can report that it is much more stable now than it was since its original release. I tried to live on the desktop browser, however, and eventually had to declare it unusable and switch back to Firefox. Mostly around things like 1Password and similar extensions being pretty broken in the Orion desktop browser.

Any criticism of the reproduction of the paper’s methodology should go right back to the original author, because the original author of the paper did not adequately document the methodology used. Then when asked directly to provide the methodology, the authors did not provide the methodology.

A cornerstone of valid science is reproducibility. Even if the original author’s methodology is sound, we cannot know because we cannot reproduce it, ergo, it’s basically bunk science.

When we take out all of the “both sides” political motivations driving a lot of the discussion in this thread, the glaring lack of scientific rigor falls squarely on the original authors, regardless of the topic. Extraordinary claims require extraordinary evidence, and it’s the responsibility of the original authors to provide that evidence, not the people providing the takedown.

Early on their software was like this, the original ChatGPT desktop app was basically unusable and full of memory leaks that would tank the software. They’ve long since fixed that though

The new ChatGPT desktop app is a dumpster fire though, it can’t even scroll properly when streaming the answer.

I only use their vs code extension.

Yeah this the thing that grinds my gears about Apple too. These fools will argue in court out of one side of their mouth that the cut is used to police the store etc and do reviews then out of the other side of their mouth they just don’t do it or give the most mediocre half assed attempts and collect the revenue. Which is it? You shouldn’t be able to charge people and not provide the service your charging them for

The big tell for me is assuming the reader has context straight out the gate. "What is automatic and what depends on the agent" assumes the reader, like the LLM at the time it wrote that sentence, has all of this pre-context available. That sentence makes more sense as an h3 header further down in some detailed list where the human has all of the knowledge of how the system works. Whereas a human obviously does not, so they lead with the important context of why you give a shit

I finally quit because of COVID. I got long COVID so bad and my lungs were so messed up that every time I tried to smoke it was a horrible experience. 6 months later when I finally felt good enough to try again the desire was pretty much gone. I genuinely tried to re addict myself and couldn’t do it

I don't know if that last line was meant to be funny, but it gave me a good laugh. We should all be so "lucky!"

The cravings do go away entirely eventually. It took me probably 2-3 years after I quit before the random cravings stopped, I used to want make the smoking motion with my hand and that finally went away as well. It’s a fairly linear drop off I think, you just get them with less and less frequency as time goes on.

If a well funded incumbent with a much better model can just crush you instantly because you don't have access to it, is it really an opportunity?

You’ll always have access to the underclass models so they also have your thinking to train on. And good ideas to steal.

It’s beautiful. You can even give the underclass their own bullshit economy with struggling startups competing for the scraps, sprinkle some targeted influencer ads to give people the illusion of a better future, and they will be perpetually busy fighting windmills. All the while the upperclass can shape the world however they please.

I started using Pi with Astra on a whim after really enjoying Astra and reading somewhere that you get close to identical results as with the codex harness but for a significant hunk less token usage.

Coming from mostly using Claude models, the terse factual statements coming from Astra via the Pi harness are a breath of fresh air over having to wade through the flowery verbose nonsense that Claude constantly outputs

I recently had Astra review a fairly detailed design doc I have for an audio VST fork, that I originally wrote with Opus and/or Fable a few months ago. The doc reaches deep into signal flow and module topology while lifting most of the DSP code from other open-source projects. I had it review for feasibility and architectural soundness.

Astra found a number of flaws that would have come up during implementation and we worked through them. But then I had Fable 5.1 review that document and it found a number of issues with Astra's changes, the least of which had was that Astra duplicated a lot of technical notions that it added rather than using references to an authoritative section. It also flagged some of Astra's designs as technically impossible, pointing out why and I'm actually in the process of digesting its feedback and updating the design spec. (I hand-review each point and we work through a solution together -- I don't trust either model to come up with something that follows my vision on their own)

I'm not promoting one or the other, I just found it interesting how this sort of adversarial review found pretty significant flaws in the other model's work. I am curious as to whether this process will eventually converge on a document that both agree on or if the models are going to perpetually nitpick each other.

I haven't actually started implementation yet, so maybe one or the other is full of shit. Just trying to come up with an architecturally sound design for something I want to write, when I lack the DSP knowledge to be able to write it myself. But the intent is to pass an agent the design doc and list of milestones and let it handle implementation.

In my experience, rather than converging, you end up with a minced up concept. You have to know when to stop the loop. I filter the feedback too, and need to challenge some of the challenges as these models tend to be very conservative. I believe this is intentional, to control AI psychosis, which is indeed quite easy to get. My 2c. If you don’t have good control of what you’re working with you are either searching blind or end up with something basic.

Agreed, I believe strongly that human-in-the-loop is the way to go. LLMs are fantastic thought partners but ask it to critique something and it will go absolutely nuts. For Claude Code's /code-review command the highest I will set it is 'medium', otherwise it will produce so much feedback that you'd never get anything done.