Hacker News Reader

This post was interesting to me because I also have a lot of programming experience but other than hunt the wumpus high school I haven’t programmed a game and recently started using AI to help with a new game.

AI has become three things for me:

(1) A learning tool. What it is really great at is understanding my questions when I don’t have the proper terminology. Because of this it can give me a starting point for answers. It is also really fantastic for exposing me to unknown unknowns; probably the most important thing it does for me.

(2) A tool to do boring or tedious things that I can do but slow me down. I’ve found it good enough at a variety of things like commenting code, writing a config file (that I usually edit), or other text-based adventures.

(3) Search. Just like (1), because it understands what I’m actually after, it is irrelevant if I know what a thing is actually called. I also let it filter things for me, make recommendations, etc.

I think you can let it think for you, but… why would you? It’s not as smart as you. It’s just faster and knows more things. It’s like an FPU for the CPU of your brain.

Sorry for the pedantry, but there's little evidence to suggest that neural nets know about unknown unknowns. They know a lot about known unknowns though. Really enjoyed your comment in any case :)

No worries and thanks. For clarification, unknown unknowns was in reference to my own understanding of subjects.

I commented on this before, I'm in this weird "opinion arbitrage" spot where I'm relatively skeptical by HN standards but I'm actually pushing for more usage at work. Hell, I'm typing this while I wait for Claude to be done.

The reason for my skepticism is the delta between what they're being sold as and what they actually do. All AI solutions, including agents (especially agents!), are effectively worse-than-worthless without guidance from someone experienced. There's very little that's "autonomous" about them, in fact.

The very guy who coined the term "vibe coding" went on stage effectively saying we're putting the carriage before the horse!

Omitting the important caveat that while they are fantastic tools they need to be restrained a lot is effectively lying.

My opinion is that it's about the tools you use. Bad tools, bad agentic behavior.

Better spoons, better food.

Owners of silver spoons tend to eat pretty well.

Spoons are tools you use to consume food; a better analogy would be better kitchen, better food. An induction range, quality good, nice pans, nice knives will definitely enable higher quality food. Of course you can still make crap if you don’t know what you’re doing, the point is that the tools raise the ceiling for someone who does know what they’re doing.

one level deeper... better farm (soil, water, .etc), better food... also you can easily ruin food in a top-of-the-line kitchen by over-processing, adding tainted spices, excessive heat, .etc

My stance has long been that LLMs are currently worse than the evangelists are claiming they are, but are significantly better than the detractors and skeptics think they are.

Like most things, the truth is somewhere in the middle. But unlike many things, they are changing and advancing rapidly, so it's current state is not the resting state.

It's the same problem that crypto experiences. Almost everyone is propagating lies about the technology, even if a majority of those doing so don't understand enough to realize they're lies.

I'd argue there's more intentional lying in crypto and less value to be gained, but in both cases people who might derive real benefit from the hard truth of the matter are turning away before they enter the door due to dishonesty/misrepresentation.

I've come to this same conclusion pretty strongly in the past few months in particular. I actually had negative comments on my experience with AI previously.

For all the talk of AI hitting a ceiling the latest tools have improved greatly. I'm literally doing things in hours that'd previously take weeks with little issue. I do of course have to think about the prompts and break it down to a fine grained level and i also have the AI integrated well with the IDE.

The biggest wins are the times you hit a new framework/library. Traditionally you'd go through the 'search for code samples on usage of new library/language/framework -> work those samples into a form that accomplishes your task' cycle. AI is much better for this to the extent it even often surprises me. "Oh the library has a more straightforward way to accomplish X than i thought!".

For those who are still skeptical it's time to try it again.

Which IDE are you using?

The jetbrains collection which now have claud built in with a subscription option.

> I do of course have to think about the prompts and break it down to a fine grained level

This is where I’ve found usefulness falling off. Code is much more succinct and exact than English. I was never slowed down by how fast I could type (and maybe some are? I’ve watched people finger type and use the mouse excessively) but by how fast I could understand the existing systems. By the time I could write an expressive prompt in English I might as well have made the changes myself.

I’ve found it enormously useful as google on steroids or as a translator (which many changes that require code often end up being).

> This is where I’ve found usefulness falling off. Code is much more succinct and exact than English.

Depends on how you use English. If you describe all the details down to the last line of requirements — then, yeah. But actually, a lot of requirements are typical and can be compressed to things like "make a configuration page following this config type" and LLM will figure it out and put checkboxes for booleans, drop-downs for enums, and all the boilerplate that goes with them. Sometimes you have to correct this output, but it's still much faster than describing the whole thing.

> I'm literally doing things in hours that'd previously take weeks with little issue.

What's an example of this? Some of the ones I see most are: converting legacy code to something modern, building a greenfield app or feature in an unfamiliar language / framework / space.

But at work I don't have these types of jobs, and I want to get this productivity speed up, but right now I'm stuck at it helps a lot but not turning weeks of work into hours, so trying to get there

I recently had a need to create educational animations. These were programmatically created using the Manim library in Python.

I'm a mobile dev by trade. The best interaction i had recently was with Python and the Manim library specifically which are not my area of expertise. This was a series of "Create an animation that shows X with a graph of the result over variables Y". AI gave a one shot successful results with good coding practices for all of this. I could have spent a week coming up to speed on that library and re-remembering all the Python syntax or i could have fought against doing it at all but instead, one hour of prompting, "here it is boss, done".

I had similar results doing some updates to the app itself too fwiw. Android dev has a lot of boilerplate. "Create a new screen to show a list of images in a recycler view". Everyone who's done Android knows the boilerplate involved in what i just stated. Again 1 shot results. Unlike the above this is something i know how to do well, i just didn't want to type 100's of lines of boilerplate.

Would that have taken you weeks though?

I imagine reading through a few articles and examples could have gotten you there. I never heard of Manim before but found these pretty quickly:

https://docs.manim.community/en/stable/examples.html

https://manimclass.com/plot-a-function-in-manim/

I am not trying to pick at you, but it feels like what I am currently able to do with AI, shave off a few hours, but not weeks.

I agree with you the ease of cutting through boilerplate is a big win, but it also doesn't register as weeks worth of work for me...

A single graph might save hours. A full feature series where each graph type has yet new syntax to learn is indeed much more. Especially when there's followups, "let's make the graph move over the left half of the screen and then the next animation shows in the right half?" which again were one shot done in minutes with AI. For me just to gain the context of how to move the animation into the left half smoothly and then move all animations that were drawn into a separate animation file into this file and reposition each element from that second file into the right half of the screen would have probably taken a day.

We tend to underestimate engineering time generally. So i wouldn't look at the above and say "that seems doable in X hours". I stand strongly by my assertion that it saved me a week (at least!) all up.

> I stand strongly by my assertion that it saved me a week (at least!) all up.

Fair enough. More power to you then. I'll keep looking for some other examples. Thanks for sharing!

For me the LLMs are failing laughably to be able to generate some examples of any actively developing library, even for simple stuff. They invent non-existing APIs, use years old functions that are long deprecated, et cetera.

How do you integrate it with your IDE? I have used intellij for 15 years, anything worse than it's actually code-aware auto complete feels like a downgrade. ie. hallucinating APIs feels totally unnecessary when my old IDE never did that. If our projects had an orderly structure, some test coverage and a reasonable way to manage database migrations, I might let the AI a lot more loose, but alas.

I use intellij. Latest versions have claude 4 as an option to enable. I almost exclusively use the code aware chat function rather than allow the ai to suggest changes as i type and i use the ability to merge changes from the ai chat window to bring things across as the responses are generated.

This leaves the autocomplete untouched. Basically it’s a way of working where the ai only jumps in when asked. It works really really well.

> the leverage you get out of it is exponentially proportional to the quality of your instructions, the structure of your interactions, and the amount of attention you pay to the outputs

Couldn't say it better myself. I think many people get discouraged when they don't get good results without realizing that for good results you need to learn how to interact with these AI agents, it's a skill that you can improve by using them a lot. Also some AI tools are just better than others for certain use cases, you need to find one that works best with what you're doing.

When it finally clicks for you and you realize how much value you can extract from these tools there's literally no coming back.

It's not about learning how to interact with AI agents. The only required skills for working with these tools are basic reading and writing skills any decent English speaker would have. Knowing how and when to provide additional context and breaking down problems into incremental steps are common workflows within teams, not something novel or unique to LLMs.

"Prompt" or "context engineering" is what grifters claim they can teach for a fee.

What does make a difference is what has been obvious since the advent of LLMs: domain experts get the most out of them. LLMs can be coaxed into generating almost any thinkable output, as long as they're prompted for it. Only experts will know precisely what to ask for, what not to ask for, and whether or not the output aligns with their expectations. Everyone else is winging it, and their results will always be of inferior quality, until and if these tools improve significantly.

What's dubious to me is whether experts really gain much from using LLMs. They're already good at their job. How valuable is it to use a tool that can automate the mechanical parts of what they do, while leaving them with larger tasks like ensuring that the output is actually correct? In the context of programming, it's like pairing up with a junior developer in the driver seat who can type really quickly, but will confidently make mistakes or will blindly agree with anything you say. At a certain point it becomes less frustrating and even faster to type at normal human speeds using boring old tools yourself.

> It's not about learning how to interact with AI agents. The only required skills for working with these tools are basic reading and writing skills any decent English speaker would have.

This is flatly untrue, just as the same would be untrue about getting the most out of people (but the behavioral quirks of AI systems and the ways to deal with them do not follow human psychology, so while it is inaccurate in the same way as with people, the skills needed are almost entirely unrelated.)

In addition, there is a learning curve and a skill ceiling that is deceptively higher than people think. Also, running Claude Opus in some tight agentic harness will give very different results than asking GPT-4o in the browser and copy/pasting stuff around.

> The difference is the specific leverage is 10x any other "10x" tool I've encountered so far. So, just like every tool, only more so.

One of the best comparisons to me is languages.

The old "lisp [or whatever] lets us do more, faster" idea, but with a fun twist where if you can reduce the code you write but still end up with generated code in a fast, high-performance language, without the extra work you would have to do to go add type annotations or whatnot everywhere for SBCL.

But with a gotcha that you are gonna have to do a lot of double-checking on some of the less-easily/obviously-verified parts of the generated code for certain type of work.

And of course highly-expressive languages have resulted in no small number of messy, unmaintainable codebases being built by people without well-specified advance plans. So we're gonna see a lot of those, still.

BUT to me the real, even bigger win - because I spend less time writing 100% new code than integrating old and new, or trying to improve old code/make it suit new purposes, is supercharged debugging. A debugger is a huge improvement over print statements everywhere for many types of things. A machine that you can copy-paste a block of code into, and say "the output looks like [this] instead of like [that], what's going on" and get a fresh set of eyes to quickly give you some generally-good suggestions is a huge improvement over the status quo for a lot of other things as well. Especially the type of things that are hard to attach a debugger to (sql, "infrastructure as code", build scripts, etc, just to start).

> One thing I've noticed is many (most?) people in our cohort are very skeptical of AI coding (or simply aren't paying attention).

I'd hope most devs are using AI heavily when coding, the last 6 months seem to have reached a level of competence in raw programming skill somewhere around mid- or senior- level with hilarious variance between brilliance and idiocy.

I think you might be seeing the most vocal programmers are terrified for their future prospects and there isn't much room to reason with them so they're let alone.