what did you ship?
Fixed small several bugs last week without even open the editor. It wrote tests that confirmed the bugs, then fixed them. Then I manually confirmed as well.
It built a double entry event log. A single application event produces two logs, one for the person doing the action, one for the person being acted upon.
For a nasty problem we have, we had AI prototype 2 different solutions. Then we reveiewed them as a team. We threw those out but it was very helpful input into our decision making.
so, basically did some vague, almost incomprehensible stuff. seems par for the course.
and my point is he is doing the hand-waving. i'm quite happy to hear success stories - we get so few concrete ones here.
https://hn.algolia.com/?query=working%20author%3Adavid927&so...
The obvious notable event circa 2024 was LLMs becoming reasonably useful for code assistance (IMO and IIRC OFC).
doesnt matter what subjective opinions are.
shipped is not pushing something on github.
Edit: I’ll add a caveat that I’d agree it was shipped if it’s making the author money even if they are the only user, but otherwise it all smells like dotcom era Pets.com level of selling a dollar for 99 cents and claiming it’s the future.
So evaluating software by "shipped or not" is just useless.
Since this is my thread, and since I am an exasperated freelancer who has made most of his post-dot-com career from writing exactly the kind of quite small, simple, unambitious, often internal things for smaller customers that nobody would confuse with anything cool, who is trying to understand how AI is going to make his life any better when it’s so opaque, fast moving, poorly documented and full of unverifiable claims battling unverifiable claims, let me assure you that the following question is not being asked in bad faith:
What did you ship?
I've just shipped a migration from our old auth service to the new one in a week, a migration that we've put off for three years because it would take the team months to finish.
I've shipped small side-projects that I'm the primary (and usually only) user of, but they now take me two days rather than weeks of effort and learning (e.g. https://www.writelucid.cc, https://pine.town, https://stavrobot.stavros.io, https://github.com/skorokithakis/dracula).
I've made changes in OSS apps that I just wouldn't have made otherwise (https://github.com/futo-org/android-keyboard/pulls/skorokith...), and even some closed-source ones (https://www.stavros.io/posts/adding-a-feature-to-a-closed-so...).
I've shipped hardware projects that would have taken me months of learning in a few days (https://www.stavros.io/posts/i-made-a-voice-note-taker/).
How's that?
I am quite interested in experimenting with it for migrations, because for example I have a set of sites written in older Nuxt and Vue and Buefy that need refreshing (and the frontend ported to that UI-agnostic Buefy replacement whose name escapes me at the moment but begins with “ou” I think). These migrations won’t happen any other way (small customers won’t pay for that) so I am open to whether tooling can reduce the cost I have to swallow. LLMs I have tested (including local models) seem to support the idea that this will be doable but I am a little out of the loop with the projects so I haven’t got back to this yet.
The hardware thing looks great; I am a sort of distracted maker and FreeCAD nerd but I often need a nudge to get started and I have found an LLM chat to help there a little bit (though it cannot answer some questions if I don’t have the specific vocabulary).
Writelucid is definitely cute.
I think you should not be put off talking about these things because whether people agree with you or not about whether they are important, they can at least measure against them.
I haven't found that LLMs help with CAD at all, but YMMV.
As for sharing here, the last time I shared something with "here's something I made with LLMs", the reply was "it shows", and that's just the latest instance. It just puts me off the whole thing.
It's more the microcontroller choice, broad components, all that.
The main areas I find LLMs struggle with research, I struggle with research too. I am a pretty solid researcher and I find it validating, in fact, to find that a more brute-force-trained thing is not better than me.
I see your point about the snarky reply; I must admit I have probably in the more distant past been somewhat snarky but I stopped commenting like that whenever I spot myself doing it because I know it is dispiriting.
(The other reply, re: early and late stages, is the kind of substantive question that lingers in my mind).
Anyway I just want to reiterate my thanks: I am sort of cynical about this, in that I believe the technologies may have their uses, but I have no time for the cult and the hype train, so it is nice to see anyone talking about actual things.
That’s not a sign of a healthy org. If you’re in a meeting it’s disrespectful not to be present. If you think a meeting is not useful you should reject it.
I have it code dsp techniques in journal articles I hand it. I have it create the unit tests, pipelines documentation. Then I manually verify the test cases aren't wrong and run the tests. If they pass it does what I wanted and I start looking at the code quality. It varies from being better than I could have done it to being objectively bad. I fix it if it needs fixing, then I'm done.
I have also pointed it at issues in our backlog and it usually finds the subtle logic errors underlying the behavior in the issue.
I haven't started and entire product from zero and shipped it. Mostly because I haven't started a new product since it was capable of that. But also because it has a scale beyond which I don't find it as useful. I have used it for an entire repo, but in the crates.io or npm scale of repo, not boost scale.
Which is basically a fancy calendar and team management system for my Valorant Premier team haha
It’s on my GitHub as operators-premier-manager but note it is not great: it serves its purpose which is to wrangle my team to show up for practice and scrims
I'm making a fairly simple game, a single player 2D roguelite strategy game. More context here: https://news.ycombinator.com/item?id=48886151
From an implementation perspective, it is about 80% complete, where by "complete", I mean "adequately polished such that I could ship it." (I'm not interested in providing evidence of my claim at this time, and you are welcome to not believe me.) Most of the remaining 20% are optional game modes I could choose to cut (and may, for gameplay reasons).
I do not contend that the code is excellent. But to whatever extent the code is "slop", that has not meaningfully inhibited the ongoing development or caused noticeable issues with the player experience.
The game is not especially ambitious, but it's something I would have been unable to create without genAI. The version of me that could have made it without genAI would have taken > 10x as long to get as far as I've gotten.
"Shipped" is a bit strong in my case, but I think this counts as something that isn't mere slop.
I get that it’s an early prototype and not all the design choices are made yet, but I struggle with “I can’t afford human-readable documentation yet”. Isn’t human readable documentation important for efficiently planning and deciding what you want to build? I feel like I can’t afford not to have human readable docs and plans while the project is taking shape
Related, if a user can prompt an agent to translate to a human-readable summary, wouldn’t it be better to just do this in place? Sure, models can deal with noisy LLM outputs but shouldn’t a document that’s easier for humans also be easier for bots?
Yes, it would probably be better to have something like that if you're struggling to plan and decide. In my particular case this has been a project that I have dreamt about and tinkered with for at least 15 years now. Most of the work I'm doing is just refinement of existing ideas what were already codified in other projects I've built.
Why don't I do this in place? The amount of churn is utterly incredible as ideas are refined and taken to the limit. These agents are getting quite good, but they regularly make the silliest of mistakes. You actually have to be extremely cautious about what you document because it often has a way of becoming "doctrine" to the agents. In fact, one of the most difficult parts of working on this project has been that the foundational properties cause the agents to lock down behavior WAY too early.
This is a frequent pattern among AI users. What causes it?
Given that you stated your readme is for bots, given that you expect our own AI to interpret it based on your evidence, how do I, as a human, go about evaluating this project without just writing it off as slop from the linked evidence?
What is the starting off point for a human, not an AI agent, to evaluate this?
And to be clear if the answer is to just download arbitrary code onto my machine and run it, that’s not good enough given the increase in attacks from AI projects and fake recruiters telling you to just run it bro. I’ve already had to pass on multiple interviews despite being unemployed because the human/ai on the other side demanded root access or for me to run arbitrary code onto my machine as part of their process.
That said, the maths library might just be the best thing to start with because it's mostly stable, relatively simple, and virtually every other part of the project depends on it in some way. If graphics are more your jam then maybe check out the SDF VM project and associated documents. All rendering goes through a single instruction set that is implemented via a shader pipeline that allows arbitrary scenes to be defined without shader recompilation. The project is essentially multiple compilers wearing a trench coat so there's a little bit of something for everyone... like two fully implemented emulators of the brick variety, including peripherals.
If you're adventurous and want to have your favorite LLM give the project a review in a sandbox then I think that'd be neat! Especially considering that they would have absolutely no problem driving everything themselves through STDIN. Though I totally understand if that's not something you're keen on doing considering the state of things today. Either way, cheers!
I think it's because it makes them seem...smarter? More technical? But they can't describe who it's for or what the actual design is without consulting an AI.
https://github.com/ByteTerrace/Puck/blob/main/src/Puck.Maths...
Some of us aren't just slopping it up like @theo and all the other AI influencers are, as I developed nearly every single line of this by hand over the span of the past decade. Agents recently became capable of factchecking it and helped find bugs that my other unit testing never caught. Software engineering has never been more alive!
https://gist.github.com/Kittoes0124/6827d08e457c1c8b790422af...
This is a snippet I wrote years ago to help me study different formulations of the equation ((1 + √5) / 2). There was this thing I could "see" in there that would allow me index into these sequences, and whole families of others, in O(1) time. The problem is that I still don't know enough maths to derive the exact object that I want from the nonsense that I have.
https://github.com/ByteTerrace/Puck/blob/main/src/Puck.Maths...
This is the reformulation of that snippet into a proper object, distilled using Fable and Sol. Unlike BinaryIntegerFunctions, I didn't write a line of this and I'm quite happy with that. It's been a slog for so long... being able to let these agents toil away at all the off-by-one type noise is just nice. I get to focus on an actual product for once instead of manufacturing every single nut and bolt myself.
A form of recursion is also doing a lot of heavy lifting because the emulators are their own separate deterministic engines that are dynamically plumbed into the primary loop. This not only allows us to embed diegetic devices (as in, you can literally pick up a glowing brick in the world, hold it to your face, and play it), but also validates that the primary loop is coded accurately because the outer loop runs at X Hz while humble bricks must run at ~59.7275 Hz. Pacing inaccuracies in the main loop cause us to fail the brick suites that we test against. This concept of having features reinforce one another is applied as often as possible.
The obsession with determinism goes so far that both the DirectX and Vulkan backends are validated against each other for pixel level differences. If they differ more than the expected maximum then code is refactored until the drift is back within acceptable range.
https://claude.ai/code/artifact/382aee8a-3a3b-4cf8-801f-3ddb...