With every new model I've been attempting to build something that takes at least 1 month and really pushes the model. So far I've done:
- Python interpreter in Rust (fail): https://github.com/BlueBlazin/pyrs
- Low-poly Google Earth like engine (success): https://github.com/BlueBlazin/lowpolyearth
- Codebase -> 2d infinite-zoom visualization (success): https://github.com/BlueBlazin/blockviz
I have never understood or liked all the obsession with one-shot builds.
Iâve also been exploring a visual way to understand a code base and have explored turning it into a virtual city.
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.
I used Fable 5.1 and Opus 5.5 to build a Python interpreter in Rust. Appears to pass all the 3.12 code I throw at it.
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.
> I've been attempting to build something that ... pushes the model ... never understood ... one-shot builds
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)
Yes! I absolutely have! And I've been thinking a lot lately about how to prevent them from collapsing into this state. It is getting better with newer and better models though. But yes, there comes a point when the codebase size and complexity crosses a threshold and we enter a churn state with very little progress.
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?
Have you seen this with Opus 5.5?
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.
I just have it constantly update real-world analogues for keeping track of everything. I have it create guides, note cards, flowcharts, running to-do lists, etc. with every change.
It helps us keep track of things, why not AI, too?
> How can we teach "systems thinking" to a model?
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.
I get what the author is saying, but his examples like "a ripgrep fork that ... is faster for my codex ripgrep workloads" don't strike me as particularly ambitious.
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.
you don't like the ads, gambling apps, and similar? /s
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?
Holy non-sequitur...
I'm all about ending user tracking, targeted advertising, and gambling. We'll need to find new things to work on that do not use big data to take advantage of our fellow humans.
One major obstacle is developers have either encountered or created entire ecosystems of problems they can't solve that get inherited whenever and wherever software is introduced. Proposing to add evergreen issues around security, data entry and retention, connectivity, vendor lock-in, and update cycles is frequently a shitty trade for whatever notional (often fictional) productivity improvement is being proposed by injecting software into a workflow.
The best software is no software at all.
Do you mean something like "smart" appliances?
We should be more ambitious, but we need to learn how we can be ambitious with AI, and what value we can create.
AI can take us from 0 to MVP in a prompt. It can fill in gaps of knowledge and allows someone who knows half of the stack to build the whole thing nearly seamlessly. These are superpowers but don't by themselves lead to new products.
What AI cannot do is remove the world of complications that happen after the MVP - product feature tradeoffs and choices, how to handle integrations and customizations, how to serve multiple types of users, how to communicate and market the app, how to handle security and data storage, how to deal with customers and bugs, etc. All of these need to be considered and acted on by a human in some fashion. AI can help with each concern but can't solve them without understanding the concern and determining how to frame it in a prompt.
This is why we have a glut of amazing demos that go nowhere while we figure out how to build software differently. This will take some time and I imagine the result will be software heavily-structured with a bit of AI reasoning woven throughout, not an army of agents and sub-agents burning infinite tokens.
I haven't yet seen any significant products made with AI that are at least used long-term. All these browser demos, from the Adobe killers to Star Citizen, are just bells and whistles that I close after 30 seconds of use.
I enjoy this quote from Antoine de Saint-Exupéry:
"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.
Right, but this is the most hopeful imaginable prediction: AI accelerates everything, but everything good is still mediated through taste and expertise, so being a (say) skilled systems engineer is important and rewarding, just with all the tedium distilled out of it.
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).
Thatâs something that I have been thinking about for a while now. Even prior to LLMs, many large companies have essentially been iterating on the same half a dozen ideas over and over again and there doesnât seem to be much new coming out even post LLMs.
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.
I have yet to see LLMs do well âautonomouslyâ on anything that doesnât fall into any of these 3 buckets:
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.
Honestly I think you're on to something, as by far the most novel and interesting use cases I've seen for LLMs in general are mostly around reverse engineering things, especially if you can hit it with Ghidra, but honestly anything that can feed some sort of data and control back to a model.
> the software industry was already nearing its economic maturity
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.
> but everything good is still mediated through taste and expertise
I'm reminded of https://archive.ph/a9Cli (ns;nt)
Agreed. Been experiencing this firsthand with an app I've been building myself. Vibecoded a working prototype ridiculously fast but then came the optimization issues. Since mine is very hardware dependent every different brand, oem stack, processor, video card, and every little thing changes how my app functions and a lot of it isnt even documented properly. Now AI is still very useful here, but you actually need to know what even to ask and fix in the first place
My interpretation of "be more ambitious" is not only give it harder problems, but be more creative about what you ask. The problem is that most of the MVPs that people ask for a boring and lame. AI can help us make things that blow your mind, things that we would never build because they don't make sense, but the cost models for code generation have changed.
This statement stood out to me.
> 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
> 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.
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.
> "this error is getting swallowed, make sure the real termination message exposes the root cause"
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 don't disagree.
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...
I think you're misunderstanding where in the process that prompt got made.
I used Opus 5.5 to figure out that a language model we were serving at work for internal use (we don't really serve models, we only use this internally because it processes sensitive data that we can't send to external endpoints) was being bottlenecked by CPU contention on tokenization, by having Opus run in an autoresearch style loop.
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.
LLMs are great for being nerdsniped. I started work on walshadow (reading pg wal into clickhouse) to demonstrate the project's infeasibility, but pieces started coming together into something reasonable & order of magnitude faster
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
Agreed.
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.
Those were exactly my thoughts when deciding to write a new JS engine [1] written from scratch.
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).
> from scratch
Beg to differ.
Building a procedural open world at the scale of a flight sim in UE5, in a month wrote 5k prompts, spent 40B tokens and will likely take at least a trillion more over the next year of full time dev work.
Big solo projects exist, they're just not coming out as frequently because of, uh, how time works
In the spirit of the latter, here's mine!
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.
>In the spirit of the latter, here's mine!
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.
To play devil's advocate, that sounds like the sort of uncomplicated thing that you could've manually vibecoded in 2020 without an LLM. What changed is that the LLM doesn't let you get analysis paralysis.
It makes me feel actually sick that so many people can't separate their positive feelings about AI from people's misery (it must simply be "complaining"), and vice versa. As if both things can't exist, for some reason. It's a common tribalism problem, but it's been kicked up a hundredfold by AI.
Exactly. I feel both feelings simultaneously.
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.
Precisely. I have both feelings simulataneously. I am impressed by what it can do and horrified because I realize what it will do to the job market and society in general. Meanwhile everybody seems to believe that AI will cure cancer and therefore we should let it do all the damage it will do without realizing that people will die because of AI as well (in fact have already died because of AI).
Hyperbole much? If you are serious, then what cohort of people are dying more per million, than before 2025?
[dead]
Despair is not a tribe.
if the complaints can be properly pointed at the actual problem - the corporate culture the complainers are actively upholding or the capitalist system at large, id be much more sympathetic
its a tribalism problem, but one of trying to uphold the current tribe system while theres a pretty obvious new tribe system replacing it
I'm not trying to uphold any tribe I just want to feel secure in my job. :/
AI has taken that security away from me
I find posts like this interesting because it seems to show the true bottleneck which is good ideas. Faster regex is cool but is it ambitious?
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.
ideas can be make-or-break but it's much more common that execution is the bottleneck, and AI is the king of high-speed low-quality execution. High-quality execution can only come from running a human feedback loop through a huge number of iterations.
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?
Make a synthesizer that can accurately recreate all orcastra instruments convincingly. People will pay hundreds of dollars for it--maybe thousands.
Make a reliable and robust geometry kernel. People will pay thousands--or maybe millions for it.
Get a daily email with the the top stories from Hacker News. No spam, unsubscribe at any time.