this post was submitted on 28 Sep 2025
280 points (95.5% liked)
Comic Strips
19484 readers
792 users here now
Comic Strips is a community for those who love comic stories.
The rules are simple:
- The post can be a single image, an image gallery, or a link to a specific comic hosted on another site (the author's website, for instance).
- The comic must be a complete story.
- If it is an external link, it must be to a specific story, not to the root of the site.
- You may post comics from others or your own.
- If you are posting a comic of your own, a maximum of one per week is allowed (I know, your comics are great, but this rule helps avoid spam).
- The comic can be in any language, but if it's not in English, OP must include an English translation in the post's 'body' field (note: you don't need to select a specific language when posting a comic).
- Politeness.
- AI-generated comics aren't allowed.
- Adult content is not allowed. This community aims to be fun for people of all ages.
Web of links
- !linuxmemes@lemmy.world: "I use Arch btw"
- !memes@lemmy.world: memes (you don't say!)
founded 2 years ago
MODERATORS
you are viewing a single comment's thread
view the rest of the comments
view the rest of the comments
This reads like someone who has heard of these general concepts but doesn’t understand them.
But then again, I just imagined trying to be 100% accurate while still being concise, and I don’t think it’s possible.
It’s also not really clear what the dynamic is supposed to be here. Is the LLM supposed to be invoking the generated code through a separate entry point like a test suite, or is the developer launching the built app with a debugger attached and feeding a prompt to the LLM whenever an exception is thrown?
Neither one of those would really be “attaching a debugger to the LLM” though, and in either case it would be interpreting the output not the input.
So, as usual this might be a translation issue, but I wasn't aware that an attachment has a direction. The debugger would obviously feed its output to the llm in this scenario, so the two things are attached to each other in the sense of the word that I got from a dictionary. As the debugger gives a filename as well, feeding the files contents as well, asking for improvements and overwriting the original file would be trivial, so automating it should be easy enough. Attachment was meant here only in the sense of "well, they're connected and data goes from a to b".
Would such a setup make sense? Not really. But you know, that's why it's a four-panel-comic and not some overrated ai startup. Or maybe it is, it seems like making sense isn't really a requirement for tech startups anymore.
Ah. Definitely a translation issue. I didn’t realize there was a translation involved. Or that you were the author. I wouldn’t have been so critical otherwise. You’re doing great.
“Attachment” in general doesn’t have a direction, but in the context of “attach debugger”, it does, because the target of the attachment is the process you want to inspect. In this case, the process is the code you’re writing, not the LLM helping you write it.
No worries, and please remain critical.
So, yeah, my mother tongue is German, so the English texts may be a little bumpy here or there. I feel confident enough with my English but that doesn't change the fact that it's a secondary language for me and this is not really a professional project where I could pay some natively English speaking nerd to fix my mistakes.
That said I'm aware how debuggers attach to the processes they're analysing, I just wasn't aware that this would turn the word exclusive if used in this context. Thanks for bringing it up though! Learned something!
Yeah, that's the technical lingo meaning. Attach a debugger means that you have a running process without a debugger running with it, and then you attach the debugger to it to get debug output from that process.
But I still don't quite get the intended process.
So you run the code the LLM outputs with a debugger and let the LLM interact with the debugger? Not really sure if that helps, because for the LLM would need to know how to operate the debugger and would need to understand what problems it should be looking for.
Current systems (e.g. Github Copilot) combine the LLM with static code analysis and compiler outputs to find and fix errors. They can also execute the code and run tests and compare outputs with expected outputs.
Am I misunderstanding something or does this sound like programmers making themselves unnecessary?