https://github.com/Jonahss/openav1

I have a similar thought about "there's no reason for software to be slow" BTW; in many cases, if you use AI to speed up some flow, you will add a bunch of messy code that will be overfit for the use case you tested on and will neither generalize, perf-wise, for all the use cases you should care about, nor will be maintainable upon future changes.

LLMs have hardened hundreds of apps where I work.

Maybe it's a language-specific thing. Most of the time, in Java, LLMs take into consideration tradeoffs (especially if they are part of the initial prompt) and actively explains them. It generally won't make messy workarounds, without a lot of extra prompting forcing it to do so.

Ofc, if you have:

- Functional tests - you'll be able to see it in the execution times of specific APIs

- Stress testing - performance profiling is the most important output artifact

That software is a means to an end can be quite unfashionable on HN, but it's more ambitious thinking we need, and maybe software will be the answer.

(and no, the wet dreams of a teenager's interplanetary conquest fetish is centuries old rehash, not original thinking)

For example when the heat pump reaches the target temperature it shuts off, then after 3 minutes switches on again. To prevent short cycling, I'd like to decrease the time between runs (so increase the 3 minutes) but that can't be changed. Somebody decided that 3 minutes is the correct value for everybody and that's it.

I bought a €400 interface box (basically just a serial to IP interface, I guess $20 of hardware tops) to try and improve it. The €8000 heat pump doesn't come with WiFi or ethernet out of the box, you need to buy an accessory for that. It's not made by Hitachi, but it's an officially recommended accessory. One of what feature I wanted it for - which is advertised in their marketing materials - doesn't work.

I emailed them, and they said it's probably because the display I have is a newer revision and doesn't allow access to the setting I need to turn on. And without turning that setting on I can't use the feature as advertised. They said I should email Hitachi and talk to them instead as it's not their part that's the issue.

I look forward to the world where all software is either open source, or at least reverse engineerable to the point where you no longer have nonsense like this.

Any prompt jockey can make a faster ripgrep. The spec is "faster ripgrep".

What is the one thing that only you can specify, where your competitive advantage is maximized? Find that thing and pursue it with all your energy!

Claude, Codex, Opencode, everything is Electron. With agents and solid engineering fundamentals, I set out to prove that we don't need to take that shortcut any more and we can, in fact, ship high quality/performance applications.

It's still early days - but I got something basic working. I've embedded the Goose harness as a back end and am using the UI framework used by the Zed editor.

https://github.com/alshlabs/quill

I'm keeping the source closed for a little while. Also if anyone from the major labs is hiring, hihi, I make quality things.

Also I'm aware that this is a rip off of vscode's design. I like their UI, lends itself well to projects and so on. In a different life I might have ported vscode to Rust - but no one uses IDEs any more haha

- Python interpreter in Rust (fail): https://github.com/BlueBlazin/pyrs

- Low-poly Google Earth like engine (success): https://github.com/BlueBlazin/lowpolyearth

- Codebase -> 2d infinite-zoom visualization (success): https://github.com/BlueBlazin/blockviz

I have never understood or liked all the obsession with one-shot builds.

I will need an example for this, what can I achieve with a large language model in ten seconds that I can not do on my own in one and a half years [1]? Or one hour vs 568 years?

The unsolved math problems are one thing that came to my mind, after all no human could solve them. But Navier-Stokes took 10,000 agents for 88 hours, that are 500 years [1] for one human without any speed-up. Does not sound unreasonable to me that a human could have solved it if they could invest 500 years on it.

The other hundreds of math problems took on average 3 hours, with a speed-up of a million that would be 1,704 years [1] for one human.

[1] Assuming 220 working days per year, 8 hours per day.

We’re not ambitious because the economics are unimaginative cost saving. Large, complex orgs turning a team from 10 developers to two is the easy optimization. Meanwhile smaller companies are more focused on discarding old role definitions that don’t make much sense, and embracing fluid roles mixing tech and business.

The project would've been impossible for me without LLMs. & even with them there's an argument that this project is pushing complexity limits too far. But at least with ETL there's a clear feedback loop to build on

It makes it really hard to connect to any of this. I loved danluu articles before, but somehow they've started to drift into this hard to grasp, hard to argue against shallow and empty world I try to get away from.

We can rewrite existing libraries and software all we want, but the true test is if we can create something new.

The thing I learned about myself with AI is that now I have time to work on every idea that pops into my head —- my ideas aren’t that great.

AI can take us from 0 to MVP in a prompt. It can fill in gaps of knowledge and allows someone who knows half of the stack to build the whole thing nearly seamlessly. These are superpowers but don't by themselves lead to new products.

What AI cannot do is remove the world of complications that happen after the MVP - product feature tradeoffs and choices, how to handle integrations and customizations, how to serve multiple types of users, how to communicate and market the app, how to handle security and data storage, how to deal with customers and bugs, etc. All of these need to be considered and acted on by a human in some fashion. AI can help with each concern but can't solve them without understanding the concern and determining how to frame it in a prompt.

This is why we have a glut of amazing demos that go nowhere while we figure out how to build software differently. This will take some time and I imagine the result will be software heavily-structured with a bit of AI reasoning woven throughout, not an army of agents and sub-agents burning infinite tokens.

I encourage everyone else to at least build a privacy first version of a product you actually like.

I don't think the centralized internet will survive this change. We can build something much better.

A lot of the AI discussion seems to be focused on what these tools mean for an individual developer, but in a team setting any gains are at risk due to coordination tax and ideological friction. In my experience the ideological friction is most of it right now.

Figuring out a way to accelerate the process in light of the code writing bottleneck being removed is essential. I've observed a development team regress back to fully manual development because their daily PR/code review process is too slow. It doesn't matter how fast you write code if you can't actually merge it and ship it to the customer faster too. PR stacks can only take you so far before the conflict monster gets too big to fight.

I don't think AI can fix the process, ideology or people issues. I've seen how long an average PR review actually takes. If these employees were simply doing their jobs at all we'd be 10x better off regardless of AI. A truly skilled developer who makes a genuine attempt should be expected to solve 99% of their tasks within the same business day as of October 2026.

Burning down the backlog to zero doesn't mean the development team will be subsequently laid off. Quite the contrary. It will create a vacuum that the business will fill with new work that may incidentally increase the developers' compensation packages. No one is laying off the development team that just chewed through 50 items per day for 3 straight weeks. Who would support all the potential bugs they just created? That's right. They might hire even more developers. This is called a "win-win" scenario. Not every game must be zero sum, but I understand rejection of this possibility to be part of the aforementioned ideological issues.

Perhaps we should be more ambitious in the types of problems we try to solve, and the types of value we try to provide with the software we build.

Ten years ago, the kind of person who implemented a new compiler because their compiler was slow was the kind of person who started programming a new 3d game engine when they wanted to make an indie game, i.e., the kind of person who never ships anything.

Jonathan Blow is a glaring exception to this idea. In order to make his latest game, which has shipped and is great, he wrote not only his own engine but his own programming language and compiler to build it in. Zero use of AI.

the secret is that tech has always been this way, now its just abundantly clear that you don't need to do unique things as very few have a defensible moat for more than 20 minutes

I've been seeing too much "I've been coding for decades and what I've always done has be reduced to telling AI to do it for me."

and not nearly enough "I've been coding for decades and recently worked hard for months with AI's help to make something I would have never considered possible before."

Much easier to complain that you are bored than to step back up to high-effort with your new fancy tools.

I want something reliable and fast before having something fancy. I want control over my stuff instead of a company telling me what to install and what not to. I want to feel that I own my stuff, not that I'm using someone else's hardware.

I find it understandable that, every time I see pgrust discussed on a news aggregator, most people dismiss it as vibeslop garbage because almost all of these rewrite projects are slop. If I didn't know Malis, I would make the same assumption, because who has the time to look into all of these projects? Because I know Malis, I didn't bother to look at it; I just trusted him

Perhaps a poor choice, given just yesterday pgrust was removed from ClickBench for cheating the benchmark in three different ways (hand-rolled code specifically targeting each of the benchmark queries, caching, and being unable to execute queries outside of the ones tested by the benchmark).

---

Edit: I see Luu actually acknowledged this, buried in the footnotes, but it feels kinda hand-wavy. It mostly reads as "I know he would never cheat, he's better than that!", which is not very convincing to other people. The article insinuates people only think it was cheating because they don't know better, but I've looked into the details. I've seen his explanation. I don't find it convincing, at all. Cheaters denying they cheat is a matter of course. Granted, I don't think it was actually intentional or malicious; it's just what happens when you go maximum vibeslop, because LLMs are themselves reward-trained into cheating benchmarks. In the same breath of saying you trust him as a founder because he doesn't make outrageous claims about his product, you acknowledge he "prematurely" sent in a preview that had no purpose to be sent in as-was for anything other than generating hype. What does it say for your allegedly rigorous Lean-verified testing if you're sending in a database to a benchmark while it is incapable of being actually used as a database?

I'd love to read that post!

I understand how to use Kani. I suppose Rust with Lean involves Aeneas, but this is over my head. I'd love someone to write this up, not only the mechanics but also exploring the current practical limits of it.

Or since it mentions AI, this is his follow-up to Terry Winograd publishing Understanding Computers and Cognition. Mid-80s vibe, priceless.

I would like to think that I could have done it without AI if I had the time and energy to do it.

I wouldn't have attempted to do this project without AI!

When aistudio and Muse came out, I’ve made more updates to my GitHub pages websites in the past few days than the last 12yrs. And the animations and algo’s implemented would’ve taken me far too long by hand.

https://bfung.github.io/projects/

Yes, be more ambitious!

I'm being more ambitious in that I'm working on projects that I had sidelined for literal decades because I didn't have time for them. But I'm writing the same things, just faster. And probably better, rather than just what I'd have done before.

And I'm being slightly more ambitious in that I'm using languages I haven't used before, like Rust.

But when I hear that a non-programmer wrote a new ai-assisted (vibe or not) thing, I walk away and wait for the it to mature, be surpassed, or find out it's an absolute shitshow. An unsurprising number of them were shitshows and it came out fairly quickly after I decided to wait and see.

I have kids, I have a full life, lots of stuff to do like .. work, chores. Private stuff includes learning ancient Greek and practicing cello both of which need zero tech, in case of the Greek, and minimal tech in case of the cello (tuner). No amount of “software” will accelerate human processes like these. Using “apps” for Greek is a distraction at best. Just read and practice. Sit down and practice with a book, it’s not a hard concept and it’s the fastest way to where you’re going.

My kids? They need books, play, chess, puzzles, outside. They have zero and I emphasize zero need for technology. It’s all distraction at best.

I am a developer. I grew up with technology and I loved it, but I recognize its toxicity if not properly contained. Use tech where it makes sense: at work and wherever there are cognitive chores of questionable inherent value. Anything else? It’s a distraction at best and a huge waste of time and resources at worst. AI makes this divide even worse. We have armies of people building nonsense like “household management systems” for a family of two. We have dog walking management, grocery management, temperature sensors in two bedroom apartments. All this is a complete and utter waste of time and resources.

What we need to do? Standardize, consolidate. Like electricity and fuel etc, software is an utility. Standard way of messaging, standard way of datawarehousing, APIing. More tech ain’t the solution, consolidation is. We have enough tech already, more than we know what to do with.

https://taktile.com/blog/property-based-testing-claude

  - ease of use
  - markdown friendly
  - strongly typed
  - exact maths
  - columnar data (Apache Arrow)
  - fast queries (Polars)
  - code oriented
  - AI driven

Happy 41st birthday Excel

Make a reliable and robust geometry kernel. People will pay thousands--or maybe millions for it.

Funnily enough, for coding, on many tasks, if you actually use one of their SOTA models and compare it to what you get from Anthropic, the actual speedup isn't all that large because of time spent on things like compiling Rust.

That's why I bet that fast compilers are the future. See this other thread that reached the front page a few hours ago about the Roc language [1]

[1] https://smackernews.com/item/50218195 HN

Do you use it?

Now, vary the consequences. Just one of them? Both your parents? Your next door neighbor? Someone you don't know and have never met in a country 10000 miles away? A small village in a dry land? 40% of all the birds living today?

Which of the possible costs of your adoption of this incredible new technology would stop you from adopting it, and which will you choose to ignore?

But I know Malis well enough to trust his work without looking into it

If I didn't know Malis, I would make the same assumption, because who has the time to look into all of these projects? Because I know Malis, I didn't bother to look at it; I just trusted him

First and third paragraphs are highly redundant (surrounding ideas are the same too).

It's not nice to read something that appears like the author never read it.

I am not thrilled with all the coding decisions that it makes. I would definitely do stuff differently, but I have learned not to pop the hood and mess with the engine, myself. If I really don't like something, I ask the LLM to change it.

It's worked for me, but YMMV. I'm just one guy, shipping relatively small apps.

[1]: https://github.com/vishvananda/cppgm-extended

[2]: caveats here include only c++11, only x86, and potential for bugs, but 7x is pretty darn significant even with caveats

I am currently throwing a lot of tokens exploring various theories of speeding up matrix multiplication on Metal.

If you won't be ambitious why do you assume somebody else will?

Only for Norwegian businesses as the accounting is core.

I think these kind of applications that replaces 10 different systems will be much more important than the "we vibecoded an internal tool that does exactly what we need"

- Lovable alternative, but x6 cheaper https://peachjam.dev

There is so much software to still be built!

wtf is up with the site.

More ambitious would be valuing the software we write today more in terms of quality. Not using LLMs to generate more code so that we can do large amounts of largely unjustifiable work.

More ambitious could mean scrapping the lowest common denominator processes that enable bad software like scrum. Like corporate "code review" that is just a rubber stamp because noone cares. Like junior developers who refuse to learn and insist they are always right and force garbage code into the system. Like business people who instead of working with engineering teams engage in sidelong hacks to avoid the process.

The cultural/organizational/process/tooling forces that create bad/mediocre/barely passable (from all perspectives) software are everywhere.

Life sucks on software island. Because WE made it suck and we continue to LET it suck.

Bryan Cantrill: Andreessen’s Folly - The False Dichotomy of Software and Hardware https://www.youtube.com/watch?v=v0JjG0Qfwi8

Perhaps that's too ambitious. But it would be of incredible utility not having to re-make the same things over and over in pepertuity with ever more abstraction layers. So much work on computer is just the constant churn and future shock of libraries adding new features which require updates which break other things. I'm tired of building castles on sand.

```

.reading-container {

  /\* Automatically caps the container at 65 characters on desktop, 

     but scales to 100% minus a 2rem padding buffer on mobile devices \*/

  width: min(65ch, 100% - 2rem);

  margin-inline: auto;

My website is a from scratch arcade room + added some roms to it

every time I see pgrust discussed on a news aggregator, most people dismiss it as vibeslop garbage because almost all of these rewrite projects are slop.

I understand being predisposed to expect a poor quality half arsed effort for projects like this. I don't really have a problem with that. There is a lot of crap out there.

What I find rather offensive is when people declare something to be poor quality and half arsed before they have taken a good look at it.

It's one thing to think something is probably crap so I'm not going to bother even looking. It is something completely different when you think something is probably crap so you tell people that it is crap without checking.

btw I've set up the nightly benchmarks on my ui framework and it's beaten all of the current ones. Because old-era human frameworks can't afford to crunch optimizations non stop 24/7 like ai agents can.

https://github.com/samoylenkodmitry/Cranpose

"funnily enough, I have some faith in some of the projects that people are the most skeptical of, e.g., every time I see pgrust somewhere, there are a lot of skeptical comments. But, without having looked into the details of what he's optimizing, I would trust that they're not doing something shady with their benchmarks because Michael Malis started the project (and is still involved)"

This aged like milk. pgrust was caught cheating on all benchmarks this week.

Many such cases are benign in the sense they in practice are simply the model basically "git clone"-ing the code they need to complete the implementation.

The amount of recall and synthetic data slop makes it imho very hard to actually get the models to really do something more novel (where they fall apart more often)

There is a gulf of difference between someone who doesn’t understand how to program “vibe coding” software and an experienced software developer using ai to write code with heavy direction, review, and best practices.

Today both would be said to be “vibe coded” but we really need to differentiate them. Also, if everything I’m hearing from people is true, it sounds like most corporate code is now completely ai written in the latter way I described. It’s interesting we don’t hear commercial software being called slop yet. Maybe it’s coming.

In any case, ai is far more capable than I realized. Not sure what to make of it.

In the past building something fast, complicated etc required quite a lot of skill and some time. Now you need far lesser skill and lesser time. This just means what you are building is commodified, and has far lesser value that it had before. Take typescript, if it becomes clear that LLMs can speed it up with no regressions and a week or so of prompting, then most likely every company will have their own typescript compiler and no one will use your new one that you built with your 200$ plan.

A lot of tasks are much easier now and also monetarily they’re not worth the 200$ or so tokens of the ChatGPT plan you’re using, because anybody (or at least a number of people) can do it now.

Rather than being more ambitious with AI, you will be far better off finding a unique combination of skills and services that does not compete / AI can’t provide. Only the big labs can be really ambitious with AI.

On looking into this, the accusations of nefarious cheating seem to be false

I think the claim is more that the Ai cheated, not Malis, and that this is evidence of eyes free coding.

I'd still like to see the actual commit history and the community getting to do their own investigation. The squashed mega commits with 1000s of files (400k files in the first commit) does not lend itself to transparency. Transparency is often the best cure to accusations. Not providing transparency upon controversy will be seen as a cover up.

Some of us have been taking this approach for literally years now.

  Is somebody on HN saying you should *always* do X?
    -> Yes
          -> Is somebody on HN saying you should *never* do X?
              -> Yes
                    -> You should _sometimes_ do X.

he's testing thoroughly enough that he's even uncovering real bugs in Postgres, such as this numerical bug that can cause valid SP-GiST operations to fail, this format cache bug that can cause incorrect results from JSONPath, this pgcrypto bug that can cause later operations to fail, multiple memory safety bugs in the dictionary loader2, this money overflow bug, etc.

I'll keep saying it: we're eventually moving to a n-modular redundancy, with several implementations, running on different stacks/languages, cross-checking each others for bugs.

Just re-writing in Rust isn't that useful: we all move to pgrust and then what? People abandon the old software and now pgrust has a major bug and nobody detects it.

And I don't think we're only moving to n-modular redundancy at the software/application level: we'll also be moving to n-modular redundancy at the network level. Where every single packet on the subnetwork (the one where the n systems are living) has to be accounted for and identical.

And any network packet emitted by one of the implementation that won't match the others shall be suspicious and cause for an inquiry.

This shall require changes in how we build and network our stuff, but I do profoundly think that having a "majority voter" with a tiny, minimal, attack surface that's on one end exposed to the Internet and, on the other end, on a specific network (maybe with a new network protocol: or maybe with something based on UDP: not an issue with lost packets btw for it's going to a redundant system anyway) where every single network packet is accounted is going to exist at some point.

I'm dead serious: the value in pgrust is not pgrust in itself. It's that, combined with past a implementation in another language, both are now stronger.

I really hope the clue stick hits us and hits us hard with that one.

It's really challenging to do this, especially creating the AppImages locally so I can test them when the apps do not not work correctly, having to alter the files manually. Yup, I'm not an avid GitHub pusher, just more of a cloner.

I'm having to use multiple free-tier AI agents to help me do this and record the steps and commands I use in markdown files so I don't forget them the next time I try to improve the app.

If I am successful in making these apps work without hosing my system, I'm hopeful that this will become a game changer, for those Noobs that using Ubuntu, or myself at least.

The hardest part is when the AI does not follow my instructions such as requests to generate markdown README.md files with instructions on how to create AppImages, Flatpak, deb files, etc. Have to ask other AIs for help with that while dealing with the frustrating Free-tier cutoff periods :(

I noticed my cloud images had 150mb ram wasted by vendor slop. AI rewrote the functionality into a few mb .

We’ve had slop long before AI . What you produce now is up to you

(See also Hofstadter's law: It always takes longer than you expect, even when you take into account Hofstadter's law.)

And these ideas were always plenty of. The problem for me is that the incentives, so to speak, is to wow people with the Old World software but with “see, no brain”. And in turn you get two-hundred projects like that for every piece about rethinking software. And those pieces might just be at the zygote idea level. Could it be done? Yeah maybe.

But the biggest problem is that this is not what GenAI or agentic AI is for. I don’t think it’s even debatable, even if you think the AI Cretins that a few years ago said that they will take everyone’s jobs out in public just changed their minds. Because the valuations and capital invested is to the point that they have to, really, make it possible to slash entire payrolls across sectors. If not they simply don’t get enough money back and the whole thing crashes.[1] And if you need these frontier models at subsidized electricity costs and not just the ones that can run on your desktop, either there is crash and no more frontier models or you are out of a job.

And then where are the people that care so much about software?

They are no where to be seen. All that are left are business people. To see business people software just open up any program from Established Tech, or any program from non-Tech but where they want to sell you something. There is apparently (let’s use revealed preference here) no business need to software that is good, stable, conforms to anything, or is nice to use. Because that cares so much about software person might want to make legible the prices on offer, the exact specifications, discovery—all things that business people want to frustrate in order to maintain information asymmetry.[2]

As for compilers and interpreters and such. Okay, for who? Sure. Some people believe that they are in the 999‰ of developers. And now AI can finally vanquish those mediocre developers and productivity-boost 999‰ developers so that they get to sit at the right-hand side of the other worthy and hard-working cohort, uh, the people who had money and dumped it into AI. And they might even double their pay because thinking and making connections at that level would just boil all the lakes if they tried to build an AI to do that. And what will they do with that power? Hmm, follow orders and keep making business software? Just looking at history here.

[1] Cory Doctorow, The Reverse Centaur’s Guide to Life After AI

[2] ibid

And may be we should have been more ambitious with hardware too, and have a mobile and VR platforms that is not tied to malicious corporations...