We should be more ambitious with the software we build
j / k
|
Down or up a comment |
h / l
|
Previous or next link |
?
|
This help |
> 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
Claude in its current Opus 5.5 form has made some wild reaches in response to reasonable-seeming prompts. For instance: "this error is getting swallowed, make sure the real termination message exposes the root cause" -> discovering that the issue is actually in a third party library that isn't exposing the original error except so through logs, so doing some hackery to inject a log-capturer that gets the stdout, buffers it, and looks for the message in order to re-throw based on that...
And it can demonstrate that working, but it's added some fragile and/or unintended consequences like (a) string matching on a particular WARN log message of a particular version of the lib, and (b) buffering those logs such that there were now cases where they would never make it to the actual output stream before the program terminating.
It's certainly capable of being used smarter than that, but it's also really easy to end up with messy fragile stuff if you get lazy about reviewing the output.
Without judgement, I think this illustrates a fundamental objection the anti-AI crowd raises.
The example prompt requires no understanding of what's happening, before suggesting action. Where I work, process requires that a PR review for a solution, has to have a corresponding explanation of why, or it's marked needs work
I think there's some nuance here though between "fully anti-AI" and "be careful with that power saw."
That example I mentioned didn't make it to production. It got noticed and fixed more properly by the person who submitted the first prompt before it even went to PR.
But a lot of times things in that same vein can be solved sufficiently with a "dumb" prompt like that, so a one-line prompt to get a PR drafted in the background for the dumb stuff can be a pretty good time saver.
The art is not skimping on your attention to the bigger or more important stuff so much that all the time you save on first getting code written is lost by cleaning up stuff like that...
In python, in a co-worker's code, it seems to significantly prefer "some_dict.get('key')" over "some_dict['key']". For the non-python-users, the first one will return None (equivalent to null) when the key is missing, while the second raises a KeyError. It was being used in a whole bunch of places that would cause problems (bad data instead of errors) if it did receive None. Some of these keys were actually optional and it does makes sense for those, but it looks like whichever model he was using just repeated the pattern everywhere instead of just where it was appropriate.
Sometimes you do want some flow to terminate if a schema / data contract is breached, and not have this broken data contract propagate elsewhere / outwards.
And/or, it is a perfectly valid pattern to indeed add try..catch, and contain (hence "localize") the issue there and then. If there is a way to handle this breach - you will need some kind of if check anyway. Catching by matching against the particular KeyError exception is in fact robust - and if you forgot to add an intended catch, then the exception will propagate upstack, yes - which is what you want - and this way you do not need to worry about forgetting an "if None" check.
This sort of approach makes it structurally impossible to "forget" - if exception is not caught, it will abort the cannot-be-null breach continuing with program flow, possibly (e.g.) ending up persisted in some place it shouldn't be, causing problems later.
Use a defaultdict if you must have all keys optional. Using get() everywhere is buggy because it masks illegal key use.
Double lookup.
Cheaper than get() masking bugs in your code or dict generation.
But yes let's prematurely optimise for speed in a slow-by-default language by writing bug prone non-idiomatic code. OK.
Both have valid use cases. It's weird to be sarcastic about it.
You could use a data structure that better articulates an optional field, like a dataclass with type hints or a pydantic model. Then you, your coworker, and the agent alike, aren’t guessing at whether the key’s value is optional.
Another example in this vein is having many optional parameters on a function or api route, that drive behavior deeply nested in the application logic. Or maybe they were there for testing and never deleted. No one comes across this code next and understands it easily. How could you expect a LLM to understand it, either?
I find it funny when people blame the LLM for dog shit code, but at the same time have a pollock painting of code they load into its context, and are like “put a person in the horse and carriage!” And the LLM is like “bro I just see dots and squiggles but you asked so boom!”
Opus's first proposal for a fix was to spawn multiple Python processes and build a load balancer between them in Python. At first I asked it why it wasn't using haproxy and it said that haproxy would be an added dependency and that the overhead for this kind of thing in Python would be negligible. I knew this was idiotic but wanted to test this out, so had Opus run two experiments in parallel. Sure enough an haproxy load balancer was much, much better on HTTP load balancing than Python code was.
This is the kind of thing that if you're unfamiliar with how networking code works, the models can autopilot into bad decisions that are verifiably correct (higher throughput than the original CPU-bottlenecked implementation) but much short of best practice.
The advantage is that you don't have issues like the GIL or whatever, so there's no need for all the complexity of load balancing between multiple pythons.
I'm not doing CPU inferencing but I'm doing some tokenization in Python which is CPU-bound. In all honesty I started on this project to scale the model and did not build it myself so have been trying to read code and walk back the approach. I've been thinking about rewriting the Python glue in Go to avoid issues with the GIL.
I suspect it's far more about workflow and developer attitude. Messy code stays because you don't object to it staying; overfitting happens in code because it happens in prompts.
Be careful to not frame this as a feature of AI and not a feature of the approach people have taken that you have observed, it doesnt have to be this way.
Is it? And that's no shade to the OPs project, it looks awesome.
But, frankly, it blows my mind that anyone with a passing interest in software hasn't seen AI as an incredible capability enhancer. How are they not doing everything they ever wanted?
So many people just sit around and complain about it. It's impossible for me to wrap my head around.
AI is quite literally the opposite of creativity. By definition. It's a pattern matcher and generates the most likely correct output based on the input. That's why it's incredibly useful at creating random tools and being a capability enhancer/output multiplier. But if you are having a dialogue with me, I don't want to hear what some AI has to say, since that's not 'you'.
This is why generative AI will never replace the creative types, as the inherit value of the product is in the artists' intent in making a piece and their unique execution of it. If at any part of the process AI was used (including if they were to e.g. use AI to fact check their anatomy, or for concepts) then they've tainted their work - it's no longer an output of themselves, it's got elements that have been genericized to what an AI considers correct / perfect.
Is there some kind of metaphysical tainting that takes place based on what happens inside of the "Hire-a-Drummer" black-box?
If I found out afterwards that your album's songs each had a single long recording of a drum track that you didn't make or refine at all, i'd be upset, because I thought the album was your creative output and that you carefully chose how it was constructed.
If you tell me upfront "the drums are a placeholder while I work on how to do them" then I can still enjoy the rest of the album, whether that part of the track is AI or not. But if you instead were to go in and take the time to carefully craft the drum track for the album, I don't care if AI was used to make the actual waveforms of the drum beats.
I think the problem is that, the more AI is used as a way to take shortcuts in your work, the less I can attribute to you, and the more it's just "correct" and thus generic. If you use AI as a tool to enable you to do creative work, then I think it's fine, I just want to know what I should judge as being 'you'.
Similar thing: Epic: The Musical is a concept album made in Logic Pro X. None of the instruments actually played or were recorded (at least by Jorge). But I enjoy the album on the basis of how Jorge's mind arranged the instruments, how the songs are written, the humans singing it and the emotions they put into their performance, etc. I don't think anyone thinks Jorge hired an orchestra nor sat there and played all those instruments himself.
So, when someone says that they like the trumpet in some part of a song in Epic, they're actually saying that they enjoy (A) the trumpet is there at that specific moment, and (B) and what decisions Jorge made for it - like its length, any effects added to create its sound profile, etc. This person probably subconsciously knows that Jorge did not actually blow into a trumpet to make that part of the song.
Is the issue, "hey, it might be AI, therefore on a metaphysical level I do not enjoy this as much as if I knew for certain that the drums were recorded by a real drummer"?
Or separately and without the complication of "Hire-a-Drummer", what about failing to disclose that drum tracks were hand-sequenced on a drum machine?
Or separately, is the issue that the drums were outsourced in the first place?
That is to say, if a human drummer is hired and the only instruction is to "add some dope beats to this track" and the drum tracks are used thereafter without any further refinement, does/should this affect the listener's perception?
This is what comes to mind reading this thread.
The poster above is complaining that the actual outputs are qualitatively "not creative". That they embody a statistical norm, while creative work has more unique variance.
These two viewpoints cannot be bridged by a flourish that ignores the fundamental difference of opinion...
Even if AI were entirely incapable of creativity, why would incorporating its output diminish the creativity of the human artist?
What about stock samples, preset drum-machine patterns, or clichéd drum parts played by a human drummer? Do these diminish the artist's creativity, and if so, why?
If you wouldn't mind reviewing https://news.ycombinator.com/newsguidelines.html and taking the intended spirit of the site more to heart, we'd be grateful.
So the inputs to "Hire-a-Drummer" are always the same. Sometimes the mechanism is an actual drummer, sometimes it is a programmed drum machine, and sometimes it is AI generated. It's impossible to tell from the outputs what the mechanism was.
Does the mere use of "Hire-a-Drummer", even assuming that the drum tracks were recorded by an actual drummer, diminish my creativity in the final songs on the album? Is it neglectful to outsource drumming in the first place?
If you played a lot of parts yourself and put your effort into them, why drag those AI drums in? That's like sculpting 90% of a sculpture with your hands and then generating the remaining 10% and 3d printing them in. For what sake?
Answering your question, it diminishes nothing except your own honesty with yourself and your listeners. If you're fine with that, well, you do you.
The morality of AI is another discussion entirely.
Or are you suggesting there's a spectrum here? Is the overall creativity of the album greater with a human drummer than with drum samples, a drum machine, or AI-generated drums?
https://news.ycombinator.com/newsguidelines.html
It's pure vibes, so buyer beware https://github.com/adriel/siri-remote-control This is "my" first Mac app, before this I'd only built PHP or web based apps. Pretty surprising how quick Claude could make it. I always thought Mac apps were really hard to build.
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!
I agree with the sibling comment: the difficulty [now, but also before] is finishing.
the difficulty now is finishing.
However you can set up loops where the AI do improving by themselves and you just have to steer
Sigh. It was always like this.
Typechecking with my own algorithm. Simple enough to specify in Python. Annoying with much boilerplate in CUDA. Similarly annoying to test.
I'm currently experimenting with some custom hardware + software, composed in a way that seems novel, for a niche domain. This is with a new kid coming soon. There's just no way I would have crossed the activation threshold to do that without having LLMs provide assistance.
Can you give some examples where people have done that?
If somebody's passion is faster command line tools, let them make a faster ripgrep. First results may be disappointing, but those who don't give up will figure out how to do it right.
Or just look around for people who are doing this and then tell the LLM "faster <thing that the other guy did>"
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.
It's pretty bad inside the bubble too.
.0001% of that software had formal verification, bitwise memory management, 100% test coverage, clean documentation and specifications, a clear roadmap, long term sustainability plan and sustainable economics
Technology is like a good meal: only possible for a moment and only a moment.
too early and it’s inedible too late and it’s spoiled.
User testing is part of test coverage
At least that is true for my software coding processes; I always found getting the actual coders talking directly to the actual users — not the managers talking to the managers — vastly improved the software delivered along all three axes of schedule, budget, and quality, and dramatically reduced test/redo cycles. Just having the coders in direct contact, they hear about the real used cases, edge cases, and frustrations, and so can make good judgements about many decisions, rather than blind judgements.
I don’t believe in 100% test coverage. Especially outside some very specific cases, it just adds a lot of code with little to no value.
Writing a good test or good set of tests does take effort but enforcing 100% coverage often pushes some folks to just run the code in any way possible within the test subsystem.
Nicely put. A very verbose type system that is also placed too far away from the definitions indeed
If I have a function add_nums that takes 2 numbers and adds them, there are like infinite inputs that can be tested.
If I have a function shape_color that can take circle, triangle, square for the shapes and red, blue, for the colors, then there are 6 different states. But what if my function just returns if it is a circle or triangle. It only cares about 2 different color paths when it is a square. Do I test all 6 states or do I test only the 3 code paths?
I think code coverage like many things is a “it depends”.
That's what formal verification is for: you generate math statements from the code, and then prove them.
Testing is for covering the most common scenarios and likely edge cases. 100% coverage means every line of code in the app is executed when your test suite runs. It is useful as a bare minimum, but by itself does not guarantee that there are no bugs.
if you are confident that the complexity of what you have built can be fully tracked in your head then either you are some sort of God or you’re not used to building complicated enough things with critical failures attached to them
Perhaps this is a sign that this function isn't necessary.
Unit tests aren't for verifying functions.
Neither do governments, incidentally. They're okay-ish at skyscrapers and bridges, but software is just beyond them.
They may treat changing a timeout value like changing a capacitor with one of a different value on a PCB. Doing it is slow and expensive, involving suppliers, delays, testing campaigns, etc... So that's the kind of thing that is specified up front, to avoid having to touch anything in production. If a change is needed, it will go in V2, months later at best.
It has some advantages, such as not breaking things that work, but they are also not fixing things that don't.
It's not about being dumb, I think it comes from the mental model where big electrical appliances/machines are controlled by big slow relays and switches. Changes to the state of operation involve inertia and momentum and huge power spikes and fuses that make extremely loud noises when they blow.
Even if its closed on their end, having standards is the key.
Good standards are often (all of the time?) ignored by bad developers.
A good standard lets the bad users grow into better users. It's like the gap between novice vs pro graphics software. It's a novice trap. The novice software is so limited and "easy" that when a user needs a "pro" feature they have to jump off a cliff to learn a new universe--all at once. The "easy" novice software is good at keeping you there at that level. It often does nothing to prepare you for graduating to the next level. The gap is so wide that it hardly matters if you started off using the "beginner" software. Inaccessible pro software combined with beginner software that avoids teaching... it's just never going to be a pipeline.
Good developers are a rare resource yet we push back on efforts to improve mining them with gatekeeping. Part of the reason you are the "good" developer you are today is because there are so many tools that let you do bad things which became lessons.
If you want your blessed standards to change bad developers then you have to build in footholds for them. I think if you look at the poorly adopted "good" standards you'll find that there's a strong correlation with poor accessibility. Are you going to turn all the bad developers into good ones? No, but you might be able to elevate a chunk them to less annoying mediocre developers and I think that's worth it.
Is it really surprising that bad developers ignore good standards which ignored them? Good standards nudge rather than trap.
This subject is way off topic but let me try and bring it back in (a wee little bit). Yeah, I'm gonna coddle the common folk some more... We hate the vibe coding from the riffraff but we went out of our way to not vibe with them! I look at the vibe coding as desperate feature requests. If we want them to come to us "good" coders instead of the AI... maybe we need to meet them where the AI did. Maybe just a little? Is it taking our job away if we weren't doing that job to begin with?
The toasters be uncovering stuff and it's time to get creative... because we're the ones that are good at creative, right? TYFCTMTT.
I've always taken it that I don't really care if someone uses a closed email client, ive already sent them data, out of my control.
Yet if you want to use IM or such, people will only talk to people with OS clients as that is all their contact is able to use on that network. Leading "all or nothing"-ness.
And to add, federation is the cherry on top.
Despite the fact that fundamentally vibe coding is enabled by good interface specification and design specs by engineers
For example, Beyond All Reason recently added code format linting errors and static code analysis just to help alleviate the load on the small group of people doing code reviews. The project had been getting along without it, but with well-meaning-but-vibe-coded PRs being proposed at an incredible rate... There was value to be found in automated (non-llm-based) code review.
https://github.com/beyond-all-reason/Beyond-All-Reason/tree/...
I'm guessing they made "happy path" decisions thinking most people aren't going to modify cycle timing, or know how to do that or what it entails. That 3 minutes was probably decided on by a group of engineers who thoroughly know the product. Especially if they provide a warranty.
You may know / understand a heat pump system but if I modified values with no safeguards on mine I'd probably break it within the hour.
Now we just have to get them to expose interfaces so that we can write the software for the interfaces that we want.
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
I do however wonder about specific research priority/project from labs' solving their own problems leaking into my chats. I noticed one month that Claude really started harping on about "legibility" and suggesting Seeing Like A State to me, and saw it like any other interesting suggestion/insight.
Now I see a lot of people mentioning "legibility" and think that was just some weird attractor state or useful vocabulary term for being an LLM (that literally can't see certain things or be observed easily!). It's a weird feeling, because nobody tried to trick me and in fact it objectively helped me to acquire useful information. I just have to wonder if other people are having the same conversation and there's really nothing special about it - maybe Anthropic just really liked that book right around when they were doing a lot of RL
Not only that, was the intent just to give Claude the vocabulary to be an LLM in a company that wants it to be legible, and apply that book to managing it, and we're either intentionally or unintentionally memetically downstream of that? Or was it just extra likely to be mentioned because it's a genuinely helpful book - either because the AI learned over time that it was (very good!), someone just wanted to recommend it to more people to help them (~good). I worry that the "intelligent conversation" or "wow look at the agent go" can give us very poor epistemics
This is, as you say, exactly the paradox of having ourselves assisted by LLMs. We are no different from our cats. Except imagine the cats start making the laser lights for themselves.
[1] https://xkcd.com/356/
- 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.
Publishing screenshots and the README on GitHub but not the code is sneaky at best, deceiving at worst.
I have now uploaded the entire codebase to the repo! Neither sneaky nor deceiving, just plain old stupidity, I'm afraid.
It is owned/run by Microsoft. The mission is the big tech mission: usage of any kind regardless of the impact on anything else, and profit.
I took it to 39% complete, as a language, over 8-weeks. Then, I spent just 50 minutes describing all the missing parts and it finished the language in 1-shot. I didn’t think it would work. It did.
I used Opus 5.5 on a $20 plan and I didn’t even hit my limits.
But we've also spend a lot of effort over the past year and a half to make the codebase and tooling more approachable to LLMs so they know how we like to do things and follow our standards.
Anything more you can say about this? We desperately need to restructure and standardize our codebase right now.
To get a toy version that can run most things takes under 2 hrs. Half of that time is collecting the tests you want to pass, how it should evaluate the code, what your criteria are, etc.
Reinforcement learning doesn’t work by training an LLM on a series of inputs like ‘rewrite python in befunge’ paired with a prepared model implementation. It doesn’t matter if an open source implementation was in the dataset that trained the language model. All it got from that was an appreciation for syntax and language idiom; when it is generating code it’s doing so according to the approaches and patterns that it’s been reinforced into following in the context of a coding prompt - regurgitating existing codebases is undesirable so it is a behavior it will have been reinforced against.
I see it this way in layman sense:
- you feed the model with data;
- you run the query;
- you activate a network and it gives you most probable token, refeeds it back and generates next and so on;
- nobody knows exactly why and how this next token comes and can tell strictly which input data gives which output data without running the exact query with 0 temperature.
So yes, it's not an exact copy, but you also can't say that a particular repo is not reflected anyhow. And I mean that the weights are reflected by the particular logic, not a syntax.
Otherwise why all the hassle if we can just feed the language reference doc to 100mb model and it should be able to produce everything just fine if only the syntax connections are needed and everything else is freshly derivated and not based on the actual implementations.
‘It’s in the dataset’ sort of implies ‘the model is just reproducing output it was trained on’.
In this case you’re saying ‘the model is repeating tasks it was trained to do’
That’s the difference between accusing someone of just regurgitating something they read, vs praising them for having prepared well for an exam.
Sounds like it's you who is behind the times. With things like REA we know that LLMs can reverse engineer the behaviour of binaries and basically treat them as a form of specification to rebuild an application.
This means that old python interpreter acts like a specification for what kind of features must be included inside the project.
LLMs are amazing at input to output transformations and that hasn't changed at all.
I think it's you who has to update his mental model away from "stochastic parrot era" accusations.
PS: if you're trying to accuse me of being a "stochastic parroter", that's exactly what I mean.
Taking an input and transforming it to an output is the exact opposite of repeating something.
https://app.preview.craftspec.com/app/city/
This whole thing is just a proof of concept, and needs a mouse to interact with.
It’s incredible what AI has made possible with experimental projects that would require months of coding.
Icon it created is same purple as yours :) Background color of the page? Yup, same. Map of a codebase? Yup, there, although very different take on it. I added a 3d walking simulator within - is cool for a minute but useless later.
https://github.com/bishonen/public/tree/main/images/code-atl...
Main use case is understanding a personal life operating system with 300k LOC a bit more. It has todo's, habits, calendars (google), trips and more baked in, with the quality (UI wise) of paid SaaS (if I say so myself). While I tried reviewing the code at the beginning, I now ask for features which would normally take me days/weeks and they're done in a few minutes by claude.
Same, and I have found some of the failure modes in the realm of eyes free coding and limited auditing. I often see it more as pushing the process than the model, as I tend to bounce around models for the benefits diversity provides.
Have you also found there is a point where they hit code complexity and start churning without progress? (at which point you have to step in to help the bot step back and think big picture, which usually takes a few sessions)
I was motivated to make the codebase visualizer linked above to help me understand how the various pieces of the system that is being vibe coded connect with each other.
Now I'm thinking about how I can build something similar for agents. How can we teach "systems thinking" to a model?
I've been mostly working on very large modeling projects (think detailed architeture over 1000 acres) or animation because this really was the "new" capability area that Opus 5.5 "unlocked".
I have been surprised how well it has worked at scale with many sub-agents. However the code base is limited to the rendering engine mostly.
Certainly in the older models they hit a complexity limit, but I haven't really hit it with Opus 5.5. I have had it make data flow designs that I didn't like because they were more complicated than it should have been or the perenial problem of trying to make everything backwards compatible when working on greenfield refactors, but I haven't seen it choke on a code base yet.
To my experience, it's a simple complexity curve where the first bits go fast and the speed goes down very fast once you reach a certain level of complexity. Size doesn't matter as much as complexity: with the right foundations, it keeps zooming through it. Now I do wonder how much my inexperience in the complicated project is a brake on progress vs. it just being a hard to tackle problem.
On the other hand, I have a TS only project core is sub-20k LoC (NES harness), where it is struggling (for now, see other comments)
It helps us keep track of things, why not AI, too?
I've been working on process more than model. Similar to having a PR review team, you need multiple teams or processes that run over the code, markdown, assumptions. I still don't think this is enough.
I'm working on an NES harness, and the agent was churning with detecting certain state changes like dialogs, menu navigation, screen change. The bot and I got churning and I put it down for a while. A few days later it occured to me to ask the bot "Does the emulator and game state change with frames? Can we just get the state each frame rather than trying to be clever about it?"
It said yes, but added some nonsense about being performance hindered... (flash model). I haven't worked on it again yet, but my intention was to next have it build a small recorder based on this so it can get frame accurate game state change.
This is just a long way of saying, sometimes you have to step back and help them help themselves. They have a really hard time with recognizing ambiguity or how to determine lack of context that could be filled.
https://blueblazin.github.io/blockviz/
I tried it on some of my code and it's pretty neat, though not fully intuitive to follow more complex code structures for me.
There's so many youtube channels getting hundreds of thousands of views on EVERY new major model release just doing essentially zero effort one-shots, and people lap it up as if building things that already exist is somehow the best their imagination allows for.
I do love being able to test a model for 3+ weeks (>1 month is too long personally for my budget) and actually learning how to build scalable software and actually develop your "engineering" skills.
[0] https://jsfiddle.net/3yLrsem0/
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)
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.
I like to think of the evolution of Factorio. It's been 15 years with the same core team playing their own game in a LAN party every week, as well as individually. And it's high quality.
Dogfooding led them to counter-intuitive decisions like, if a flying robot runs out of battery, it should obviously crash into the ground and explode, but it turned out way better for gameplay if it just limps slowly to the nearest charging point instead. This fact and many more can only be discerned from actual gameplay experience. No amount of pure linguistic reasoning will tell you them. Another one is how the burner inserters (coal-powered robot arms) fuel themselves - in the first version, they didn't. They could have made running around to refuel your robot arms a part of the game, but that isn't where they discovered the statue within the marble. You had to try the game both ways and see what feels more fun. A third: filter inserters and smart inserters were removed, and their features were moved to all inserters. A fourth: trains originally ran on strict time-based timetables, but it was frustrating so they were made able to move based on logistics needs instead. A fifth: basic oil processing used to produce all three oil products, and now it doesn't. A sixth: the basic oil refinery has its liquid I/O ports set up in a way that's compatible with switching to advanced oil refining later, instead of requiring you to redo your pipes.
All these little things you get from actually using the software and streamlining it, those are the quality. The list above obviously doesn't translate directly to any other project, but something like Microsoft has its own list, probably starting with things like common controls, dialog tabbing, and drag'n'drop. Did you know the reason you click "Start" to shut down in Win95 is because they did actual user testing and that's where the users looked first?
... and politics! To me LLMs are just another piece of evidence that it was never the lack of resources that made Microsoft produce bad user experiences.
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
The purpose of software is to help people with their problems. I think it's easy to tell ourselves that other people want to use our tools which we really made to help ourselves (especially if them using it also helps ourselves even more!). And also, this is all so new and there are real opportunities that it is good to learn and try new things and be open to actually making something valuable.
But! Other people extensively using agents are literally the last people who would pay for a project like this! And unless it's a fulltime job like it is for a 5 or so well resourced tech companies, it's hard to make something as good and useful as them. I say this as someone who spent a long time on this problem as my fulltime job.
We should still have fun with our work. But literally, "software for other software people, that solves the problem of us needing to write more software for writing software, faster", who is that helping? There are no constraints or end users besides ourselves, and half of that is not so much it benefiting us through productivity, but learning new things and play - again, important. But there's a reason so many people are doing this and I think it's because they don't have to go outside and solve someone else's problem, or do something unusual, or involving unfun non-software aspects - agents are fun! But how many random people's agent have you installed?
IMO: if the technology does not help a non-technology person live a better life, and especially if it involves "using an agent to build a framework for agents" we should do some more, deeper introspection about what problem we are actually solving and whether or not we're being ambitious. And I say that not to pick on you but myself.
It's not a new problem in software, and it's not unique to software.
A lot of hobby woodworkers, for instance, spend most of their woodworking effort on their new woodshop. Building a workbench, building shelves and cabinets and special holders for all their drill bits, mortising chisels and tools, special tables for their miter saw, a special cabinet connected to their dust collection system for sanding small pieces...
Likewise, the favorite project for programmers is ... programming tools. New languages, new libraries, new editors. We've gone through like six version control systems at my day job.
There is some merit in this, since new tools make you more efficient at building more new tools, but eventually you have to step back and remind yourself what your actual goals are.
I call it the tool maker's dilemma, but that's not nearly as catchy or easy to fit into conversation as bikeshedding.
The end result of it all does eventually touch people, though.
For the end user, the outcome will likely be the same when compared to opencode or similar, but the journey will be nicer
I expect no one to actually use it though, however nice it might be to hope for that
What I fear is that as computer people we can easily convince ourselves to avoid doing things in-person or which involve leaving the comfort of our inner/online lives, or having to bridge technology with some other thing that is very much not technology (like non technical people, or sales and marketing), or is but is not easy to work with (like a robot). But there are actually a ton of problems that need solving there, and they are uncomfortable because it might involve looking stupid or showing up somewhere nobody knows you, or unknown-unknowns.
Personally I am embarrassed at myself not for trying to solve my own problems (I want to spend all day doing tech stuff and make money selling it to other people doing tech stuff) but for how long it took me to realize that I was either anxious or thought I was above doing something more concrete and mundane.
For example, this is a popular music venue in the city I live in https://www.thegreatnorthernsf.com/ - Claude and Codex have been out for months; it would take like 20 minutes to give their site a makeover, mostly just watching AI work.
This is how local government events are coordinate in the most technologically forward city in the world. Double irony that the product is provided by one of the biggest tech companies in the city, too. But it's literally just a web form and some poor government worker is apologizing in the event details that the signups are broken: https://sfrpd.my.salesforce-sites.com/SFRPDJob?sShiftId=a09P...
I think agents are very fun and cool but I'm increasingly convinced that my job is to use them to help this type of user, not developers.
We should build everything using a AAA FPS engine loop now that we can. The amount of shit that happens in one rendered frame of overwatch is wild. And then we go and do like 200 of those per second.
You actually would have been better off replacing your SVG animation with a game loop! Assuming you're using Lottie you can easily swap it to render into a `<canvas>` which doesn't have any of that overhead and uses `requestAnimationFrame` which automatically gets throttled in inactive tabs.
You can try rendering a 2D rectangle as 2 quads in whatever GPU API you like the most, then try pushing the same amount of pixels to a CPU buffer via the widest CPU memory write instructions you can have (and then wait the GPU-accelerated compositor upload them to the GPU anyways to present them...).
I can tell you for a fact one will be 2 orders of magnitude faster, want to make bet which one?
Using a GPU api does not imply you have to render at the screen's refresh rate, or even that you have to update the entire window.
There's a reason why browsers are so complicated and equally non performant. 2D rendering, even GPU accelerated, with the constraints we have right now (or rather, the lack of constraints, because 3D rendering is basically tradeoffs all the time), is not going to be more performant.
They are. They're not particularly more performant that what we do today. It all involves tesselation on the CPU, or dropping entire feature sets.
>But in general handling vector graphics is simply overkill.
You don't get to decide that.
>Rounded corners? We don't those! Let's use a paradigm that's more GPU friendly.
That ship has sailed. The text input I'm typing this comment in has slightly rounded corners. The text it's containing is vector graphics with rounded corners everywhere, where the best renderer solution at the moment is Slug, with SDFs being a distant second.
>Text can all be cached.
sure, if you drop ligatures, only care about latin alphabet languages, accept having to rerender everything the moment I zoom the page to 110% or 125%
dont you have to do that anyway if you want text to stay crisp?
Text glyphs/UI images are all in 1 atlas, you can render the entire UI as 1 draw call and only re-render when something changes. I haven't checked if Claude chose to re-render the whole screen or just part of it, you can design it either way.
Layout can be as simple or as complex as you want it to be - this example does both flex and grid-style layuts, flex supports start/end/center/stretch on both main/cross axes, as well as a flex prop.
For the API you can either go immediate mode or retained - this one is retained since explaining to Claude how to do the IM version properly would take longer than doing it myself, but the layout algorithm can be the same regardless of which route you go for the user-level API.
You only need scrolling/overflow on top of that and this is enough for the majority of widgets you may need.
My point is none of this stuff is hard. This is 700 lines of Claude code, if you write it yourself it would be 400, and will have better performance characteristics than most UI libraries out there.
Edit: Added scrolling too, there's a 100K scrollable virtual list in the demo. Again - this stuff is not hard.
It might be helpful to add your comment to the GitHub repository so people can find it in the future.
rxi's MicroUI is a similar (but human-written) project whose interface is immediate-mode; it supports overlapping windows, which is trivial in retained mode (now that we have CPU to spare) but a little bit tricky in immediate mode. https://github.com/rxi/microui is about 1500 lines of C.
I'm especially impressed with your perseverance in the face of such low-quality commentary.
* Your font rendering is catastrophically bad, because it doesn't take DPI into account. It's a blurry, low quality mess.
* You don't handle taps, because you made it with a PC without considering other users. I can therefore not tap on anything. Is it all mobile devices? Is it just Firefox? Is it just that device? Surely that's an easy problem to solve, it and doesn't involve dozens of interop hacks! Scrolling that main page does work though, thankfully the horrible bad UI toolkit does the job for you.
* Layout: congrats, you've remade Clay. It's mostly a solved problem for the past twenty years, although modern layout needs like "rescaling your UI because your users aren't in 1920x1080" seem to be unneeded. Flex and grid layout have plenty of open source implementations, I'm sure Claude can copy it.
* Your text is not selectable or copyable, but I'm going to be graceful and say that maybe it's because it doesn't handle taps either and that it definitely works on desktop. Right?
* People that have accessibility needs seemingly can go fuck themselves, since your entire website is just a canvas. How hard could it be to integrate with the DOM for ARIA elements anyways? (Trick question, it's impossible.). And when that's done, you get to redo it for AccessibilityKit on Apple platforms, UIA on Windows, AAF on Android, AT-SPI on Linux... Don't worry, they're all very similar APIs, how hard could it be to have one model that integrates with them all? (Watch out, trick question again. Especially if you intend to do it _well_).
* I haven't tested it (remember, doesn't work on a mobile device?), but you do restore text input, in the way that is expected by platforms, right? Android has lifecycle events like PAUSE and STOP, as well as activity recreation like it just did upon going to low battery mode as I was typing. Firefox restored this very long comment. You would do the same, right? It is the responsibility of an UI framework: two way binding of inputs is a recipe for UI nightmares.
It took me longer to type this than to collect all of these issues. That was from just the first 30 seconds of interacting with your toy.
Maybe, just maybe, some people are smarter than you, and have spent more time working on the subject than you, and you should be ever so slightly more humble. That the complexity and the performance of current UI toolkits is not an accident that needs to be fixed by geniuses like you gracing us with your previously undiscovered research. Or keep jerking yourself off, unilaterally declaring that people don't need shadows, transparency, or other very niche features like animations, and ignore the world around you, I'm not your dad.
https://www.nicbarker.com/clay does everything you're doing, except better, and it's _still_ not good enough.
In the midst of your ad hominem, your argument seems to have changed from "don't use a GPU API" to "making a production grade UI library is hard", which I'm more than happy to give you.
It's now been three times you ignore the reality of the world, loudly proclaim yourself winner then proceed to drop 90% of what is necessary. No shit, you can draw empty boxes in 2ms and badly shape text in 3.
>I would love to hear how handling taps, adding a mobile-friendly layout to the demo, handling selection or accessibility would change the calculus on that.
Because now for half of these, you are involving the CPU again, with endless back and forths. Keep repeating it until you have something that works and congratulations, you have more or less exactly what browsers do today.
Considering the hubris, the loud proclamations that you're right and that the whole world around you is wrong, the complete ignorance of the state of the art and the insistence on badly reimplementing things from scratch, the "you don't need those features actually", let me guess, game engine developer?
This never stopped the Electron devs until now, I honestly can't see why they'd start to get any better now that the slop machine lets them be even lazier.
you're not "in the terminal", in fact the product is selling you on the concept of being "in the terminal" as you work, but you're literally just asking a computer with ~full userspace access and direct ability to compile and run programs to do stuff for you, in an environment with "plugins" and like 30 "slash commands" and menus. it has auto-review and manages git for you and even writes your PR descriptions and other messages to your colleagues if you want. that is an integrated development environment.
I think if you can just run a one line bash command from a big company's website, and then just ask it to set up git and everything else for you (which it will default to anyway), and it tries to sell you on third party plugs in and Skills and managed proxies like MCP, and workflows, you are just using the new kind of IDE. And there is nothing bad about that because it makes us more productive to not have to mess with things like that. The idea that you are not using an IDE, or that we are "better" because the IDE looks like the development environment of the type of developer we'd admired in the post (but literally has the value proposition of being the easy way to accomplish that), is dangerous.
We are gonna see some Knight Capital level fuckups shortly.
"Render what I was thinking"
I just double check to make sure it aligns
They're not going to bother checking. It simply isn't going to be possible for humans to review code in the future where all code is being written by machines, and not having all code be written by machines is not an option.
Hell in the future LLMs probably won't even work with "code" at all, just bytecode directly, using some format created by and optimized for LLMs. Why even bother with text when no human will ever lay eyes on it?
>We are gonna see some Knight Capital level fuckups shortly.
Yes, but humans fuck up too so it doesn't matter. Future go brrr.
I'm pretty sure many folks put up with the bloat of IDEs just for the functionality they offered. Now, they're hopping back to emacs, vim, sublime, whatever their heart desires.
[1] https://github.com/akiselev/svelters
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.
There's a less hopeful outcome, where no skill is needed at all, because every conceivable thing is one-shot-able from a SOTA model. But then, at that point, you're saying something pretty profound about computer science (roughly: that there was no meaningfully more sophisticated and complex place to go from where we are today).
The most recent new things that LLMs have unlocked (regarding software dev) for us is reverse engineering and combining old games, unearthing decade old vulnerabilities, and helping root and debloat consumer hardware. Which are all cool and useful, but none of it being a “next great thing”.
Perhaps LLMs are really doing is highlighting how the software industry was already nearing its economic maturity and this just shifted the timeline from 2040 back to 2027-2030.
1. well specified
2. well tested (which is a form of spec)
3. represented in the training set (i.e. not built on a corpus of human developed examples)
For example, a lot of the compiler porting efforts fall into all 3 buckets: compilers are well specified (there is a set of valid inputs and an expected behavior), they are typically well tested, and as a bonus, in a way that is implementation agnostic thanks to the clean interface (think: integration vs unit tests), and are very well represented in the training set.
There remain some nitty details related to tracking randomness and choosing what interfaces to log. But even having your code testable by replicas would help organize it better and expose different assumptions made by the language or library stack.
When you get different outputs from replicas it can be 1. one of them has a bug, or 2. the spec is unclear -> fix the bug or the spec. So this method catches both sides. It also might be faster than traditional code based testing, you can build replicas in parallel. A replica is an open ended test, unlike coded tests it can be tried on open ended input values.
The core idea is that it is easier to implement twice than to imagine bugs. We already solved implementation, but bug finding means running code in your head, it touches the halting problem issues - can we really imagine behavior from code? I don't think we can do it well. That is why we should just make replicas instead, tokens are getting cheaper and cheaper by the month.
If you look at that, this approach is producing a pile of slop, where one LLM implements a feature, two weeks later another LLM spots an edge case and without much human review just crams in the code to fix that. Even at 1-2 months of that, those repos have significant changes and the commit messages get weird. I wonder what happens if the LLM won't spit out a fix anymore?
Will the human maintainers who started this process because noone thanked them and noone wanted to work with them on their bright new ideas just reset to the last commit they understand? Will they drop the project? The sunk cost for them is enormous. The time-effort required to fix the mess is gargantuan already. To me it increasingly seems that after the LLM industry robbed most humans of their collective labour output it will now rob them of labour aka time as well. Some people (like you and me) seem to notice that but most just go on and essentially spend away their life on machines now. I guess the problem is that most of these people have been severely cut off from using their own agency.
Companies work on the same ideas because they want to own IP, data etc. and then charge money.
The other way around they work on the same ideas not to be charged by others and control their business.
“software industry” is not some big happy hippie family. Patent wars, browser wars, OS wars - well we get a lot of open source for free but that’s not the norm.
What I'm sensing is something I might describe as the Oligarchy reaching the point of significant societal pushback, like the labor rights movements that ended 80 work weeks, unsafe conditions, and child labor in factories (i.e. The Jungle).
My hope is that we can use this moment in human history to break the user tracking and targeted advertising industry. It's been so harmful to humans, but in doing so, we will likely break a major revenue source that supports our well above average salaries. I still think it should be done.
This is the world the accelerationists are trying to create, is it not? Fully automated luxury space communism through AI solving all earthly problems.
We're just unlucky that software is one of the first moats to fall (alongside the humanities), because it doesn't require developing novel ways for the AI to interact with the real world...
I would love to believe this but I don't see it yet. I see a lot of anger in some circles, but I also see the machine marching on as normal.
We aren't there yet, but definitely headed that direction.
I suspect there are a lot of people really good at “systems” - there are a lot of really clever folks out there - that did not go through the proper CS rituals and are thus shunned but in fact can take over your job in no time especially with AI.
My wife regularly gets pushed away by “IT” at her work and unlike others she pushes back, but they don’t like her. They start talking about db clustering details etc as if that has any bearing on anything. I am a dev, I know she doesn’t know what logical replication is, but I do know she can replace their team. She just needs one technical person to keep an eye on things.
I suspect we will end up with just a handful of building blocks like “this is how data is siloed, secured etc”, “this is how dashboards are made here”, “this is how email is handled”, etc and employees with AI just develop their own stuff on top of these. The “devs” just oversee the building blocks and the overall soundness of the flow. Don’t know how many you need once that is standardized..
People react before they've had the time to really process it, and show a lot about their existing thought processes
Many technical people IMO fetishize technology and processes, disagreeable-but-right authority justified by their willingness to work on things that most people find hard or just don't want to do. Computers can be a vessel for identity and self-worth - it's alluring to think of technology (and ourselves) as intrinsically valuable. A surprisingly large contingent seems to see work as necessarily zero-sum and adversarial, and make it a core part of their identity (and often not even particularly abnormally powerful or better for it) - like what even is the archetype there?
People like your wife are the ones writing crazy excel spreadsheets and VB6 macros, and making decisions about enterprise IT products, and solving problems with computers! They're actually probably more knowledgeable about "what is a useful and valuable way to use computers" than the ones who find computers fun and freeing and Just Want to Code.
Algorithms will dole out as much outrage as you can take but at the end of the day, doing stuff with computers that people want to pay for - usually, automating or securing things - is why people pay us!
One framing is people overindex on Being a certain kind of person or (the archetype they aspire to or identify with, that is valuable in a passive sense), over Becoming or Doing what's necessary for their work to be valuable (actively helping people, and stuff that's not fun). Very normal to feel grief and not want life to feel so uncertain, but it was literally always uncertain! Life isn't over because the business people at your IT job want to build software!
IT (and developers) have always been gatekeepers at their business. It's a meme, a stereotype. And it's why they are absolutely melting down about AI; you can see it up and down this thread. They don't understand people want to work with people they like, first and foremost. And it's why normies can't wait to replace them.
Link to some of those comments? Should be easy if there are that many.
I'm reminded of https://archive.ph/a9Cli (ns;nt)
Or that human taste and expertise cannot helpfully guide a project there.
"Perfection is achieved, not when there is nothing more to add, but when there is nothing left to take away."
And I feel that sums up my feelings on AI this and that. Just as the wood and clay contain the sculpture within and it's the artist's duty and privilege to reveal that. So, is elegant software exposed from the conceptual mass, rather than built up.
The AI zeitgeist currently is 'how many features can I add' because we've tied self worth to work output instead of some other more personal or human rubric. AI will happily pile more and more and more code on your plate because it's a buffet. It's gone through reinforcement cycles guiding it to add whatever feature you ask. There is no training for elegance or careful considered design. Nobody is teaching this generation of LLM restraint.
The safest code is that which never runs. The most elegant feature is that which is not necessary.
I assume you run GNU Hurd as your OS? ...
In general I very much agree to the quote of the Little Prince's creator, but I am not sure if we mean the same by it, because you seem to value code elegance more than adding useful features?
Now "useful" does the heavy lifting here, but my point is a useful feature is useful, even if it is achieved by the most ugly unmaintainable code. And what counts as a useful feature will depend on who you ask, but in general you should ask some users. (They don't care how the code looks)
And sure, they do not enjoy a pile of garbage of new features that only work sometimes, but managed to destroy their existing flow. But "Nobody is teaching this generation of LLM restraint" this is hyperbole and up to each developer. There is no need to let the AI run on auto for hours, this is only one way how to use that tool. The other way is, you make the design yourself - and let the AI implement it.
Yes, but the most useless software is that which doesn't exist.
At some point, you actually do have to write some code and add some features, or else the most satisfied client is the one who hired your competitor.
They are not. Quote: "The safest code is that which never runs. The most elegant feature is that which is not necessary."
> you're bringing it back to capital.
I am not. I'm talking about satisfying customer requirements, not about capital.
I think you've replied to the wrong comment. Either that, or your reading comprehension needs some work.
But long term AI will allow us to unbundle and implement only the features we need.
All I need to know is it's the most widely used piece of software in my stack, by far.
They keep adding features that are outside the scope of the original project, without refining or polishing the original concept.
If you're being ambitious enough, you shouldn't be able to there in one prompt. Ambitious work with AI is done 24/7 for months and guiding it continuously, because it's not good enough to work autonomously for that long without going off the rails.
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.
All of a sudden nobody is interested in actually using the web now that it's so easy only for doom scrolling exclusively
With AI we could build top quality free open source tools for every niche.
In the retro gaming handheld space, we are seeing brand new highly custom “distros” show up to suit the plethora of hand held consoles in different shapes and sizes coming out. This is all enabled by AI, a human developer could have built this, but it would have taken ages and we wouldn't have so many options being build.
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.
Maybe you subconciously expect that it’s vibe-coded fart that will be unmaintained in six months as the person who built it loses interest?
Or maybe it’s the sheer volume of stuff that is being built now?
Or maybe I’m just depressed by it all. Don’t know. Wonder what you think about it.
Also basic brain chemistry: seeing a pack of impressive (by 2020 standards) solo dev projects a day makes it the new norm, raising the bar for the future. But now I feel like this bar is not reachable because of no way to accurately measure "impressiveness".
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.
Both your comments there seem to latch on to a detail and miss the context totally. Ambition scales with the number of "small" things you can get done too.
Ambition doesn't scale with the number of small things you get done. Ambition is the size of the big thing you are trying to do. It's true that improving small things can help you do that big thing, but that's not the same as the ambition itself. Wanting to build a better mousetrap is just a modest technical ambition. The kind of ambition I'm talking about is wanting to eradicate the plague, and then maybe building a better mousetrap as a means to that end.
I was hoping that someone with enough motivation and money for tokens would come up with a non-electron option that is similar to onenote, with free form note placement and handwritten notes.
Basically I wish there is an opensource app having good feature parity with OneNote. Thats a good benchmark to have.
Today I wish the same, but for someone with enough motivation and tokens instead.
Don't get the wrong idea: I would be glad for a OneNote/Obsidian alternative that's performant. I just lament the days where I'd stare in awe thinking about the levels of wizardry one must get to in order to build something that I admire. Now the first thing that comes to mind is "I wonder how many tokens did this took them to make".
its always been a problem for me that ive never been able to find something that works exactly how i want, so i just put up with whatever is close enough, like obsidian for example. its probably because note taking is just a very personal thing so everyone is going to have different needs, and the amount of options out there is kind of proof of that
from the point of view of a developer, an AI would help with the complexity of a program that has every feature under the sun, and for the end user ian Ai would help the complexity of having to put all those modules together and making them work well
obviously each person could just vibe code their own program right now but each one would be starting from scratch. it would be more efficient to start with the same modules that have been tried and tested and then piece them together into something more standardised
i would love if this was a thing for most software actually. photoshop for example has only a dozen features that i ever use and the other 1000 features are wasted on me and just mean a longer startup time and a larger install size, but also i dont want want an AI to make me a custom version from scratch because you would probably spend more time trying to iron out all the weird bugs in it than actually using it
I once made a proof of concept. Wikipedia use to have static menu entries. I had a greasemonkey script that hides some of them them.
For entries that shouldn't be hidden the line that hides them is commented out.
https://userscripts-mirror.org/scripts/review/170442
Then I had a form that let you pick which ones you want. It spit out a gm script with all entries commented out except from the ones you wanted to keep.
https://go-here.nl/gm/wikipedia-clean-up.php
I also wrote this as a joke.
https://neanderthal.go-here.nl
When a link or button is clicked the server return a js file that contain one function. Then it executes the function.
To borrow your example, when you've picked the functionality you want in your note taking app a version number like 1.0.0.unixtime can be generated and stored so that you can later populate the config form with the chosen configuration and add or remove things.
Or you could do something with a config file to populate the form again.
An LLM can also modify a config file. Before execution it can be validated, as it is so simple it can show which mandatory entries are missing, which ones are spelled incorrectly.
If you provide the LLM with the html form or the config file (+docs) it shouldn't have much difficulty generating exactly what you wanted.
As the application has now been turned into ravioli it also addresses the ancient puzzle of separating feature updates from security updates.
You can still introduce a new gui that confuses the hell out of users. Then if no one checks the box you can take your learnings from it without 1000 people having to tell you in 500 different places.
[] Icons? [] Text? [] Icons AND Text?
What might help is non-software-first companies valuing developers and engineers more, enough that we could earn a reasonable living which building actually cool things. Not sure how the economics works out on the other side. Can these companies make enough money to support this vision?
Being able to take pictures at effectively zero marginal cost, and being able to see them instantly, both make it much easier to get into the hobby.
However the rest of the points are wrong as the photo album step was there originally. Film acquisition time, album acquisition time, labeling time, sorting time, sharing time, shelf space creation and cleaning time have all improved by orders of magnitude and all of that impacted accessibility.
As to the claim that retention isn't insoluble, that's at best a baseless statement of faith not terribly dissimilar to someone praying a rosary. With other religious pieties there's at least some evidence (someone built a cathedral, there's a book, etc.) to support the faith. There is no evidence to date to support the idea that basic file formats are a settled matter on archival timeframes, much less retention services or storage hardware.
A big benefit here is public transparency and citizen video evidence. Like when ICE murdered Alex and Renee
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.
Having been a product and UX-focused dev for my entire career, I knew only the basics about parsers and compilers, but have enough experience to grasp where each piece of the puzzle fits, and how to evaluate them. At the beginning it was just a fun test, but it got progressively more serious; it now implements 100% of the latest spec, beats QuickJS in performance, and surpasses V8/JSC in test262.
It took me four months, and I imagine it would take me a single month to do it again - I’ve learned a lot. Someone who already knew what they were doing, and with the right orchestration, could achieve this in weeks at minimal cost.
I really think we are in for a cambrian explosion of software, enabling things that were just always a little out of reach before (like why can’t most of your devices really talk to each other, in 2026).
[1] https://github.com/ricardobeat/boomkat
Beg to differ.
The architecture is different, the language is different, implementation choices are all mine. It was not developed by autonomous agents. I don’t think you’ll find any code that is a duplicate of other engines* - happy to be proven wrong here.
* The regexp and unicode modules are taken from QuickJS and have the appropriate licenses.
https://blog.stuartspence.ca/introducing-asteria.html
https://store.steampowered.com/app/5482440/Asteria_4X/?beta=...
To be clear, I've made large software and game projects over the years, but no way I'd have found the time to do a remake/enhancement of a game I loved as a kid from 1995 that has zero business case. Not without AI.
To pile on, here's mine: https://github.com/linsomniac/apt-cacher-ultra
It is a robust, reliable cache of apt packages, with the additional goal of still being able to serve packages from the cache even when the upstream is down. This was started shortly after that DDoS of Canonical this past year. We've run apt-cacher-ng and apt-cacher over the last dozen years, but (a) it requires hand-holding about once a month and (b) it did absolutely nothing for us when Canonical was under DDoS.
I've put well over 100 hours of my time into it. Still running into a lot of people knee-jerk calling it "slop", but I've had 200-ish machines pulling from it for 6 months and it has worked way better than apt-cacher-ng.
I'm not really sure what to do with people who dismiss AI-assisted projects, while dehumanizing the 100 hours of my time I've put into it. I fear we're running the very real risk of both sides losing: the people trying to thoughtfully create with AI losing because of the AI, and the people avoiding AI losing because they can't keep pace.
That's pretty naive.
This isn't just a simple http proxy and checking if the requested URL exists on disc. It's a pretty subtle snapshotting system that fully understands and vets apt repos, detecting when the repo changes, proactively downloading "interesting" packages that have updated, verifying and validating all packages, and then promoting the repo to active when it is healthy. Plus a web-based admin interface.
The core of it is around 20K LOC, with another 40K in tests. The COCOMO model gives that an estimate of around 2 developer years of effort assuming full time work.
apt-cacher-ng, the hand-written C++ version, is 16K LOC for the core. apt-cacher-ultra does a lot more. Seems like a pretty reasonable LOC count to me.
What are you basing your assertion above on?
What the fuck does this even mean?
Like za_creature said you can use a language more towards the YOLO end of the spectrum - more Go or Python or JavaScript than assembly or Rust.
Your commit history shows you had an issue of high background CPU use. You probably wouldn't have it in a manually coded implementation.
Why even write one of those? Just set up an nginx proxy cache and call it done.
But that doesn't even scratch the surface of what this project does. We already have a few simple approaches to this problem: apt-cacher and apt-cacher-ng. Neither of which were any help when Canonical was under DDoS. Both of which have proven unreliable.
As I said elsewhere, apt-cacher-ultra is a pretty subtle piece of software, it doesn't just do a naive cache, it fully understands the apt repo structure, validates the repo, and snapshots it, understands what packages your clients frequently request and preemptively downloads updates to them as part of the snapshot promotion, etc. A DDoS of the package sources, even in the middle of an upstream releasing updates, is something a-c-u will handle no problem. I've simulated this by firewall rules blocking upstream traffic. It's also proven much more reliable than apt-cacher-ng.
I've been in the software game ~40 years, I've seen it time and time again: "How hard could it be" and then when you get into it you realize there are a lot of devils in the details.
You might want to change the way you phrase this idea. I think you meant that Go/Python/JS are more "YOLO-friendly languages" (you'll get into far less trouble if you write slop in them). My initial reading was the opposite. It sounded like you were saying the languages themselves are the slapped together garbage.
Assembly is most certainly not "YOLO-friendly", but is more YOLO.
Indeed. The number of hours is my goto defence too. So far I've put in maybe 200 hours of time into design, iteration, playtesting, QA, and balance of my game. Sure - almost zero has gone directly into writing code but this is still a major project.
People who one shot a crappy game have no idea how much work it still takes to get something really good over the finish line.
>I'm not really sure what to do with people who dismiss AI-assisted projects
Mostly I've stopped worrying or trying to convince the haters. I'm having a blast and building great things (lots more than just Asteria).
Good luck with your apt project!
AI has essentially stolen my career from me. I _liked_ having to solve complicated problems with software, I enjoyed having to get into the nitty gritty to get things done. I never really cared that much about the actual business problems I was solving, so moving up a layer of abstraction to be some sort of bastardized product manager/architect does not scratch the same itch.
OTOH, for solving problems I care about, AI has been a god send. I can achieve things that I would have never had the time for.
> If anything, it should make me more optimistic, not less. If you have an idea, you can turn it into product within 30 minutes, no matter how complicated it is.
There is no product in that anymore because someone else could copy your product in the same time.
This fallacy is second to only every SME believing their jobs are going to be the jobs AI can't replace.
You have QA engineers chiming in about how "QA" isn't going anywhere.. On threads talking about code, tests, and PR reviews being completely automated.. PR reviews being a quality assurance activity..
Cancer deaths are going to sky rocket before this is all over.
https://globalmecho.com/lights-out-lab/
I guess my wording was really bad. The point I was trying badly to make: I wasn't thinking about cell-level stuff, but rather human-level observations, experiments, etc. and these are not possible in a lab but only out in the "real world." I don't see AI running anything on that level.
edit: that would be more like medicine, not bio-science
https://learn.hms.harvard.edu/insights/all-insights/how-arti...
Yes, detection with AI is obviously already superior to doctors, but on research I remain skeptical.
Give it some time and you'll be adding to that list.
In every war, countless innocent people die due to mis-targeting or other failure modes. At times the casualty count there exceeds military deaths. It is so common that we have a term for it: collateral damage.
So the question is: does AI lower such damage?
If AI had not been used in the attack on Iran, history indicates the death tolls in this regard would likely been much higher.
Not making a political statement or implying support for the war. Just making a point that these comparisons are more complicated that your example.
Well, just wait then, lots of other professions will soon get to realize the same sort of pain, so you'll be able to be similarly dismissive and condescending to them, too.
A lot of people don't realize that the frontier AI companies are so focused on automating software development first because they are all racing to be the first to get to RSI. I don't know if RSI will actually happen, but many, many other professions will soon be in the same boat. Mathematicians have already felt the pain, and those mathematicians who aren't the few who have tenured professorships are certainly not (generally) some of the most coddled professionals.
But lots of folks low on the salary totem pole (copywriters, paralegals, etc.) are already being hit hard by AI and that blast radius will continue to grow.
My parents-in-law started their careers as management consultants. The job in their time was much higher prestige and much higher value than it was when I started my career; free flow of information over the internet and commodification of spreadsheets changed all of it. From my parents' generation, I know practical effects folks who became unemployable once movies went to digital effects; engineers who found their draftsmanship skills obsolete. Folks with near-photographic memories whose entire superpower was destroyed by computing. I personally grew up in a blue collar community that was income depressed because its labor became commodified, though that was due to mechanization.
The only thing I don't really agree with is where you say "My parents-in-law started their careers as management consultants. The job in their time was much higher prestige and much higher value than it was when I started my career." I still think of management consultants as some of the highest paid careers around, and getting a partnership track job at one of the Big 3 is one of the most desirable jobs (for MBA types anyway) there is, so I just don't know what you're talking about with this one.
Sorry, I didn't mean to imply that. I just meant that part of the unique feelings in the air for software engineers is that this is the first time we're facing this.
> I still think of management consultants as some of the highest paid careers around, and getting a partnership track job at one of the Big 3 is one of the most desirable jobs
There's plenty of other jobs the MBA type could get into these days which are also high prestige and there are now many more tiers of management consultants. The elite folks at McKinsey are still high prestige with high salaries, but your average Accenture or Deloitte consultant is both pay and prestige wise about the same as an average knowledge worker. Plenty of VCs, fund managers, and investors are high prestige MBA-types. The explosion of private capital means there's a lot of opportunity to manage private capital; private capital markets were just much shallower 50 years ago.
And? Who are these people that need all this sympathy from internet strangers? Grow the fuck up and go solve your own damn problems. I can’t stand these “I need internet strangers to tell me that my life is, in fact, hard” people.
its a tribalism problem, but one of trying to uphold the current tribe system while theres a pretty obvious new tribe system replacing it
AI has taken that security away from me
My lifestyle isn't super expensive, but I can't afford to retire or anything. I have a mortgage that I still owe money on
My comforting thoughts are, who is this all for, and what would happen if AI actually makes human labor redundant? Labs control the AI sure, but so much stuff is built around humans that it almost becomes comical to think it would be a bad outcome for a the average person.
Farms and land don’t cease to exist, houses/apartments don’t go up in flames instantly, people aren’t reduced to functionless sludge creatures as soon as they’re done being economic drivers. What’s the real plan? All the normal people die and a thousand or so chosen few sit around and watch AI videos and eat grapes until the heat death of the universe?
Nah, we’ll figure it out, perhaps it will be harder temporarily, and perhaps SWEs lose status before everyone else, but it will probably be okay overall.
Imagine what happens if landlords decided one day to collectively demand more money than actually exists in the total monthly income of workers. What would happen?
You can point out that if everyone just stopped paying rent, their houses and apartments would still exist, and they could live rent-free as their landlords would have no money to spend on enforcement. Technically, this is not untrue. But it's not what would actually happen, is it? One person would be the first to default on their rent, and their landlord would use the money collected from all their other tenants to seize back that tenant's formerly rented property. No individual tenant would dare to be the first to stop paying rent, so they all continue paying rent, selling their stuff, taking out loans until there's physically no way for them to keep paying, and only then do they default.
I am strongly feeling I'm already redundant
‘Not having to work and being warm and fed’ is called being a pet. Some cats and dogs enjoy this life greatly. I’ve been thinking about this a lot recently.
I'm sorry for your loss, but welcome also to the real world. You had it better than most for a long while.
I know plenty of people in their late 40's 50's and 60's that were doing fine and who now have to compete with junior and Claude.
And sometimes just Claude.
Obviously they had no inherent right to income but still, people have obligations that need to be met and if they stop spending the economy is not going to be happy. Especially cruel because we have been telling everybody for decades that a career in software is stable and that there will always be a need for more people.
I suspect that when all this is over 1929 will look pretty good.
I don’t, necessarily; but I do know that if you’re not even trying, then you’re putting yourself at greater risk. This isn’t one of those developments that people can just stubbornly dig their heels in about.
Life throws obstacles at everyone. Learning how to dodge and weave is essential to survival.
> I suspect that when all this is over 1929 will look pretty good.
Oh come on. Let’s not be so dramatic, shall we?
We could also all put our gifts toward preventing the "new reality" you see as inevitable, and put you at greater risk.
The future isn't written yet. Your ability to predict it is an illusion. In aggregate, people whose job it is to predict large-scale economic events are worse than chance in their predictions.
Sounds good, but isn't supported by data. Tetlock did not establish that all experts are worse than chance.
> The average expert was slightly better than chance.
-Tetlock
There's no realistic way to compose a statistical model for what will happen to a society when a powerful new technology is introduced. Predictors of our brave new AI world are going to be about as accurate as our pundits.
I can read between the lines.
Also, this new reality is today. You may not be seeing this in your place of business or culture yet, but for many of us, it arrived up to 2 years ago.
If that's happening at [redacted] of all places, I think it's reasonable to think that the technology may not be as transformative as predicted due to its (currently) poor performance in generating revenue.
We're profiting from its inefficiency by selling compute to other companies, especially AI startups. It's expensive and unprofitable for them and a cash cow for us. The position we're taking is bearish and somewhat more reversible than that taken by Meta, for example.
This is sensible and pragmatic, but I think you're talking past the other commenter.
Obstacles presented by, for example, your boss, or your company's competitors, or your political system, are not the same as obstacles like heartbreak, natural disasters, emotions, illnesses we cannot yet cure.
> Learning how to dodge and weave is essential to survival.
A lot of people perceive that elites are throwing dodgeballs at them in order to increase their own profits. Saying "them's the breaks, it's just the way it is" appears to be deflecting criticism from those elites and that system.
It probably depends on whether you think we could actually feed everyone, today, if we chose to, or if you think e.g. human nature prevents that from being possible.
You'd have said the same thing in 1928...
Seriously: this is a massive problem that we are creating and given that the tools that make the problem require better tools to solve them I really am not all that happy about how this is going.
Hindsight is 20/20. Besides, what good is panicking? It won’t help with the inevitable; better to adapt and save for it.
> the tools that make the problem require better tools to solve them
You’ve found the opening :-)
I'm not worried about myself, I've had a lot of luck in my life for which I'm super greatful. But I'm also quite aware of the exceptional position that puts me in and how many people are not so fortunate that they could probably live on their savings for the rest of their life if things ground to a halt.
Most people live paycheck to paycheck, or they may have a few thousand bucks in savings at most. They've worked hard all their lives and simply were never in a position to save enough against this kind of eventuality because the deck was stacked against them.
Have a heart, and realize that barring a couple of unfortunate moves it could be you looking at your last 500 bucks with rent due and a couple of mouths to feed.
I agree, but I'd like to think these people come from a optimistic point of view.
A lot of people don't seem to understand that the "human in the loop" is exactly the thing the big AI leaders want to cut out as much as possible.
I’m sorry if it’s coming across that way. It’s not my intent, and I’m aware that many people are a lost paycheck away from a crisis.
But if you really think the right thing to do in response is to complain and commiserate, I don’t think that is helpful, either. I think it’s much better to encourage behavior that has a chance of being effective.
If you think it’s somehow wrong to encourage people to behave in such a way that has a better chance of setting them up for success, then I vehemently disagree.
> To effectively tell them... to adapt when that simply isn't an option is losing sight of the human angle.
You must have a pretty low opinion of people if you think they can’t adapt.
What if complaining and commiserating leads to fighting for political actions that lead to outcomes we like better?
This thread is not designed for discussion? I'm not even sure what that means. If the sentiments expressed in this thread lead to people discussing the same topic elsewhere, does it matter what this thread is "designed for"?
> 2/I’m not sure what outcome you’re contemplating
What does that have to do with anything? I'm responding to a comment complaining about the fact that others were complaining about a narrowly envisioned future which seems, to them, inevitable. I'm merely pointing out that the dissenting opinions could have value to individuals who want different outcomes from the ones predicted.
It means that that’s not where the conservation in this thread is going, and in my experience on HN, almost never does. There’s no organizing going on here. It’s not even clear what a group of organized people would fight for based on the conversations here.
Finally, I’m not telling people they can’t commiserate or complain. It’s an open forum for people to speak their minds. However, that freedom cuts both ways; people are equally allowed and encouraged to have contrarian views that are respected.
How do you know there aren't people organizing after discussing something online and realizing there are others out there who agree with them? You assume, but you don't know.
And yet, you speak confidently, as though you do know. What's with that?
I’m not going to produce a laundry list of how it’s already impacting engineering productivity and practice. You can look that up yourself.
That's because you don't have one.
I work for a big tech company. My org is being asked to be more judicious with AI usage because there is no evidence that it improves productivity and is in fact slowing some work down. Recent studies back this up. It is affecting practice, not productivity.
> The fear and anxiety are driven by some people’s natural responses to that, as they see it, too.
How do you separate that out as the cause of the anxiety, when the leaders of AI companies are actively fearmongering about the power of their technology?
That or swallow a bullet, we'll see. Haven't decided. We'll see how long my current unemployment lasts, and how long my savings last after that
Having been in this game for a long time, I get the negative aspects of the industry. They grind on me, as I believe they have for you. Choosing a different path is not an all or nothing proposition. Your knowledge, and you as a person, have value. I hope you find a way towards better mental health and wish you well on that journey.
>Your knowledge, and you as a person, have value.
This is the exact thing AI is threatening to take away.
What will it not replace, eventually?
Been seeing a counselor for over a year already
Went and made a doctor, guess it's time to look into medication
Thanks
Don't worry about me, I'll be fine. Been here before, just very unhappy to be here again that's all
I’m not trying to be contrary, just that doesn’t say a lot.
I think we'll see a lot less people willing to share if the end result is just to feed the machine no matter how they arrived at it.
I don't see why I should care about this any more than I cared about "somebody I don't like could read my code and learn from it" in the past. The frontier labs can generate or buy all the training data they need; not releasing your app isn't going to hurt them in the slightest.
I think this could be achievable with LLMs if they had a much higher token rate. That way you'd have less downtime and could work on the problem more aggressively. How it's designed to work now, offloading cognitively, doesn't feel very good, even when you 'ship' more.
I get it, I've gotten a lot of joy over the decades from the specific act of programming. But I also get a lot of joy from making something. I'm old enough now that I don't have a lot of my time left to "hand stitch an amazing tapestry". But with AI tooling, I do have time to try out a bunch of ideas and see how they work, scratch little itches and also just run a mad scientist library of experiments, without each experiment taking tens or hundreds of hours of coding to see how that experiment pans out.
Why not? What is the goal of "having an amazing tapestry"? Do you need to do increasing more things in the limited time you have left and making a tapestry isn't one of those things? What will you have once you've "finished" an amazing tapestry, just something to hang on the wall and look at? How does one "use" a tapestry after it's "finished" such that the act of finishing it is the most important thing? If you've finished it, will you get more enjoyment from looking at it for longer because it was finished sooner and thus the length of time you can look at it before you die is maximized? Exactly what you are optimizing for here?
Let's call it "Joy".
I've done hard things. Many of them have a significant amount of time that is a slog. A tapestry is going to have a lot of days of just slog work. And that's fine. Doing hard things can be very rewarding. I've reupholstered a couch by taking it down to the sticks, repairing and reinforcing the frame ("hey kids, the couch isn't designed for walking and jumping on"), enhancing the design, re-springing it, redesigning the cushions so that they didn't need readjusting every time you sat down, making new foam cushions, and then sewing a upholstery. Took 3-4 months.
But, I'm in the last half of my 50s. The project you're commenting on, apt-cacher-ultra, probably would have taken 2 full time developer years to get to where it is now, and I'm doing some pretty big changes for the next version. I literally probably have a handful of that sort of project I can do left in my life, assuming I quit my job now and work full time on it.
Let me tell you, it's pretty sobering to be faced with: "I may only be doing this once, maybe twice more in my career."
So yes, building experiments where I get to try out my ideas without 2 developer-years of coding required is going to give me an opportunity for a lot of creation that I otherwise wouldn't have had. I've spent decades hand-crafting code, I fully understand the joy of doing so.
Big solo projects exist, they're just not coming out as frequently because of, uh, how time works
[1] Yes, lots of people use dictation instead. I feel like speech-to-text loses you the benefits that speaking has over writing in terms of communication power, plus it's inefficient. I'd rather harness the benefits that writing (really, editing) has.
Don't we see this already a lot? I feel like people constantly say this exact same words.
Now I must pay for codex/claude, and that money goes to billionaires psychopaths. So that sucks as you can imagine
My understanding from reading the lwn article is Linus's implication is more specifically about filtering out people that cannot write code without LLMs or the willingness to spend the money on the tokens required to uphold the quality of the kernel. He does not want to push out developers that do not use LLMs.
Which talk of his gave this impression?
That happened at least 20 years ago. How many recent "this product did so great because of the care of software engineering, and now the creator is comfortable for the rest of their life without risk of it being copied" success stories are there compared to "this product chased some trends VCs were nuts about with a slapdash MVP and the founders took out 8 figures from their later fundraising rounds, but then the business sputtered out"?
I think there's an angle with AI tools where business-minded people will have a better chance of doing interesting things now than in the recent past, because you could potentially tailor much more deeply to individual customers with reasonable economics than in the past. There are fields where there's room for a garden of solutions from different small-team vendors appropriate for different use cases instead of a one-size-fits-all SaaS winner-take-all type market in the past. We could kill the old line about SAP around needing to change your business to accommodate SAP instead of customize SAP to accommodate your existing workflow.
But if you aren't business-minded at all there are likely less places that will need to hire as many careful maintainers or novel-software-writers, which obviously is a huge kick in the teeth to a lot of people.
You could also focus on problems. What are the actual problems you want to solve? Can you use software to solve them? Do you still need to buy that software from other companies, or is it now feasible to have sufficient in-house expertise to develop it yourself?
If you can make it solo with an LLM then someone else with an LLM can copy it immediately
why are you here if you dont enjoy the solving of problems first and foremost?
Can we please, for once, stop trying to figure out how to "get ahead" of each other, and instead figure out how to build a decent and dignified floor for as many people as possible? Because I imagine that, "Ultimate power in the hands of anyone with enough VRAM to run GTAVI," works better when people are in a culture of looking out for each other, versus a culture of clawing their way to one of the limited lifeboat spots (under the mistaken impression that there ARE lifeboats, when, again, everyone potentially has the power to blow up the lifeboats).
I 100% agree people need a culture of looking out for each other. I'd argue that has only successfully happened sustainably in smaller communities, and from the bottom up rather than the top down.
Take care of your neighbors, and ask them for help when you need it. You aren't proposing this here so I'm not arguing with you, but it never works for long when the "help" comes from the top down. For a short period we may actually see the government take resources from some to help others, but eventually that is corrupted and they stop at the point of taking resources and power.
You end up with the government deciding how much bread each person needs, how much the bread will cost, how much to pay a person so they can pay the defined price for the allocated amount of bread, etc.
Either utopian claims of an AI and robot-powered future are right and we don't need money because you can just have what you want, or money and resources will still be scarce and we will continue to compete amongst ourselves for resources.
2) America in 2026 is not the USSR in the 20th century, so even if they did, our circumstances are very different from theirs.
3) UBI was only the first suggestion; you completely failed to address the other and then jumped to a black-and-white conclusion.
The general thrust of my proposition was that people shouldn't have to submit to an artificial system of manufactured competition and unnecessary "productivity" in order to access goods that are objectively abundant. When people realize that and make the necessary compromises, they won't have to worry about shipping useless AI-assisted slop for "income security" and can focus on using AI to build consequential and useful software.
Please do not get bogged down in whatever kneejerk anti-UBI thought-loop your misaligned amygdala is screaming at you.
2) I didn't say the US is the USSR. I pointed to a clear example where a UBI-like structure was tried and failed. Feel free to call out specific differences that may help it work better today in the US, I'm genuinely curious despite my skeptism.
3) I can respond to the others as well, but that isn't necessary to have an interesting debate or discussion on any one topic. If one was required to respond to all raised ideas they could try to shut down all conversation by threading together a long list of hard to discuss topics, avoiding responses to any one topic.
I do agree people can avoid having to submit to AI or ML systems though. We ultimately all make our decisions, some more impactful than others, and if we end up in a dystopian future with no jobs and AIs/robots in charge of the world we made that bed for ourselves.
I'm not bogged down in any kneejerk reactions and I'm not parroting what I've heard air bags saying elsewhere. I've read up on the topic, the history of the USSR, and read Marx writings (well the translations, I speak some Dutch but no German). We may disagree, but my views aren't uneducated reactions.
2) >I pointed to a clear example where a UBI-like structure was tried and failed.
You did not.
3) That's not applicable here. Why did you respond to the UBI issue only?
>I do agree people can avoid having to submit to AI or ML systems though.
I didn't speak to this at all. The "artificial system of manufactured competition and unnecessary 'productivity'" is independent of AI and ML and has existed for several decades.
>my views aren't uneducated reactions.
See 1.
My conclusion is that you actually aren't interested in a conversation. You haven't responded earnestly or considerately to anything in my initial post except the portion suggesting UBI, which you dismissed with a faulty presence.
Here is my suggestion: talk about something else from that post. Anything else. Do not revisit the UBI topic.
I did respond earnestly, whether you accept it or if I'm explaining myself poorly. You have yet to propose how a UBI would actually work, or pointed to an example of it ever having worked in the past. Socialism and Marxism have been tried, the don't work. And yes, UBI is an idea that goes back to Marx's writings.
Can we get a forum for sharing project that were _proudly_ built with AI due how ambitious they are?
I was a fantastic IC and built really amazing software. I'm an even better AI-empowered engineer.
The old era is dead. The new one is exciting.
But even without that, open weight models are already good enough and everyone would be fine with paying unsubsidized prices for them.
Employers previously hired you because cheaper alternatives such as offshoring were impractical…
Now the AI is cheaper, faster, and better than domestic labor and offshoring while still hosted domestically…
Some will feel one doesn’t need an experienced rockstar to babysit an AI…
In about an hour I just solved about 80hrs worth of personal coding/debugging with a portion of a $20/month Claude subscription… Frankly it makes all my knowledge and experience feel kinda worthless… I only gave it a few sentences…
So then, given your knowledge and experience, what challenge would require 80 hours of real, focused work out of you using today’s tools?
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.
Claude was able to identify the approach that worked, and even the long Python command that was needed. In, yes, probably about 10 seconds.
For me to figure that out myself, it probably would've taken something like a year of study. Of the entire stack of machine learning and all of the Python tooling associated with it.
That's where these absolutely incredible astonishing speedups come from.
Because it's one thing for Claude to be able to write code 20 times faster than I can. But it's a whole other thing when it is able to create things in domains that I know nothing about at all. That would take me one or more years to become an expert in. But where I can still just verify its results, so I don't need to be an expert in order to judge the quality or suitability. If the end product works, the end product works.
I have similarly had it come up with mathematical formulas that would probably have taken me a year in going back to studying math if I had to derive them myself. But where it is trivial to show that they are producing the correct output for known test cases.
So trying to come up with some kind of factor multiplier here almost kind of falls apart. It might as well be infinite. Because these are things that I just wouldn't have done otherwise. The software wouldn't have gotten built because I would have had to hire somebody else to do it, and there was no budget for that.
> For me to figure that out myself, it probably would've taken something like a year of study. Of the entire stack of machine learning and all of the Python tooling associated with it
It wouldn’t take that long. Maybe a few days of playing around. It’s not like you’re trying to create a new model from scratch. No need to understand linear algebra fully to learn how to do a dot product.
I am entirely sure that it would have taken me many months to figure out that that was the actual thing that needed to change. It wasn't just some kind of tooling configuration issue. It required a deep understanding of the size of every single different layer of the model and how they fed into each other.
... But while you're at it, perhaps you could try having Claude teach you some of the domain, too. It takes much less time to study these things when you have a guide directing you and pointing you at the right research. You might be amazed how much less time.
But that was still to answer very targeted questions that I would never have been able to ask on my own in the first place without months of study.
And when we are talking about the speed up from LLM's, we are generally comparing to a world without LLM's. Not to some mythical world where LLM's are able to teach us about anything but not actually able to write the code or find the technical solutions themselves.
I am a huge fan of having LLM's teach me what I need to properly guide them in domains that are outside my expertise. It's kind of funny when you think about it. A really big part of learning how to be productive with Claude is indeed trying to find precisely the areas where you yourself, not only provide value, but provide irreplaceable value.
Yes companies/large groups of humans are sometimes also a lot faster at doing some things than a singular person. I'm not sure why that matters or what your point with that is.
I think it makes sense to focus on what one individual can do, and amount of time to do it.
If I'm sawing wood I could compare a knife to a handsaw, to an electric saw, to a table saw, to a team of woodworkers, to a factory, etc.
It would be totally reasonable to compare the amount of wood I'm able to saw by hand vs electric or any of the other methods.
Humans are a lot more expensive, it takes ~a year to find, interview, hire, onboard and offboard an employee, while an agent can be spun up for 10 seconds, do its work and vanish back into the ether.
Agents are lambda functions where humans are bare-metal servers that you have to rack yourself.
You might want to make a separate point about the cost difference of getting more done by hiring more people or running more agents, but that is a different point.
Also, those AutoResearch agents for other types of verifiable goals.
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.
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.
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.
AI should make us better, not just churn out trillions of lines of code.
The very idea of massive vibe coding efforts, where devs go to sleep with a hoard of agents churning away, makes me uncomfortable.
I worked in agile/scrum orgs with product managers who couldn't be bothered to write well formed tickets or truly keep a well groomed backlog, I think this is more normal than not outside Mag7.
A lot of work was noisy iteration with a guy/guys who change their mind a lot, and write nothing down. We met weekly to iterate, I suppose now one could meet 2x/day to iterate (10x!). I am not sure we would arrive at "done" 10x faster though. Probably 50-90% of the productivity boost would go towards.. doing more iterations.
For an external customer facing product with KPIs, A/B testing, etc that could show iterations relationship to revenue probably that's great. For a lot of internal tooling that is not good. A lot of senior devs kind of internalize this behavioral knowledge already and purposely cadence out changes to stakeholders to avoid this type of churn, while working on other things.
Re: backlog
My observation at work and in my work network is a lot of SWEs are using the productivity boost to burn down backlogs that probably never needed burning down. There's a reason some tickets were there for 2 years - they aren't actually needed, and everyone is too lazy to close them.
So in both cases we have problems expanding to fit the time available.
As soon as you have many engineers using agents in the same codebase, the process breaks down, and you start stepping on each other’s toes, collapsing those velocity gains.
Maybe the “software factory” pattern will work, where agents just pull from the backlog, and so the team can all focus on grooming and disambiguating tickets, with the coordinator agent flagging conflicts and ambiguities between different people’s asks?
The only thing I’m confident of here is that a “h1 planning exercise” doesn’t really make sense in most cases; ~everyone should be shifting to building a lot of prototypes and iterating with customers, rather than trying to prioritize how to spend scarce eng effort. (That resource is no longer scarce.)
I think a lot of teams are going to rediscover (by necessity) the good parts of Agile, namely finding the domain expert and iterating with them to solve the actual problems; that’s your bottleneck now.
If something that runs on those is somebody's idea of a good process, that's wrong from the inception. Good process looks like completely broken "Agile", but in a way that somehow everybody is happy with the results.
Prior to this, building the software was, generally, one of the main constraints. If the business wants to do X, then it takes 3 months to build.
That means the business ideation and governance cycle (what do we want to do, are there customers, what do we charge) can take 3 months.
If you 10x thay development process then you also have to do the same with the business processes.
Once engineering teams have cleared the backlog, then burned through the decades of tech debt the constraints will switch. And how businesses react to that will be interesting.
Riiight, except tech debt is the one thing that's actually been 10xed. People are now producing a decades' worth of tech debt in less than a year.
The latest frontier models are producing significantly higher quality output. And the usual reason to introduce tech debt (deadlines) is less relevant.
Indeed, I know multiple companies fixing decades of bugs and security issues in just the last few months.
I have no doubt someone in business will have more ideas than any team can deliver.
Think about all those product-pitch PPTs. What if one could present a prototype instead? Boom, demand increased 100x.
That's Jevons Paradox https://en.wikipedia.org/wiki/Jevons_paradox
Or the extra time can be used towards polishing the software.
Will it? Are you willing to test this?
>No one is laying off the development team that just chewed through 50 items per day for 3 straight weeks.
If there are no remaining items, or the amount of items processed per day has increased well above the amount of items that need processing every day, someone's certainly getting laid off.
>Who would support all the potential bugs they just created?
We have long criticised management for not caring about this. Now we are supposed to trust their good judgement?
I recently switched, but at my previous job, the PMs (who would typically do most of this work) got so overworked after AI took hold, that they’ve doubled the PM-to-dev ratios on all (the productive) teams.
I have read about this in other companies as well. Some teams in Google have a PM pr dev, I hear.
Where I work now, sh*t gets done MUCH quicker with AI, and to a higher quality as well.
IMO, if you work with software and can’t get a meaningful boost out of AI, I think you’re doing something wrong.
Many of these companies have no idea what to do to begin with, so improving dev throughput is not really the business problem to begin with (even though frequently blamed).
In every software job I’ve ever had, every released new feature leads to maybe three new requests to modify the new feature, two unintentional bug tickets, plus some tech debt. Work leads to more work, not less. I don’t see how increasing the velocity of the work should change that.
Yes, this literally happens all of the time today. Proof point - software development organizations hire to fill operating budget voids, not on what work needs to be done.*
*Source - I've seen 900+ software team's P&Ls and interviewed their CTOs.
So if I hire a painter who is pleasant to be around, trustworthy, and good at what they do, I'm not going to "lay him off" the instant he's done painting my house?
If someone is deliberately stretching out a job and making it an adversarial business relationship, when the business arrangment is that they complete the project then do another job somewhere else, then I would not expect that to be a very successful strategy, and also not really want to help them in any way beyond existing contractual obligations. You are basically guaranteeing a bad working relationship with every employer you ever have.
And it doesn't make sense because this is not a strategy that's rational for someone who enjoys their work or is good at their job anyway - if that describes you, then your existing employer is probably one of if not the best advocate you have, and your best strategy would be to either switch careers or progress to a point you don't feel precarious
That's why I say you are really hurting yourself more than you know. You are guaranteeing an at-best "every boss dislikes me and my career goal is not getting fired" outcome and (idk about your actual employer) damaging relationships you really probably need (if this is your mindset)
Some people view their job as having infinite things to do, and AI means they can work on more and different things.
Other people see their specific job as a series of tasks, and if AI does those they don't know what do anymore.
Guess who is going to stay employed?
I take an issue with that mindset because I know it is not true. And I'm not sure why you think I am attacking this person - if someone were to actually sandbag their own career, that is probably one of the most damaging mistakes they could make. Maybe I misunderstand something, if so I apologize for that
I'd argue that there's more delusion going on in people leaving software development because of "what is coming" and somehow ending the thought there.
There's a lot more going on out there than "writing code", believe it or not.
But "AI writes slop code" just sounds ridiculous at this point.
https://news.ycombinator.com/newsguidelines.html
I largely agree with the main idea in the post, but would push back on this.
As I’ve gotten older, I notice a large proportion of tasks can be chalked up to busywork. Not in the sense that they aren’t real bugs, but they’re not fixing root causes of problems.
To your point about process, there may be a hundred tasks that stem from poor repents management or poor testing process etc. There will likely continue to be many bugs until that root process issue gets fixed. To that end, those root problems generally take much more work to solve.
So, yes, many tasks can be done quickly unless you’re doing true root cause analysis.
That will end well.
AI allows you to produce code without understanding the system, and that's how you can get delivery speed up. And, yes, AI is getting good enough that you can purchase large amounts of code from Anthropic without understanding much, so you can move very fast indeed as long as you never need to make sense of it.
> 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?
Do you live under a rock, or are you hoping that saying this enough will law of attraction[1] it into being?
https://en.wikipedia.org/wiki/Law_of_attraction_(New_Thought...
Personally I do code review, it's what we do at my workplace, and we regularly improve the agents' code and design though human review, even with Opus 5.5.
But looking at some of the people who are pushing AI development the furthest, I do see the trend towards it just not being that useful anymore.
Real world example:
I use T3Code as my agent orchestrator and it's consistently pretty high quality and works well + regularly gets new useful features.
And with just a handful of maintainers, they're doing anywhere from 100 to 200 PRs a day!
And there are a ton of users of their nightly, which is a rolling 5-hour release, and nothing really breaks. And they have more real-world users than almost all the projects I've worked on before.
So I just can't really in good faith say that this extremely challenging to my world view.
If you're running tons of product/UX experiments code review is just going to waste everybody's time. But the volume of changes you can make now is so large, someone could touch something important about at any given time without proper oversight.
IMO an effective team has to be able to either trust each other enough/be accountable enough that code review is mostly unnecessary, or everybody just works really independently on mostly separable things, or you regularly pair/mob-program.
If you can trust your colleagues not to pump out code without messing it all up or turning everything into slop, or creating large amounts of work for other people, things are great. Realistically most dev teams have a wide range of skills and personalities and people also make mistakes, and code review helps us build shared knowledge and collaborate.
Maybe there is too much of a moral hazard from the reviewer's role as a cosigner, or some people are only as conscientious as necessary to get things done (not a problem writing every line by hand)... but people can ruin code review for everyone else by demanding an asymmetric level of accountability/judgment and oversight.
The bigger issue for me is whether or not you still do code review, you need to build shared knowledge within teams. I really think we should be reviewing our colleagues' coding agent session logs
Not even to critique them (but that could be useful), but just to understand what it is they are actually trying to do/what mental model they're operating under, and if there are issue in the PR, what miscommunication or technique or process could help fix it? I think a lot of people feel that asking to see those logs is invasive or embarrassing, but the problem is that it's just really hard to build a model for how someone works or thinks without it. You don't need that in a deontological sense, but you do if you want to fix coordination problems.
> Quite the contrary. It will create a vacuum that the business will fill with new work that may incidentally increase the developers' compensation packages.
This seems very disconnected with the reality of any company I've worked at in 25 years.
"Tasks" frequently are not spelled out, or if they are, they are wrong. There's almost no value to a company to blaze through all this.
Similarly, no one is getting rewarded for that type of speed, especially if the company has no idea how to uptake it.
https://claude.dev/blog/solving-code-review-at-anthropic/
You need to decouple it, but you dont need to remove it.
Agreed, and in fact even pre-AI good development teams weren't limited by speed of code generation (how to build it), but rather making the right thing (what to build).
It can if a single developer replaces a whole team.
What? You know there's only 24h in a day right? I work 8 of those and most tasks takes my agent far longer. And thats not including me correcting it, adjusting the spec so it does the right thing, etc etc. And I don't have anyone doing a PR waiting, I go straight into production.
I’d look into where the model is spending its time and see if you can save some time. Eight hours is more then enough time to have an entire new microservice up and running and to adjust existing microservices to utilize it.
This was a problem well before AI, but it doesn't get talked about enough because so many developers are hooked on the power trip they get from making people waste time on crap that has no relevance to the user.
In my experience, this has been senior engineering leaders and project managers more than anything.
The user is not just the person consuming the finished product
Why not say outright that "ideological friction" is about AI usage? Maybe some devops have friction cause when things break at 2am and they get called up they don't want to dig through 500k lines of slop the author can't explain?
And "empty 99% of the backlog everyday" <-> "hire more people to fix the bugs" is illogical. Reviewing slop and fixing bugs make me want to go build houses instead of software.
Meanwhile, back in reality, DevOps now have a tool to help them sort through the slop that already exists.
So, go build houses, nobody cares. But go ahead and try and slow their process down with "the way you like to do things", see how that goes.
Barring underspecification, and bugs in the verifier.
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?
For real judgements on database products, I'd look to https://jepsen.io/. That author tends to be refreshingly straightforward in a field where many vendors love to cheat by different names
As far as I'm aware, Jepsen solely focuses on correctness (which is more than enough for someone to do!), not performance.
To give you a sense of how fast it is, pgrust on a c6a.2xl is faster than ClickHouse running on a c6a.metal, a machine with 24x as many cores and costs 24x as much.
Edit: And now it's been accepted: https://benchmark.clickhouse.com/
[0] https://github.com/ClickHouse/ClickBench/commit/56535d29e825...
[1] https://github.com/ClickHouse/ClickBench/commit/89cc76e1e4e2...
You don't have to take my word for it. If you want you can inspect the binary yourself: https://pgrust.com/downloads/archive/2026-09-clickbench-snap...
You can run the binary with PGRUST_GRAVITY_REPORT=1 which logs the code path hit for every query. You'll see that all the code goes through the general query path. We did have hand-rolled code in the binary, but we used it for testing. The code is not used when running the benchmark. We also did not use a results cache. Warm runs still scan all the data. You can verify all of this
You are right, though, that it did support a narrow set of SQL. It supported scans, group bys, sorts, and filters. That's enough to run all the queries on ClickBench, but failed on functionality not tested by the benchmark like subqueries
You keep giving this same answer to no one's satisfaction. Saying go check the binary is worse than saying go audit 400k+ files. How do we know the Ai has not cheated in the code path logging? How do you know that it has not?
The more you make excuses, the more we get suspicious
(copied and pasted from another place you gave this unsatisfactory answer)
It instruments the files that were called out in the PR, then runs ClickBench. You can run it and see that the code in those files doesn't run.
If you can find anything suspicious in the binary, let me know, and I'm happy to dig in
this would be less dramaful if you had said something more like "claude cheated and we didn't notice, here's what we will be doing going forward..."
people empathize more with those who admit mistakes than those who try to argue around them
What happens in an environment of cheaters is that cheating becomes so commonplace, the competition becomes one that assumes cheats are enabled, and then everyone involved either denies cheating or is silent about it because IYKYK and if you DK, you don't need to K. Look at bodybuilding, which is full of men (and women!) absolutely juiced to the gills getting on Instagram and assuring everyone that their physique is totally natty, bro, just hard work and proper nutrition.
Programming is headed in that direction. LLM use, even to the point of "vibeslop", is the new default, and while LLMs do overindex on benchmarks, our benchmarks are going to end up overindexing on validating whatever public opinion thinks is "great" at the time, irrespective of whether it actually is, so "cheating" as we know it will go undetected, and certainly unpunished if it is detected. I don't know what the equivalent of falsely claiming you're natty is. Maybe saying "I wrote this" when you wrote it about as much as the Pope painted the Sistine Chapel fresco?
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.
Most organisations and people just need to focus on doing the basics right. There's an obsession with optimisation and we see this in all aspects of life.
We end up spending a lot of time and money on things that aren't really that important and don't move the needle that much, or actively making life much worse for people.
I read someone’s realization here and it’s dawning on me as well. My ideas, they suck. I can’t be ambitious if my life depended on it.
For work though I think many of the same applies - keep it simple - but there is actually some progress to be made. Processes always can be improved (for now) and even just improving the UI of some sad but necessary systems that employees have to suffer through everyday is still worth it.
Similarly, you can try something like:
> Break down aspects of the economy by amenability to state control high/medium/low, based on what we see in successful economies. Include a rationale and supporting evidence/counterexamples. Present it in 3 tables.
It should give you dozens of things you can look up. Eg it might mention successful Singapore and Vienna-style public housing, and there are some nice videos on that on Youtube. Teach your kids how to do nuanced large-scale research, while everyone else is at "communism is bad".
The bot might also miss something, or get something wrong, and they should be able to catch it. I think auditing LLM output will be very important in the future.
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.
…But he's also shipped the engine and the language, yes?
- technical skills to build an engine, language, and game
- interpersonal + communication skills to build, manage, and lead a team
- business acumen to take the above 2 skills and create profitable businesses (plural emphasized)
Not trying to lay the idolization on too thick, but an average developer having any one of the above would likely be a multiplier in their career.
It's extremely unfeasible.
Taste is disagreeable.
Maybe Claude should not let me build a two-level type theory with just a "You're absolutely right!". In fact, now it will say "You're absolutely right, and it would be so amazing to use cubical types for blah blah", and adamantly defend it with several paragraphs of vomit.
I want a new language because current GPU (and really, parallel programming) languages are just not it. Also, I think we'd be better off if it weren't just CUDA dominating the developer experience.
Moreover, I feel that we should be embracing advanced type systems with AI. The past couple decades have shown that people do want advanced typing even without AI. And now we have stuff like "Lean is faster than Rust" (https://kim-em.github.io/blog/2026-7-24-why-lean-is-faster-t...).
Programming is hard. Programming when you can't just rely on the classic RAM model is harder. Parallel programming at scale on vector processors with small amounts of cache (and slow cache at that) is even harder. We can do better. Rust has already shown this for normal systems programming.
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.
Right now, I wrote a compiler that takes C and Rust code and compiles it to Lean. Then I have an LLM write a proof that the C and Rust code behave identically. I've been able to prove equivalent behavior for about ~70k lines of C code with pgrust.
The issue I've started to encounter is that the context needed for each incremental proof has kept growing, and things have slowed down dramatically. My hunch is that the speed is the time it takes to prove a line of code is on the order of O(n^2) of how much you've proved so far
I'm looking to see if there are ways to shard things so the required context scales better. Today I was going through the formal verification work Anthropic and Theorem published a few days ago, and it looks like they used some sort of orchestrator to manage all their proofs and ensure good clustering of similar code. I'm seeing if I can get an approach like that to work
It's just difficult enough that I think it's doable if done right. Half of me is debating if I should wait until the next model release because any improvement in model performance will help a ton
What if there are bugs in this C,Rust->Lean compiler? Anthropic are able to sidestep this by reasoning at the RISC V level for which its easier to develop a correct semantics.
fwiw, I wouldn't say working at the assembly level solves the problem. You now need to make sure that your definition of the assembly behavior is correct
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.
…And I think all of those can be considered forms of "ambition".
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.
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.
Now that custom software is cheap (if you can tolerate a bit of slop here and there), it seems like there's an opportunity to do some important things that weren't being done before because they're not profitable--and you can't get at those things by incrementally improving the old stuff, you need ambition.
AI could help making life a lot better in all these cases.
But yes, we should also aim higher in general.
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.
https://taktile.com/blog/property-based-testing-claude
wtf is up with the site.
"Universal acceptance" seems remarkably citation-free. AI cites back to Baymard which doesn't provide any actual published research article indicating the results.
Firefox's reader mode allow you to set the line length. If the reader-mode is able to understand the page it should be able to increase the length as well?
> "Universal acceptance"
Looking into it bit more I concede there's no real research consensus for optimal range in the 50-100 character range. I could not find research for the 180 char length this site render on my laptop screen at reasonable font size.
(Research indicate that bigger line spacing is beneficial for long lines though.)
I don't want to spend even tiniest amount of time for CSS or spend few cents with AI for it either.
This is similar to badly designed sites make you click more than once to get a job done while once click is enough. (as It'd force me to style around his crappy site)
I see someone posted justification of his decisions for such crappy site but I do not agree and ...
had an exact same visceral reaction as if I checked "trypophobia" related pics.
It's been formatted the same way since 2013.
https://danluu.com/slow-device#appendix-this-site-vs-sites-t...
https://twitter.com/danluu/status/1115707741102727168
Make a reliable and robust geometry kernel. People will pay thousands--or maybe millions for it.
In the guitar world, you can get really good (for most people) modelers that emulate a good amp sound for like 100 bucks, and for 10 times that you can get _excellent_ sound.
My expectation would be that for similar prices you could get really good synths as well by now.
I think this is simply because nobody knows an algorithm to create realistic piano sounds, etc. There are some good attempts, but they are paid and expensive. Hence my suggestion here.
Already made the geometry kernel. So far, nobody has offered me even like 20 dollars to license it yet, nevermind millions of dollars.
I'm sure the US, where most of AI runs, could also capture a lot of low hanging fruit.
It sucks that many providers are not able to be carbon neutral, but this should be solved by electricity providers. Not consumers.
In any case, I don't think the lack of caring about CO2 emissions is unique to AI. How many people care about Trump's war on green energy? Not many it seems.
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.
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://news.ycombinator.com/item?id=50218195
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 :(
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"
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?
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 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.
Do you still feel responsible for what you ship?
What about the copyright on your code?
Would you be ok with someone reverse engineering what you ship and then releasing their own version of the app?
I don't use LLMs the way that most folks do. I think a lot of people would laugh at the way I do it, but it's allowed me to retain a significant amount of control in the work, and I relinquish it very, very slowly. Everything that I've ever let go of has claw marks all over it. I have issues.
> Do you still feel responsible for what you ship?
Absolutely. If it has my chop, it's my ass on the line; no one else's. It's the way I was trained, and it's the way I worked; my entire career. I was a manager, for much of that career, and I got very used to standing behind the work of people smarter and more capable than I am, and refusing to condone bad work.
It doesn't matter how the stuff I ship gets there. It may be my own code, it may be a contracted pro, it may be an unpaid intern, it may be an LLM, it may be a howler monkey, banging on a typewriter.
If I sign off on it, and ship it, it's mine, and it's my responsibility to refuse to ship substandard crap (and I have seen a lot of substandard crap done by meat engines).
But that kind of attitude is considered "quaint," these days, and that's from long before LLMs were a broken rubber on the drug store shelf.
> Would you be ok with someone reverse engineering what you ship and then releasing their own version of the app?
Absolutely no problem. If they can do better, then more power to them, and I'll step out of the way. Might want to take a gander at the kind of stuff I write, and who I write it for. It's no secret.
I read every line and make sure it does exactly what I want it to do unless it is external plumbing, then I don't care.
> 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.
Bridges exist to move people and goods across water within a particular envelope of needs and constraints. In this specific case, when the needs grew, the most ambitious answer was not a bigger bridge, but BART's Transbay Tube, which is an entirely different kind of thing.
So when I reflect on Dan's piece, it seems we're in agreement that AI is not provoking us to simply build bigger versions of things we already have.. but what remains unsettled is whether we know what we’re really building for yet.
There's of course the by-now oft-repeated story of electrification of factories, which had a 'first pass' of mostly swapping out the steam engine with one big motor, and otherwise preserving the same layout. Over time people redesigned floor plans around small motors at each machine (with Paul David’s “The Dynamo and the Computer” being the classic telling of this).
A lot of AI-assisted software development right now still feels like the one-big-motor pass at this. I suspect the projects really worth being ambitious about are probably the ones that only make sense once the entire factory floor changes, and I don’t think we're able to see that just yet. What Dan's doing is probably the right answer at the moment, building a lot of odds things and seeing what sticks.
Back to the Bay story, I think this moment is equivalent to our digital glaciers melting, and the water rushing in, than us having to figure out better "cranes", for example. It's changing what the world we're designing for is, what the whole problem space is, instead of whether we build bigger versions of things within the prior paradigm.
We look to our software stack today and we are tempted to imagine 'bigger', 'better', 'faster', 'more efficient', but... why? What are we really building _for_? We shall see!
Happy 41st birthday Excel
[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
https://github.com/Jonahss/openav1
- Lovable alternative, but x6 cheaper https://peachjam.dev
Still, 6x cheaper is a good selling point I guess.
in the early days when we had shitty AI's, i reviewed all the code.
now i review a less code and more UI (I watch videos of random AI user journeys). It's exhausting but at least I am sure that users see what I intend for them to see on all devices that I want to support.
the website has grown quite complex. cloudflare, hetzner, supabase, openrouter. go codebase... I was originally a python ml engineer :'). anyway, it's a lot and I am doing my best to keep every surface reviewed.
target audience is non-devs. but I think even if you are a dev, you wouldn't be able to do this significantly cheaper than what peachjam costs. the costs are literal rock-bottom for the services, and hopping off peachjam is as easy as connecting your github and just pushing code via github.
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!
> 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.
He recently released an indie game using that very language using his own 3D engine. The reviews on Steam are Overwhelimgly Positive and sales have so far significantly exceeded expectations.
https://store.steampowered.com/app/499170/Order_of_the_Sinki...
There is so much software to still be built!
My website is a from scratch arcade room + added some roms to it
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
Bryan Cantrill: Andreessen’s Folly - The False Dichotomy of Software and Hardware https://www.youtube.com/watch?v=v0JjG0Qfwi8
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 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.
unfortunately though pgrust appears to be at best misleading, at worst vibeslop: https://github.com/ClickHouse/ClickBench/pull/2165 hacknews thread isn’t much prettier either https://news.ycombinator.com/item?id=50205816
```
.reading-container {
} ```Out of curiosity, what exactly is the constituency that's being address by not using css to format page content at all? It seems like a deliberate attempt to not use CSS at all; but then it does. Just not for actually formatting the page. Is this virtue signaling of some kind? And if so, what virtue is it signalling? Most curious.
"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.
Can you back this up? Our code is open source here[0]. You're free to audit it and benchmark it as much as you want. You'll find it's just as fast as we claim it is
[0] https://github.com/malisper/pgrust
the first commit has 400k files, the other two more than 1000 each, if you are going to ask others to audit this scale of ai generated code, can you tell us what you have done to audit it?
What I have seen is your Ai adding a lint test to make sure it doesn't cheat again. Are you personally aware of this file? How can you ensure it doesn't alter it and reinject the hand rolled benchmark queries? Will you be reviewing changes more thoroughly going forward?
https://github.com/malisper/pgrust/blob/38634b408dea373f3944...
transparency is the way to end the controversy, which appears to be sharing the full commit history based on HN responses
For clarity, I do not think you personally cheated or did anything nefarious. This is more another example in the "too much eyes free coding" columnar database.
You can run it with PGRUST_GRAVITY_REPORT=1 and it will log the codepath that was hit for every query
On the lint, yes, I'm aware. It's one layer of defense. When we were prepping for the 0.4-beta release, we generated a large number of fresh queries and made sure the engine runs them and performs well across all of them
You keep giving this same answer to no one's satisfaction. Saying go check the binary is worse than saying go audit 400k+ files. How do we know the Ai has not cheated in the code path logging? How do you know that it has not?
The more you make excuses, the more we get suspicious
> It's one layer of defense.
Needing to put in tests to make sure the Ai doesn't cheat is an interesting development in software development. I personally see it as a big red flag and evidence the machines are not going to replace human developers. It's categorically slop or the opposite of quality and care in development.
> 413,963 files changed
> +2,908,538
> -3,423,007
How is anyone supposed to audit that? I doubt you’ve looked at even a small fraction of the code, if any. Especially since this commit is two days after the second. Pure vibes.
And people still seem to believe they know what’s going on…
If you run it with PGRUST_GRAVITY_REPORT=1 it will report the code path hit for each query. You can see that all the queries go through the general query engine
The binary does contain hand-written kernels in the irprobe files. These were used for testing. You can validate that when running the benchmark, those files are dead code
The engine supports a narrow subset of SQL: scans, group-bys, filters, and sorting. That's enough to run ClickBench. It doesn't support e.g. subqueries which is why some of the follow up queries failed
You keep giving this same answer to no one's satisfaction. Saying go check the binary is worse than saying go audit 400k+ files. How do we know the Ai has not cheated in the code path logging? How do you know that it has not?
The more you make excuses, the more we get suspicious
(copied and pasted from another place you gave this unsatisfactory answer)
HN is waiting for the source code for pgrust 0.4-preview to be released, the version which allegedly cheated Clickhouse benchmark. So far, the people (person?) behind pgrust has not committed to releasing the offending code, and has instead offered other code (0.4-beta, not preview).
Maybe what's happened is that their bots reward hacked their way into special-casing the benchmarks without a proper audit from the humans involved, and now they're doing vibed damage control....
The project has tell tale signs of eyes free coding and ralph-like loops.
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.
Or since it mentions AI, this is his follow-up to Terry Winograd publishing Understanding Computers and Cognition. Mid-80s vibe, priceless.
(See also Hofstadter's law: It always takes longer than you expect, even when you take into account Hofstadter's law.)
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.
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
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)
Some of us have been taking this approach for literally years now.
ChatGPT isn’t 4yo yet. We’re just getting started
I did something like this before Ai, with CUE + Dagger wrapped in a small Go binary. One problem I have seen with Ai generated projects is that they hit a limit due to conditional complexity. They have a strong tendency to add more code (local optimizations, deep if-else nesting) for edge cases, rather than stepping back to think about how to simplify problem and code.
[1] https://github.com/bonisoft3/bayt
I have another thing in hof that is closer to this, also CUE + Dagger
https://github.com/hofstadter-io/hof/tree/_next/examples/env
https://github.com/hofstadter-io/hof/tree/_next/lib/env
I'm gearing up for a major rewrite into a new project, based on a bunch of learning and a desire to remove a ton of cruft that accumulated over 10+ years. I still debate if I want to wrap existing tools (tf, helm, etc...) or go for a full sail replacement. Dagger handles a lot of the tooling earlier in the CI process, mainly thinking CD here. Argo-* is our bain lately...
You might find the code gen aspects of hof interesting, I opted for Go's text/template, which you can also use from CUE if you wanted to have more literate (imo) code gen in your project.
However I don’t think anything using BuildKit is as fine grained as Bazel.
https://github.com/dagger/dagger/pull/11856
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
Maybe, as the creator of your own experience, you should be more ambitious to fit what you see into your tastes as well. This goes both ways.
We should be more ambitious in letting the browser software control the presentation according to the user’s preferences. This is not facetious. We should use the increased ease of building software to create software that is flexible, empowers the user, and accommodates different user preferences.
https://news.ycombinator.com/newsguidelines.html
By the way, I'm still waiting for Meta and Google do something about Instagram and Chrome so that my CPU usage doesn't go to the roof. They're front runners in the AI race, so it should be easy for them, right?
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...
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?