llm/5888b8dc-b96e-4444-9c3c-465dde409e92/batch-1-bf92714c-eef7-4e11-a7eb-f2d0f5ec8f1a-input.json
You are a comment classifier. Given a list of topics and a batch of comments, assign each comment to up to 3 of the most relevant topics.
TOPICS (use these 1-based indices):
1. AI productivity claims skepticism
2. Joy of programming vs shipping products
3. Skill atrophy concerns with AI
4. Experienced vs inexperienced developer AI gains
5. Web development complexity is optional
6. Code review burden with AI
7. Vibe coding quality concerns
8. Learning while using LLMs
9. Time-constrained developers benefiting
10. AI for boilerplate and scaffolding
11. Frontend framework fatigue
12. Managing AI like junior developers
13. Return to simpler web stacks
14. AI as autocomplete evolution
15. Side project enablement
16. Technical debt from AI code
17. Cost and pricing of AI tools
18. Pattern recognition and code quality
19. Parenting and hobby coding time
20. AI hallucinations and reliability
COMMENTS TO CLASSIFY:
[
{
"id": "46497643",
"text": "> The difference is whether or not you find computers interesting and enjoy understanding how they work.\n\nI'm a stereotypical nerd, into learning for its own sake.\n\nI can explain computers from the quantum mechanics of band gaps in semiconductors up to fudging objects into C and the basics of operating systems with pre-emptive multitasking, virtual memory, and copy-on-write as they were c. 2004.\n\nFurther up the stack it gets fuzzy (not that even these foundations are not; \"basics\" of OSes, I couldn't write one); e.g. SwiftUI is basically a magic box, and I find it a pain to work with as a result.\n\nLLM output is easier to understand than SwiftUI, even if the LLM itself has much weirder things going on inside."
}
,
{
"id": "46498282",
"text": "So, can you tell me everything that happens after you type www.google.com<RET> into the browser? ;)"
}
,
{
"id": "46498495",
"text": "Nope, but that was the example I had in mind when I chose my phrasing :)\n\nI think I can describe the principles at work with DNS, but not all of how IP packets are actually routed; the physics of beamforming and QAM, but none of the protocol of WiFi; the basics of error correction codes, but only the basics and they're probably out of date; the basic ideas used in private key crypto but not all of HTTPS; I'd have to look up the OSI 7-layer model to remember all the layers; I understand older UI systems (I've even written some from scratch), but I'm unsure how much of current web browsers are using system widgets vs. it all being styled HTML; interrupts as they used to be, but not necessarily as they still are; my knowledge of JavaScript is basic; and my total knowledge of how certificate signing works is the conceptual level of it being an application of public-private key cryptography.\n\nI have e.g. absolutely no idea why Chrome is famously a memory hog, and I've never learned how anything is scheduled between cores at the OS level."
}
,
{
"id": "46491787",
"text": "I think a lot of us just discovered that the actual programming isn't the fun part for us. It turns out I don't like writing code as much as I thought. I like solving my problems. The activation energy for a lot of things was much higher than it is now. Now it's pretty low. That's great for me. Baby's sleeping, 3d printer is rolling, and I get to make a little bit of progress on something super quick. It's fantastic."
}
,
{
"id": "46491910",
"text": "This 1000x!\n\nI had a bit of an identity crisis with AI first landed and started producing good code. “If I’m not the man who can type quickly, accurately, and build working programs… WHO AM I?”\n\nBut as you pointed out, I quickly realized I was never that guy. I was the guy who made problems go away, usually with code.\n\nNow I can make so many problems go away, it feels like cheating. As it turns out, writing code isn’t super useful. It’s the application of the code, the judgement of which problems to solve and how to solve them, that truly mattered.\n\nAnd that sparks a LOT of joy."
}
,
{
"id": "46491909",
"text": "Exactly. And I was never particularly good at coding, either. Pairings with Gemini to finally figure out how to decompile an old Java app so I can make little changes to my user profile and some action files? That was fun! And I was never going to be able to figure out how to do it on my own. I had tried!"
}
,
{
"id": "46494306",
"text": "Fewer things sound less interesting to me than that."
}
,
{
"id": "46494336",
"text": "Fair enough. But that particular could be anything that has been bothering you but you didn’t have the time or expertise to fix yourself.\n\nI wanted that fixed, and I had given up on ever seeing it fixed. Suddenly, in only two hours, I had it fixed. And I learned a lot in the process, too!"
}
,
{
"id": "46494331",
"text": "> Fewer things sound less interesting to me than that.\n\nTo each their own! I think the market for folks who understand their own problems is exploding! It’s free money."
}
,
{
"id": "46496634",
"text": "Literally shipping a vide-coded feature as my baby sleeps, while reading this comment thread. It's the wild west again. I love it."
}
,
{
"id": "46500117",
"text": "Maybe you can tell us the name of the software so we can avoid it?"
}
,
{
"id": "46502210",
"text": "Google, Facebook, Amazon, Microsoft....they literally all have the vibe coded code; it's not about vibe coded or not, it is about how well the code is designed, efficient and bug free. Ofc pro coders can debug it and fix it better than some amateur coder but still LLMs are so valuable. I let Gemini vibe code little web projects for me and it serves me well. Although you have to explain everything step by step to it and sometimes when it fixes one bug, it accidently introduces another. But we fix bugs together and learn together. And btw when Gemini fixes bugs, it puts comments in the code on how the particular bug was fixed."
}
,
{
"id": "46493263",
"text": "This. Busy-beavering is why the desktop Linux is where it is - rewriting stuff, making it \"elegant\" while breaking backwards compatibility - instead of focusing on the outcome."
}
,
{
"id": "46493911",
"text": "macOS breaks backwards compatibility all the time, and yet..."
}
,
{
"id": "46497762",
"text": "Other than security-related changes, as a user, I find macOS to be quite generous about its evolution, supporting deprecated APIs for many years, etc.\n\nSIP and the transition to a read-only system volume are the only two things that I remember broke things that I noticed.\n\nIt’s not Windows-level of backwards compatibility, but it’s quite good overall from the user side."
}
,
{
"id": "46491301",
"text": "It's just fun in a different way now. I've long had dozens of ideas for things I wanted to build, and never enough time to really even build one of them. Over the last few months, I've been able to crank out several of these projects to satisfactory results. The code is not a beautiful work of art like I would prefer it to be, and the fun part is no longer the actual code and working in the code base like it used to be. The fun part now is being able to have an app or tool that gets the job I needed done. These are rarely important jobs, just things that I want as a personal user. Some of them have been good enough that I shipped them for other users, but the vast majority are just things I use personally.\n\nJust yesterday for example, I used AI to build a GTK app that has a bunch of sports team related sound effects built into them. I could have coded this by hand in 45 minutes, but it only took 10 minutes with AI. That's not the best part though. The best part is that I was able to use AI to get it building into an app image in a container so I can distribute it to myself as a single static file that I can execute on any system I want. Dicking with builds and distribution was always the painful part and something that I never enjoyed, but without it, usage is a pain. I've even gone back to projects I built a decade ago or more and got them building against modern libraries and distributed as RPMs or app images that I can trivially install on all of my systems.\n\nThe joy is now in the results rather than the process, but it is joy nonetheless."
}
,
{
"id": "46491665",
"text": "I think, for a lot of people, solving the problem was always the fun part.\n\nThere is immense pleasure in a nice piece of code - something that is elegant, clever and simple at the same time.\n\nGrinding out code to get something finished - less fun…"
}
,
{
"id": "46493276",
"text": "It depends. Sometimes they joy is in discovering what problem you are solving, by exploring the space of possibilities on features and workflows on a domain.\n\nFor that, having elegant and simple software is not needed; getting features fast to try out how they work is the basis of the pleasure, so having to write every detail by hand reduces the fun."
}
,
{
"id": "46494323",
"text": "Sounds like someone who enjoys listening to music but not composing or performing music."
}
,
{
"id": "46501293",
"text": "Or someone who enjoys playing music but not building their own instrument from scratch."
}
,
{
"id": "46494458",
"text": "Or maybe someone DJing instead of creating music from scratch."
}
,
{
"id": "46493260",
"text": "I use LLMs for code at work, but I've been a bit hesitant to dive in for side projects because I'm worried about the cost.\n\nIs it necessary to pay $200/mo to actually ship things or will $20/mo do it? Obviously I could just try it myself and see how far I get bit I'm curious to hear from someone a bit further down the path."
}
,
{
"id": "46493358",
"text": "The $20/mo subscription (Claude Code) that I've been using for my side projects has been more than enough for me 90% of the time. I mostly use the cheaper models lately (Haiku) and accept that it'll need a bit more intervention, but it's for personal stuff and fun so that's ok. If you use VSCode, Antigravity or another IDE that's trying to market their LLM integration, then you'll also get a tiny allowance of additional tokens through them.\n\nI'll use it for a few hours at a time, a couple days a week, often while watching TV or whatever. I do side projects more on long rainy weekends, and maybe not even every week during the summer. I'll hit the limit if I'm stuck inside on a boring Sunday and have an idea in my head I really wanted to try out and not stop until I'm done, but usually I never hit the limit. I don't think I've hit the limit since I switched my default to Haiku FWIW.\n\nThe stat's say I've generated 182,661 output tokens in the last month (across 16 days), and total usage if via API would cost $39.67."
}
,
{
"id": "46497687",
"text": "$20 is fine. I used a free trial before Christmas, and my experience was essentially that my code review speed would've prevented me doing more than twice that anyway… and that's without a full time job, so if I was working full time, I'd only have enough free time to review $20/month of Claude's output.\n\nYou can vibe code, i.e. no code review, but this builds up technical debt. Think of it as a junior who is doing one sprint's worth of work every 24 hours of wall-clock time when considering how much debt and how fast it will build up."
}
,
{
"id": "46494367",
"text": "Depending on how much you use, you can pay API prices and get pretty far for 20 bucks a month or less. If you exhaust that, surprisingly, I recommend getting Gemini with the Google AI pro subscription. You can use a lot of the Gemini CLi for that"
}
,
{
"id": "46495944",
"text": "Check out the Google One AI Pro plan ($20/mo) in combination with Antigravity (Google's VS Code thingy) which has access to Opus 4.5. this combo (AG/AI Pro plan/Opus 5.5) is all the rage on Reddit with users reporting incredibly generous limits (which most users say they never meet even with high usage) that resets every 5 hours."
}
,
{
"id": "46494505",
"text": "I have a feeling you are using SOTA models at work and aren't used to just how cheap the non-Anthropic/Google/OAI options are these days. GLM's coding subscription is like $6/month if you buy a full year."
}
,
{
"id": "46493386",
"text": "You can use AI code editor that allows you to use your own API key, so you pay per-token, not a fixed monthly fee. For example Cline or Roo Code."
}
,
{
"id": "46493926",
"text": "They all let you do that now, including Claude Code itself. You can choose between pay per token and subscription.\n\nWhich means that a sensible way to go about those things is to start with a $20 subscription to get access to the best models, and then look at your extra per-token expenses and whether they justify that $200 monthly."
}
,
{
"id": "46497495",
"text": "In practice, I find it depends on your work scale, topic and cadence.\n\nI started on the $20 plans for a bit of an experiment, needing to see about this whole AI thing. And for the first month or two that was enough to get the flavor. It let me see how to work. I was still copy/pasting mostly, thinking about what to do.\n\nAs i got more confident i moved to the agents and the integrated editors. Then i realised i could open more than one editor or agent at a time while each AI instance was doing its work.\n\nI discovered that when I'm getting the AI agents to summarise, write reports, investigate issues, make plans, implement changes, run builds, organise git, etc, now I can alt-tab and drive anywhere between 2-6 projects at once, and I don't have to do any of the boring boiler plate or administrivia, because the AI does that, it's what its great for.\n\nWhat used to be unthinkable and annoying context switching now lets me focus in on different parts of the project that actually matter, firing off instructions, providing instructions to the next agent, ushering them out the door and then checking on the next intern in the queue. Give them feedback on their work, usher them on, next intern. The main task now is kind of managing the scope and context-window of each AI, and how to structure big projects to take advantage of that. Honestly though, i don't view it as too much more than functional decomposition. You've still got a big problem, now how do you break it down.\n\nAt this rate I can sustain the $100 claude plan, but honestly I don't need to go further than that, and that's basically me working full time in parallel streams, although i might be using it at relatively cheap times, so it or the $200 plan seems about right for full time work.\n\nI can see how theoretically you could go even above that, going into full auto-pilot mode, but I feel i'm already at a place of diminishing marginal returns, i don't usually go over the $100 claude code plan, and the AIs can't do the complex work reliably enough to be left alone anyway. So at the moment if you're going full time i feel they're the sweet spot.\n\nThe $20 plans are fine for getting a flavor for the first month or two, but once you come up to speed you'll breeze past their limitations quickly."
}
,
{
"id": "46491377",
"text": "I think this is showing the difference between people who like to /make/ things and those that like to make /things/. People that write software because they see a solution for a problem that can be fixed with software seem to benefit the most of LLM technology. It's almost the inverse for the people that write software because they like the process of writing software."
}
,
{
"id": "46491475",
"text": "Surely there has to be some level of \"getting stuff done\"/\"achieving a goal\" when /making/ things, otherwise you'd be foregoing for-loops because writing each iteration manually is more fun."
}
,
{
"id": "46492008",
"text": "I think you misunderstand the perspective of someone who likes writing code. It's not the pressing of keys on the keyboard. It's figuring out which keys to press. Setting aside for the moment that most loops have a dynamic iteration count, typing out the second loop body is not fun if it's the same as the first.\n\nI do code golf for fun. My favorite kind of code to write is code I'll never have to support. LLMs are not sparking joy. I wish I was old enough to retire."
}
,
{
"id": "46492398",
"text": "I have a 10-year-old side project that I've dumped tens of thousands of hours into. \"Ship the game\" was an explicit non -goal of the project for the vast majority of that time.\n\nSometimes, the journey is the destination."
}
,
{
"id": "46493093",
"text": "And sometimes the destination is the destination and the journey is a slog."
}
,
{
"id": "46493138",
"text": "I mean, sure. I was just pointing out to the commentor that sometimes \"getting stuff done\" isn't the point."
}
,
{
"id": "46491585",
"text": "Sure, but, in the real world, for the software to deliver a solution, it doesn't really matter if something is modelled in beautiful objects and concise packages, or if it's written in one big method. So for those that are more on the making /things/ side of the spectrum, I guess they wouldn't care if the LLM outputs code that has each iteration written separately.\n\nIt's just that if you really like to work on your craftsmanship, you spend most of the time rewriting/remodelling because that's where the fun is if you're more on the /making/ things side of the spectrum, and LLMs don't really assist in that part (yet?). Maybe LLMs could be used to discuss ways to model a problem space?"
}
,
{
"id": "46491856",
"text": "I like both the process and the product, and I like using LLMs.\n\nYou can use LLMs in whatever way works for you. Objections like the ones in this thread seem to assume that the LLM determines the process, but that’s not true at present.\n\nPerhaps they’re worrying about what might happen in future, but more likely they’re just resisting change in the usual way of inventing objections against something they haven’t seriously tried. These objections serve more as emotional justifications to avoid changing, than rational positions."
}
,
{
"id": "46493716",
"text": "As I've gotten more experience I've tended to find more fun in tinkering with architectures than tinkering with code. I'm currently working on making a secure zero-trust bare metal kubernetes deployment that relies on an immutable UKI and TPM remote attestation. I'm making heavy use of LLMs for the different implementation details as I experiment with the architecture. As far as I know, to the extent I'm doing anything novel, it's because it's not a reasonable approach for engineering reasons even if it technically works, but I'm learning a lot about how TPMs work and the boot process and the kernel.\n\nI still enjoy writing code as well, but I see them as separate hobbies. LLMs can take my hand-optimized assembly drag racing or the joy of writing a well-crafted library from my cold dead hands, but that's not always what I'm trying to do and I'll gladly have an LLM write my OCI layout directory to CPIO helper or my Bazel rule for putting together a configuration file and building the kernel so that I can spend my time thinking about how the big pieces fit together and how I want to handle trust roots and cold starts."
}
,
{
"id": "46493763",
"text": "So much this. The act of having the agent create a research report first, a detailed plan second, then maybe implement it is itself fun and enjoyable. The implementation is the tedious part these days, the pie in the sky research and planning is the fun part and the agent is a font of knowledge especially when it comes to integrating 3 or 4 languages together."
}
,
{
"id": "46497819",
"text": "This goes further into LLM usage than I prefer to go. I learn so much better when I do the research and make the plan myself that I wouldn’t let an LLM do that part even if I trusted the LLM to do a good job.\n\nI basically don’t outsource stuff to an LLM unless I know roughly what to expect the LLM output to look like and I’m just saving myself a bunch of typing.\n\n“Could you make me a Go module with an API similar to archive/tar.Writer that produces a CPIO archive in the newcx format?” was an example from this project."
}
,
{
"id": "46502532",
"text": "Yeah, this is a lot of what I'm doing with LLM code generation these days: I've been there, I've done that, I vaguely know what the right code would look like when I see it. Rather than spend 30-60 minutes refreshing myself to swap the context back into my head, I prompt Claude to generate a thing that I know can be done.\n\nMuch of the time, it generates basically what I would have written, but faster. Sometimes, better, because it has no concept of boredom or impatience while it produces exhaustive tests or fixes style problems. I review, test, demand refinements, and tweak a few things myself. By the end, I have a working thing and I've gotten a refresher on things anyway."
}
,
{
"id": "46494388",
"text": "Something happened to me a few years ago. I used to write code professionally and contribute to open source a lot. I was freelancing on other people's projects and contributing to mature projects so I was doing hard work, mostly at a low level (I mean algorithms, performance fixes, small new features, rather than high level project architecture).\n\nI was working on an open source contribution for a few days. Something that I struggled with, but I enjoyed the challenge and learned a lot from it.\n\nAs it happened someone else submitted a PR fixing the same issue around the same time. I wasn't bothered if mine got picked or not, it happens. But I remember looking at how similar both of our contributions were and feeling like we were using our brains as computers, just crunching algorithms and pumping in knowledge to create some technical code that was (at the time) impossible for a computer to create. This stayed with me for a while and I decided that doing this technical algorithm crunching wasn't the best use of my human brain. I was making myself interchangeable with all the other human (and now AI) code crunchers. I should move on to a higher level, either architectural or management.\n\nThis was a big deal for me because I did love (and still do) deeply understanding algorithms and mathematics.\n\nI was extremely fortunate with timing as it was just around one year before AI coding became mainstream but early enough that it wasn't a factor in this shift. Now an AI could probably churn out a decent version of that algorithm in a few minutes.\n\nI did move on to open my own business with my partner and haven't written much code in a few years. And when I do now I appreciate that I can focus on the high level stuff and create something that my business needs in a few hours without exhausting myself on low level algorithm crunching.\n\nThis isn't meant to put down the enjoyment of writing code for code's sake. I still do appreciate well written code and the craft that goes into it. I'm just documenting my personal shift and noting that enjoyment can be found on both sides."
}
,
{
"id": "46492345",
"text": "I’ve got kids and so seldom find myself with the time or energy to work on something. Cursor has really helped in that regard.\n\nI have an extensive media collection of very large VR video files with very unhelpful names. I needed to figure out a good way to review which ones I wanted to keep and discard (over 30TB, almost 2000 files). It was fun sitting using Cursor with Claude to work on setting up a quick web UI, with calls out to ffmpeg to generate snapshots. It handled the “boring parts” with aplomb, getting me a html page with a little JavaScript to serve as my front end, and making a super simple API. All this was still like 1000 lines and would have taken me days, or I would have copied some boilerplate then modified it a little.\n\nThe problems Claude couldn’t figure out were also similarly interesting, like its syntax to the ffmpeg calls were wrong and not skipping all the frames we didn’t want to generate, so it was taking 100x longer to generate than was necessary seeking through every file, then I made some optimizations in how I had it configured, then realizing I’d generated thumbnails for 3 hours only for them to not display well on the page as it was an 8x1 tile.\n\nAt that point Claude wanted to regenerate all the thumbnails and I said “just display the image twice, with the first half displayed the first time and the second half displayed the second time, saving myself a few hours. Hacky, but for a personal project, the right solution.\n\nI still felt like I was tinkering in a way I haven’t in awhile, and a project that I’d never have gotten around to and instead have just probably bought another new hard drive, took me a couple hours, most of which was actually marking the files as keep or delete. I ended up deleting 12TB of stuff I didn’t want, which it felt cool to write myself a bespoke tool rather than search around on the off chance that such a thing already exists.\n\nIt also gave me a mental framework of how to approach little products like this in the future, that often a web ui and a simple API backend like Node making external process calls is going to be easier than making a full fat windows UI.\n\nI have a similarly sized STL library from 3D printing and think I could apply mostly the same idea to that, in fact it’s 99% the same except for swapping out the ffmpeg call to something to generate a snapshot of the stl at a few different angles."
}
,
{
"id": "46493383",
"text": "There are many people who enjoy spending an afternoon working on a classic car. There are also many people who enjoy spending an afternoon driving a classic car.\n\nSometimes there are people who enjoy both. Sometimes there are people that really like driving but not the tinkering and some who are the opposite."
}
,
{
"id": "46493586",
"text": "Neat summary of Zen and the Art of Motorcycle Riding!"
}
,
{
"id": "46500068",
"text": "LLMs are really showing how different programmers are from one another\n\ni am in your camp, i get 0 satisfaction out of seeing something appear on the screen which i don't deeply understand\n\ni want to feel the computer as i type, i've recently been toying with turning off syntax highlighting and LSPs (not for everyone), and i am surprised at the lack of distractions and feeling of craft and joy it brings me"
}
,
{
"id": "46491382",
"text": "I yearn for the mindset where I actively choose to accomplish comparatively little in the brief spells I have to myself, and remain motivated. Part of what makes programming fun for me is actually achieving something. Which is not to say you have to use AI to be productive, or that you aren't achieving anything, but this is not the antithesis of what makes programming fun, only what makes it fun for you."
}
,
{
"id": "46491493",
"text": "Ultimately it's up to the user to decide what to do with his time ; it's still a good bargain that leaves a lot of sovereignty to the user. I like to code a little too much ; got into deep tech to capacities I couldn't imagine before - but at some point you hit rock bottom and you gotta ship something that makes sense. I'm like a really technical \"predator\" - in a sense where to be honest with myself - it has almost become some way of consumption rather than pure problem solving. For very passionate people it can be difficult to be draw the line between pleasure and work - especially given that we just do what we like in the first place - so all that time feel robbed from us - and from the standpoint of \"shipper\" who didn't care about it in the first place it feels like freedom.\n\nBut I'd argue that if anyone wants to jump into technical stuff ; it has never been so openly accessible - you could join some niche slack where some competent programmers were doing great stuff. Today a solo junior can ship you a key-val that is going to be fighting redis in benchmarks.\n\nIt really is not a time to slack down in my opinion - everything feels already existing and mostly already dealt with. But again - for those who are frustrated with the status-quo ; they will always find something to do.\n\nI get you however that this has created a very different space where past acquired skill-sets don't necessarily translate as well today - maybe it's just going to be different to find it's space than it was 10 years ago.\n\nI like that the cards have be re-dealt though - it's arguably way more open than the stack-overflow era and pre-ai where knowledge was much more difficult to create."
}
,
{
"id": "46491512",
"text": "If you only get one or two half-hours a week it's probably more fun to use those to build working software than it is to inch forward on a project that won't do anything interesting for several more months."
}
]
Return ONLY a JSON array with this exact structure (no other text):
[
{
"id": "comment_id_1",
"topics": [
1,
3,
5
]
}
,
{
"id": "comment_id_2",
"topics": [
2
]
}
,
...
]
Rules:
- Each comment can have 0 to 3 topics
- Use 1-based topic indices
- Only assign topics that are genuinely relevant to the comment
- If no topics match, use an empty array:
{
"id": "...",
"topics": []
}
50