[dmm]

Are you referring to the author specifically? Or a specific hypocritical person you know? If you're making a general statement about groups of online people you might be falling for the group attribution error[1], where the characteristics of an individual are assumed to be reflective of the whole group.

In any case, two things can be simultaneously true:

1. Writing code is not the bottleneck, as in we can develop features faster than they can be deployed. 2. It's annoying and disruptive to be interrupted when doing work that requires deep focus.

[1] https://en.wikipedia.org/wiki/Group_attribution_error

[Aurornis]

I think it's obvious that they're not referring to the author or a specific person at all. They're talking about how the zeitgeist has changed. Look at Hacker News archives 3 or more years ago and it would be really hard to find anyone arguing that coding speed is not a bottleneck or that engineers need to spend more time in collaboration. You would find a lot of arguments that leaving engineers alone to code is the best thing a business can do and constant lambasting of meetings, documents, approvals, and other collaborative activities.

I think there are small pieces of truth on both sides of the argument, but I find the sudden change to claiming that coding speed doesn't matter to feel half-baked. Coding speed is part of building a product. Speeding it up does provide benefit. There's a lot of denial about this, but I think the denial is rooted in emotion more than logic right now.

[fao_]

I don't think that this is very hypocritical on the part of the developer holding such views. Typing code has never been the bottleneck, building the mental model has. You need the mental model so you know how the domain and the actual model will interact, which is needed for pre-empting what tests you need, what QA you need to do, etc etc. and the limitations of the system. You can demo this out with a specification but all specifications eventually meet the domain head on, and often with catastrophic consequences, and you still need to do this sort of work anyway when writing the specification.

Fundamentally, LLM do not construct a consistent mental model of the codebase (this can be seen if you, uh, read LLM code,), and this is Bad for a lot of reasons. It's bad for long-term maintainability, it's bad for modelling this code accurately and it's behaviour as a system, it's bad for testing and verifying it, etc. Pretty much all of the tasks around program design require you to have that mental model.

You can absolutely get an LLM to show you a mental model of the code, but there is absolutely nothing that can 100% guarantee you that that's the thing it's using. Proof of this is to look at how they summarise documents, to look at how inaccurate a lot of documentation they generate is, and to look at how inaccurate a lot of their code summaries are. Those would be accurate if the LLM was forming a mental model while it worked. It's a program to statistically generate plausible text, the fact that we got the program to do more than that in the first place is very interesting and can imply a lot of things, but at the end of the day, whatever you ask for it, it will generate text. There is absolutely no guarantee around accuracy of that text and there effectively can never be.

[devonkim]

One of the core problems we have in software engineering is the longstanding philosophical problem around creation of cohesive, consistent, objective mental models of inherently subjective concepts like identifying a person, place, etc. Look at the endless lists of falsehoods programmers (tend to) believe about any topic.

You’re right that LLMs specifically have no guarantees about accuracy nor veracity of the text they generate but I posit that that’s the same with people, especially when filtered through the socialization process. The difference is in the kind of errors machines make compared to ones that humans make.

It’s frustrating we’re using anthropomorphic concepts like hallucinations when describing LLM behaviors when the fundamental units of computation and thus failures of computation are so different at every level.

[fao_]

> but I posit that that’s the same with people,

> The difference is in the kind of errors machines make compared to ones that humans make.

There's another difference, and that is that other humans can learn and study that mental model (which is why "readable code" is a goal — the code is a physical manifestation of the model that you, the programmer, has to learn), and then the model can be tweaked and taught back to the original programmer, who can then think of that tweak in the future. Programming is inherently (in most cases) a collaborative art, because you're working with people to collectively develop a mental model and refine it, smoothing it down until (as Christopher Alexander said) there are no misfits between the model and the domain.

[globnomulous]

I was an LLM naysayer for a long time. During that time I would have agreed with you. Recent experiences have changed my mind. The accuracy I get from models does not suffer from the problems you describe, and many of the issues you're describing are also true, in different ways, of human beings. There's never any guarantee that any of the text you or I produce will be accurate, or that our summary of it will be accurate, but if you ask us to generate text, we will. It recalls that funny meme: "Your job application says you're fast at math. What's 513 * 487?" "39,414." "That's not even close." "But it is fast."

[jwpapi]

Needing focus to think is not the same as needing focus to write code..

It can take a whole day to find 10 good lines to write.

[Aurornis]

> It can take a whole day to find 10 good lines to write.

So we've come full circle to code writing speed being a factor again? :)

In all seriousness, this just feels like a never-ending list of attempts to try to resist any notion that LLMs might accelerate software development, however small the increment. The original article was arguing that organizational and collaboration was the bottleneck and that taking a whole day to think about the code was not.

[rafaelmn]

And sometimes an LLM can find those 10 lines in 10 minutes. Or it can find a 100 and you cut them down to 10 in two hours total. Yes I've seen this in practice. The amount of code an LLM can tirelessly ingest is super human.

[globnomulous]

Twenty minutes ago Claude digested about a dozen pipeline definitions, a sequence of build files and targets, read the scripts they use, found the variable that I could reuse for my purposes, and made the appropriate change in the right (looking) place, so that I'd be able to achieve my goals.

I could not have done this nearly as quickly. On the other hand, I gave it clear, precise instructions.

[jwpapi]

Most of the time it can’t it can write 1000s, but its not good in finding the best 10s.

[Cthulhu_]

Speeding it up provides benefit if speed was the bottleneck to begin with. As the author notes or hints at, faster code output leads to more features being delivered, more room for experimentation, etc. But that's not necessarily productivity, if the features offer no value, if the experiments end up on a shelf, if the maintenance burden and context becomes bigger than the organization can handle (even LLM-assisted).

I've done a lot of "rebuild" / "second system" projects and the recurring theme is that the new version does less than the original. I don't think that's entirely down to the reality of second systems, I think that's in part because software grows over time but developers / managers rarely remove functionality. A full rebuild allows product owners (usually different from the ones of the original software) to consider whether something is actually needed.

[BoorishBears]

You wouldn't find anyone saying typing speed is a problem, they wanted more time for thinking.

[jimbokun]

Maybe some have changed their views because circumstances radically changed?

[knollimar]

Or just goomba fallacy

[sermah]

til https://en.wiktionary.org/wiki/Goomba_fallacy

[knollimar]

I learned here like a week ago so I'm here to evangelize.

[pydry]

This was a perfect example.

[robocat]

The collective smarts on the Internet can't come up with a better name that might help our brains tag the concept?

Although at least it has some cross-cultural references. Why is naming so hard.

[PakG1]

Memes help things to become popular. I guess the question would be how popular would it have been without the meme name? We'll never know.

[nemomarx]

Weirdly, the meme wasn't a goomba originally. The goomba edit just got way more popular?

[kevinmgranger]

Or the alternative explanation: there simply is no better name for it

[SV_BubbleTime]

That’s kind of just strawman with an origin story isn’t it?

[_diyar]

No because the goomba is the average of two real opinions, and the strawman is a distortion/reduction of any opinion such that its easy to argue against.

[tadfisher]

More like a superposition of two opinions.

[Cthulhu_]

Schrodinger's Goomba?

[SV_BubbleTime]

Ah, ok, so two real opinions made into a distortion. Right, I see how very dissimilar to an origin story of a strawman that is…

[nkingsy]

If I only had a brain...

[scarecrowbob]

On some level, yes, but having words to describe sub-sets can be useful too.

A "human" is just a "featherless biped", after all?

I think the Goomba Fallacy captures something helpful to me- it's helpful to know the origin of a straw man if you want to un-stuff one.

[bluefirebrand]

I know this is off topic but I cannot resist. It's very funny to read a comment about un-stuffing a straw man written by "scarecrowbob"

Gave me a good laugh, thank you. :)

[wuliwong]

I think the Goomba is distinct. Strawman is disingenuously representing an argument, Goomba is assuming contradictions are coming from the same person, presumably b/c it's coming to the Goomba through the same app.

[Jensson]

> Goomba is assuming contradictions are coming from the same person, presumably b/c it's coming to the Goomba through the same app.

Its because it comes from the same political faction. In general people are open about A when A seems palatable, and openly B when B seems palatable, but they almost never admit to do that when its obviously wrong to do so.

That is the rational part of the fallacy, even if these are different sets of people you can still tell they are biased since they never appear in the threads where its obvious they are in the wrong.

For example, lets say in a thread where a white cop shoots a black guy you find a lot of republicans say "this is just statistics, nothing to see here". Then in another thread where a black cop shoots a white guy republicans pour in and argue this must be racism and we should investigate! Maybe it isn't the same set of people, but its still a strong sign of problematic bias that they only choose to speak up in those particular threads and not the others.

Every political side everywhere does this, and that is why people started calling that out.

[awkward]

This is just the fallacy. Political groups are coalitions not single monoliths.

[SpicyLemonZest]

Is it true that they don't appear in the threads where you feel it's obvious they're in the wrong? Or do they just get upvoted less in those threads so you don't see it when they do appear?

[advael]

In general, hypocrisy is a pretty weak argument. It's an annoying personality trait, but consistency is a thing humans often fail at, and humans failing at holding consistent opinions is a failure of those humans, not the claims they're making. It's not quite as weak as the more non-sequitur kind of ad-hominem attack, because it does at least pertain to the argument being made, and kind of resembles a logical contradiction if you squint, but it seldom does a good job addressing the merits of the argument, rather than the arguer. It's a successful political tactic for the same reason ad hominem arguments in general are, of course, especially in the context of representative forms of government, where the person's character or competence is relevant when they're running for an office. Much less so in contexts where the merits of a position are being debated in abstract.

I think it's very silly to make the argument that "groupwise hypocrisy" is not a fallacy in such a conversation. In politics, the reality is that people have to form coalitions with people with whom they don't agree on everything, and non-political groupings are even more non-sensical, often holding people responsible for the opinions of other people who happen to share things like inborn characteristics. It's especially ridiculous to explain this with this idea that people are engaging in some kind of elaborate coordination to argue with you on the internet. Yes, some people, and indeed political parties, engage in that kind of behavior, and if you think you're arguing with something like a botnet, there are larger considerations to make about what you gain as an individual by trying to engage with such a machine at all. If I believe I'm arguing about the merits of an idea with an actual person, and I find myself reaching for something like "your group is collectively hypocritical on this issue" to make my argument, this is cause to reflect on whether I actually have any real arguments for my position, as that one is... well, essentially meaningless

I think you're trying to invoke what's commonly called a "motte-and-bailey" argument, where people argue for a maximally-defensible position when faced with serious criticism, but act as though they're proving a much less defensible version of their argument, often including a nebula of related ideas, in other contexts. This is something individuals and coordinated factions absolutely do, but again doesn't really support treating any grouping you want to draw of some kind of collective hypocrisy. Even assuming we care about hypocrisy, it seems like this kind of reasoning about nebulous groups that don't explicitly coordinate would allow making that argument about any position in any context, depending on how you draw the boundaries of the group that day. It's well-understood that you can go on the internet and find someone who believes just about any crazy thing you can think of, or find someone who makes the argument for any position poorly.

[jmalicki]

It's almost as if factions are made up of different people with different opinions in a loose alliance.

But nah, clearly they're all goombas.

[mothballed]

This is exactly it. You see it on HN all the time. You will debate someone. Then deep in thread, a second person appears with a gotcha. when you point out that the gotcha doesn't fit in with the prior argument, they point out that was a separate person. They knew damn well what they're doing with their little conniving deflection fuck-fuck game. They're acting for the same surrogate argument. The Goomba is real and the people playing the game are just too cowardly to be two-faced themselves so they act two-faced through a surrogate and deflect to the surrogate when it's pointed out.

[SkyBelow]

Sometimes there are two groups of people who have different opinions that don't interact, but given the extent they take up the same platform and don't seem to see each other, I'm not sure it is really a fallacy even then.

First, it becomes possible for people who have a double standard to hide behind this. One can try to track an individual's stance, but a lot of internet etiquette seems to be based on the idea of not looking up a person's history to see if they are being contradictory. (And while being hypocritical doesn't necessarily invalidate an argument, it can help to indicate when someone is arguing it bad faith and it is a waste of time as someone will simply use different axioms to reach otherwise contradictory conclusions when they favor each.)

Second, I think there is the ability to call out a group as being hypocritical, even when there are two sub groups. That one group supports A generally and another group supports B generally (and assuming that A + B is hypocritical), but they stop supporting it when it would bring them into conflict indicates a level of acceptance by the change in behavior. Each individual is too hard to measure this (maybe they are tired today, or distracted, or didn't even see it), but as a group, we can still measure the overall direction.

So if a website ends up being very vocally in support of two contradictory positions, I think there is still a valid argument to be made about contradicting opinions, and the goomba fallacy is itself a fallacy.

Edit: Removed example, might be too distracting to bring up an otherwise off topic issue as an example.

[plorg]

I believe in A, I don't take a strong position on B, I am in coalition with people who believe in B and don't take a strong position on A, we both believe in C, D, E, and F, which some other people believe in with differing weights. Browbeating me about position B (or, the most useless kind of Internet banter, complaining about me and my hypocritical position on A+B to your friends who oppose both in a likewise contradictory way, in some venue I've never heard of) is not about making people reevaluate positions, it's about negative factionalism. The only reason it might not fit the familiar categorization of "fallacy" is that you would never use it in rational debate, either in arguing with another person or in reasoning out your own position.

[SkyBelow]

>I believe in A, I don't take a strong position on B

But if A and B are opposed, then there is a question of why a strong position on A can be allowed with a weak position on B, if the reason for the strong position on A would also indicate a strong position against B.

The underlying argument being implied (but rarely ever directly stated) is to question if your reason for the strong position on A is really the reason you state, or if that is just the reason that sounds good but not the real reason for your belief.

In effect, that you don't apply the stated reason to B despite it fitting is the counter argument to why it doesn't actually support A.

If there is an inconsistency in arguments being applied, any formal discussion falls apart and people effectively take up positions simply because they like them, contradictions irrelevant. This generally isn't a good outcome for public discourse.

[habinero]

That's just "why do you hate waffles" with more words.

[the_gipsy]

You're making a strawman

[coldtea]

If so, I've seen that strawman living and breathing, and saying the first thing before, and the other thing now, several times.

[coldtea]

>Writing code is not the bottleneck, as in we can develop features faster than they can be deployed.

That's an organizational issue due to over-regulation, bureucracy, too many stakeholders each with their own irrelevant opinion, etc.

Startups or FOSS projects without the above absolutely can't "develop features faster than they can be deployed", and usually have a huge backlog of bugs and features they'd like to have, but never got around to.

[physPop]

If you don't have stakeholders I contend you probably don't have a product, or you're building the bare minimum MVP which upon becoming a product will be woefully inadequate, generating the aforementioned bottleneck.

[coldtea]

I said "too many". And mostly meant people with a say, as in "design by executive board/committee" as opposite to someone or a small team with a vision. Not about not having users.

In any case, the point still stands: most companies absolutely can't code "faster than they can ship" and for that have huge backlogs of things they'd want to add or bugs to fix.

[nottorp]

> 2. It's annoying and disruptive to be interrupted when doing work that requires deep focus.

Steering a LLM also requires deep focus. Unless you want to end up on accidentally quadratic or have a CVE named after your project.

[loeg]

How can it? You prompt it, then wait minutes+ for it to come back. It's the opposite of flow state.

[allannienhuis]

I get much better results the more thought I put into crafting my prompt. including using llms to help create that prompt. There's definitely a declining rate of return on that time, but thinking about the problem and carefully describing the context can take fairly deep thought. I do think it's in shorter bursts than when doing all of the work, but I get that same feeling of 'bah, where was I?' if I get interrupted while creating the prompt for a more complex feature. On the other hand, I spend a lot less time in flow state while debugging - it's way easier to describe a bug to an llm (often can just paste in the exception or link to error log).

[gowld]

What I do is, I'm always responding to output N while the AI is working on prompt N+1. So we are both always responding to each other's question/answer before last.

https://www.youtube.com/watch?v=CCMiyXM-1_U

https://shreevatsa.wordpress.com/2010/02/07/mastermind/

[bluGill]

It isn't exactly flow - but at when the prompt comes back it forces me to think. Flow is about getting into a state where I'm thinking so this is surprisingly similar. The prompt is helpful because it gives me a place to focus: does the proposed changes make sense (this is much smaller than the entire code base), and given this is done: do I know anything else that was missed.

[fmbb]

So you move from a maker’s schedule to a manager’s schedule. Interrupting you does not have any meaningful consequence on your ability to work because at any given moment you are not really working and when your interruption is over the prompt is still just waiting there for you.

[avereveard]

You don't wait. You run multiple independent incremental feature in parallel, while also running a code review, which will create the next set of tasks while you or the llm think up the feature to add after.

[loeg]

Context switching back and forth between a dozen different things is sort of the opposite of flow state, IMO.

[Daishiman]

It's not "flow state" but working on three features in parallel requires focus that's equally as fragile, at least if you want to follow the output of the LLMs and steer it if it makes mistakes.

[nottorp]

Flow comes after when you verify what it did...

[rodrigodlu]

I'm using my ADHD hyper focus skills while flagging issues that the LLM is doing.

Reading 10x more code than before puts me straight into the zone. (In a language that I find interesting: Elixir)

My own process is improving so much that I had only one bug last week that was fixed immediately after the error tracker caught.

But yeah I feel more tired sooner. So it's oneto three hyper focus zones per day, just like before.

The difference is that I enter faster, and now I'm not afraid of leaving the task and resuming later, since I can just ask for a summary of what we did so far.

I'm using two different models from two different providers to cross check the work tho.

I'm very good with bad smells I guess, after years supervising less experienced developers since early days in my long career.

[coldtea]

Many people today just trust whatever shit comes out. Some even brag about it, even famous devs like Yegge.

And requiring review of the result is not a "flow state". Flow states means continuous and uninterrupted focus while actively performing, LLMs block and return with new code or questions for minutes on end. That's the opposite of flow, it's the "let's take a break now, see you in a few minutes" for every interaction.

[nottorp]

> even famous devs

Are they devs or performance artists by now?