quantadev

Having a happy team is a sub-goal of the higher goal of 'accomplishing the task' (getting the work done), because sure it's nice for people to get along, and they're generally better performers when they're happy; but conversely if they get the job done while not getting along, then the higher objective is still attained, which is often the case.

In other words, if a manager's choice comes down to 1) happy people v.s. 2) replacing whoever it takes to get the job done, with or without happiness, then #2 must be done. So 'getting the work done' is the top objective, and everything else is secondary and subordinate to that. An employer's job isn't to run a social club, it's to produce results.

Without the sun the only source of energy would be starlight. Planets don't _generate_ energy of their own, they only radiate away energy. So without the sun everything will simply freeze to near absolute zero, once it radiates away all heat energy.

Even if you have one trillion juniors, you're not going to get them to spit out 1000 lines of code in a matter of seconds, after you give them an assignment, like LLMs do, so this is a faulty comparison.

Also often it takes a senior dev _more_ time to _explain_ to a junior what needs to be done than it takes to do it himself. What LLMs give us is the ability to generate a feature about as fast as we can type up the instructions we would have, pre-AI, given to a junior dev.

What's your point?

That carbon fiber seat is cool. Could be made to integrate right into the back of a backpack (like the rigid frame), to help the backpack stay rigid during use, so it's kind of dual purpose.

On the latest 'All In' Podcast today, one of the Besties Billionaires said coding productivity boost was like '20x to 50x'. Probably just reads my HN.

Yeah, that's where the 'branching' comes in for sure. Ideally a chatbot would be 'tree-based' where you can just go back to a prior point where you wish you had said something different, and just pickup as if you were back at that point in time, while the other parallel branches are ignored.

The way this is done, technically of course, is you build the "Context" by walking back up the tree parent by parent, until you reach the root, building up 'context' as you go along, in reverse order. That will then always be the 'right' context, based on branching.

The first chatbot I wrote back in early 2023, had exactly this (branching and history editing), and I was highly active on the OpenAI discord showing them it, and trying to influence them, to go in this direction. Tree-based editors can be hard to implement, and can be confusing to users, so that's one reason GUIs tend to not attempt it, and just go with linear (although often nowadays "editable") chats.

Related to this I've learned that a lot of the time it's best to just use a "Context File" which is a big file of instructions explaining goals, architecture, and constraints so I can just tell the AI to read it and then say "Do Step 21 Now" for example, if step 21 is laid out in the file. This way I sort of can micromanage the context, rather than trying to reuse old discussions which are usually 90% throw away content, no longer appliable.

All great programmers are exactly like this. We have a relentless insatiable desire to always be fixing problems, solving challenges/mysteries, and/or just creating. When you mix those psychological tendencies with the other aspect many of us share, called HFA, you end up also with extremely focused and narrow interests, as well.

What I tell myself (which is true) when I notice I've perhaps done something where the effort might not be worth the pay off, is that life itself is about the journey not the destination. As they say "The Journey _is_ the Destination", which applies to my other hobby, riding motorcycles. You can always get anywhere "better" in a car, but it's more fun on two wheels.

I'm using VSCode with Github Copilot, which has an "Agent Mode". It proactively reads thru your project files to understand the project, but imo you still have to give it pretty precise instructions to get what you want.

The 5min example is like a maximum/extreme case, yes. My average time spent writing each prompt is probably 30 seconds or less, and coding time saved per prompt like 25 to 60 minutes.

When I do spend minutes (not seconds) writing prompts, it's because I'm actually typing a "Context File" which describes with full clarity certain aspects of my architecture that are relevant to an Agent task set. This context file might have constraints and rules I want the Agent to follow; so I type it once and reference it from like 10 to 20 prompts perhaps. I also keep the prompt files as an archive for the future, so I can always go back and see what my original thoughts were. Also the context files help me do system documentation later.

This can definitely happen, because the context windows even in a great Agent can become flooded. I often do prompts like "Add a row of buttons at the top right named 'copy', 'cut', and 'paste'", and let the Agent do that, before I implement each button, for example.

The rule of thumb I've learned is to give an Agent the smallest possible task at a time, so there's zero ambiguity in the prompt, and context window is kept small.

That 30x math simply comes from spending 5min typing a prompt, and getting code generated that would take a human 2.5hrs to write. This means in the future most of a developer's time will be spent reviewing code, rather than typing it. Because AI will also be able to write the test cases too, so that effort [mostly] vanishes as well.

When it comes to zero ambiguity and perfect specificity here's how I define it: If I gave the same exact prompt wording to a human would there be any questions they'd need to ask me before starting the work? If they need to ask a clarifying question before starting then I wasn't clear, otherwise I was clear. If you want to balk at phrases like "perfectly clear" you're just nit picking at semantics.

Not sure how Claude frequently fails for you, but everybody I know says it rarely fails. I'm definitely not claiming it's perfect tho.

I can't tell you how many times I've seen people write shoddy ambiguous prompts and then blame the LLM for not being able to read their minds.

If you write a prompt with perfect specificity as to what you want done, an agent like "Github Copilot+Claude" can work at about the same level as a senior dev. I do it all day long. It writes complex SQL, complex algorithms, etc.

Saying it only does boilerplate well reminds me of my mother who was brainwashed by a PBS TV show into thinking LLMs can only finish sentences they've seen before and cannot reason thru things.

It was when I started using Github Copilot in "Agent Mode" that my LLM productivity gains went from like 5x to 30x. People who are just using a chatbot get like 5x gains. People who use "Agent Mode" to write up a description of a new feature that would take several days by a human, but get it done in one click by an Agent, are getting 30x or more.

The amount of pushback I got on this thread tells me most devs simply haven't started using actual Agents yet.

It's all about the quality of your prompts (i.e. your skill at writing clear unambiguous instructions with correct terminologies).

An experienced developer can generate tons of great code 30x faster with an Agent, with each function/module still being written using the least amount of code possible.

But you're right, the measure of good code isn't 'N', it's '1/N' (inverse), where N is number of lines of code to do something. The best code is [almost] always that with the least amount of lines, as long as you haven't sacrificed readability in order to remove lines, which I see a lot of juniors do. Rule of thumb is: "Least amount of easily understood LOC". If someone can't look at your code for the first time, and tell what it's doing, that's normally an indication it's not good code. Claude [almost] never breaks any of these rules.

I'll spend like 10 minutes crafting a prompt that explains a new feature to be added to my app. I explain it in enough detail, with zero ambiguity, such that any human [senior] developer could do it. Often the result is 100s of lines of code generated, and well over 95% of the time the code "Claude 4" generates is exactly what I wanted.

I'm using VSCode Github Copilot in "Agent Mode", btw. It's able to navigate around an entire project, understand it, and work on it. You just lean back and watch it open files, edit them, show you in realtime what it's thought process is, as it does everything, etc. etc. It's truly like magic.

Any other way of doing development, in 2025, is like being in the stone ages.

One good prompt into Github Copilot 'Agent Mode' (running Claude 4) asking for a new feature can often result in up to 5 to 7 files being generated, and a total of 1000 lines of code being written. Your math is wrong. That's hours of work I didn't do, that only took me the time of describing the new feature with a paragraph of text.

The "instant" to which you refer was meaning that I can tell instantly if the LLM generated what I wanted or not.

That doesn't mean it's reviewed, it means I'm accepting it to _BE_ what I go with and ultimately review.

The only thing more reckless than a junior is an LLM-empowered junior.

I can easily get a month of work done in a single day yes. So probably the 30x is about the current max, and 50x was hyperbole, because I didn't add it up before doing that post.

Experienced senior developers can spot and fix the slop instantly, while still getting a 30x productivity gain, while entry level or junior devs basically only have one "Filter" by which they determine code quality which is: "Does the code seem to work?".

Unfortunately "Slop" will appear to work enough of the time to fool a Junior.

Also the reason Junior devs get "slop" is because their prompts are "slop". They don't know all the right terminologies for things, nor do they even have the writing/language skills necessary for good prompting.

EDIT: Due to everyone checking my math I corrected this to 30x, as what's provable, from past experience.

It's more like better-than-senior 99% of the time. Makes mistakes 1% of the time. Most of the 'bad results' I've seen people struggle with ended up being the fault of the human, in the form of horrible context given to the AI or else ambiguous or otherwise flawed prompts.

Any skilled developer with a decade of experience can write prompts that return back precisely what we wanted almost every single time. I do it all day long. "Claude 4" rarely messes up.

Your information is quite badly out of date. AI can now beat humans at not only chess but 99% of all intellectual exercises.

Sounds like someone in denial, and certainly with less than 10yrs of his own.

I think the "Who Cares Era" (great name btw) is able to continue down this path because really the entire business purpose nowadays for any online content is simply AD Delivery.

If the website can successfully prove to the advertisers that some human likely did indeed view the ADs then it's "mission accomplished". It matters very little what the content contains, as long as the AD revenue stream (the only revenue stream for most online sites) keeps rolling in. So really the only text to get right is the "Clickbait Titles" and "Clickbait Imagery".

So the longer canonical form of our Era is "Who Cares, We Made Some Money...Era"

What I meant by "doesn't matter" is that your original quip didn't prove me wrong. You just want to talk about all these other things to insinuate somehow I'm unaware of them, despite having 3 decades of web dev exp. lol. I already made it perfectly clear what I said is about 2 days of work, and I'm not wrong.

I've been coding for 35 years. I love HackerNews. Because it works. And it's all we need. But holding it up as some example of engineering would be silly. It's just a tree editor. I implemented a better tree editor myself today from scratch.

If you want to know what stuff I'm impressed by it's things like Mastodon, Nostr apps, and stuff that does more than edit a simple content tree of nothing but plain text. We can't even upload images. Can't do markdown. lol. It's definitely a "Less is More" app, from two decades ago. Just agree to agree with me on that. It's not an insult to them. It's just an observation.