One thing I loved about doing technical enterprise sales is that I’d meet people doing something I knew little or nothing about and who didn’t really understand what we offered but had a problem they could explain and our offering could help with.

They’d have deep technical knowledge of their domain and we had the same in ours, and there was just enough shared knowledge at the interface between the two that we could have fun and useful discussions. Lots of mutual respect. I’ve always enjoyed working with smart people even when I don’t really understand what they do.

Of course there were also idiots, but generally they weren’t interested in paying what we charged, so that was OK.

> Helping a customer solve challenges is often super rewarding, but only when I can remove roadblocks for customers who can do most of the work themselves.

So I feel a lot of sympathy for the author — that would be terribly soul sucking.

I guess generative grammars have increased the number of “I have a great idea for a technical business, I just need a technical co founder” who think that an idea is 90% of it and have no idea what technical work actually is.

Before that, I worked in a digital print organisation with a factory site. This factory did huge volumes on a daily basis. It was full of machines. They had built up a tech base over years, decades, and it was hyper-optimised - woe betide any dev who walked into the factory thinking they could see an inefficiency that could be refactored out. It happened multiple times - quite a few devs, myself included, learned this lesson the hard way - on rare occasion thousands of lines of code had to be thrown out because the devs hadn't run it past the factory first.

It's an experience I'd recommend to any dev - build software for people who are not just "users" of technology but builders themselves. It's not as "sexy" as building consumer-facing tech, but it is so much more rewarding.

Asking it to refactor / fix it made it worse bc it'd get confused, and merge them into a single variable — the problem was they had slightly different uses, which broke everything

I had to step through the code line by line to fix it.

Using Claude's still faster for me, as it'd probably take a week for me to write the code in the first place.

BUT there's a lot of traps like this hidden everywhere probably, and those will rear their ugly heads at some point. Wish there was a good test generation tool to go with the code generation tool...

Having mistakes in context seems to 'contaminate' the results and you keep getting more problems even when you're specifically asking for a fix.

It does make some sense as LLMs are generally known to respond much better to positive examples than negative examples. If an LLM sees the wrong way, it can't help being influenced by it, even if your prompt says very sternly not to do it that way. So you're usually better off re-framing what you want in positive terms.

I actually built an AI coding tool to help enable the workflow of backing up and re-prompting: https://github.com/plandex-ai/plandex

But in my experience, if you continue iterating from that point, there's still a risk that parts of the original broken code can leak back into the output again later on since the broken code is still in context.

Ymmv of course and it definitely depends a lot on the complexity of what you're doing.

The challenge is writing in a tone that will gently move the conversation rather than refocus it. I can’t just inject “remember point n+1” and hope that’s not all it’ll talk about in the next frame.

If nothing else, LLMs have helped me understand exactly why GIGO is a fundamental law.

https://news.ycombinator.com/item?id=40922090

LSS: metaprogramming tests is not trivial but straightforward, given that you can see the code, the AST, and associated metadata, such as generating test input. I've done it myself, more than a decade ago.

I've referred to this as a mix of literate programming (noting the traps you referred to and the anachronistic quality of them relative to both the generated tests and their generated tested code) wrapped up in human-computer sensemaking given the fact that what the AI sees is often at best a lack in its symbolic representation that is imaginary, not real; thus, requiring iterative correction to hit its user's target, just like a real test team interacting with a dev team.

In my estimation, it's actually harder to explain than it is to do.

I think the problem with “AI” code is that many people have almost a religions belief. There’re weirdos on internet who say that AGI is couple years away. And by extension current AI models are seen as something incapable of making a mistake when writing code.

- That said, surely traffic will decline for Q&A sites. "How do I connect tab A into slot B" is something that people are likely to query LLMs for; the response will surely sound authoritative, and could be even correct. That's definitely a task where LLMs could help: common questions that have been asked many times (and as such, are likely to be well-answered in the human-made training data). A 20001st question of "how do I right-align a paragraph in HTML" has not been posted? Good. Rote tasks are well-suited to automation. (Which, again, brings us back to the issue "how to distinguish the response quality?")

Now imagine that HTMZ comes along and people just go straight to asking how to full justify text in HTMZ for their smart bucket. What happens? I doubt we’ll get good answers.

It feels like the test of whether LLMs can stay useful is actually whether we can stop them from hallucinating API endpoints. If we could feed the rules of a language or API into the LLM and have it actually reason from that to code, then my posed problem would be solved. But I don’t think that’s how they fundamentally work.

So, I think the answer is that since all useful data is already in a LLM somewhere all new data will be stolen/scraped and inserted in real time. So if real people are answering the question it will work as normal. The real question is what happens when people are trying to mine karma by answering questions using an LLM that is hallucinating. We have seen such with the Bug Bounty silliness going on.

The problem, of course, is that this might work once in a while for low hanging fruit, until the web inherited things like DICOM and we now have medical imaging in the web browser (I've heard in Apple Vision Pro), where robotics implies the price of unforeseen bugs is not accidental death or dismemberment of one patient, but potentially many.

His clients were usually older small business owners that just wanted a web presence. His rate was $5000/site.

Within a few years, business dried up and he had to do something completely different.

He also hosted his own smtp server for clients.It was an old server on his cable modem in a dusty garage. I helped him prevent spoofing/relaying a few times, but he kept tinkering with the settings and it would happen all over again.

Unless he's so good at selling his services he can consistently find new clients. And if that's the case, he'd probably kill it in sales.

That business model only works until customers are sophisticated enough to understand tech debt. In the future, more customers will be less willing to pay the same good wages for low quality code.

    > but his customer / employer bought low quality code with lots of tech debt.

I can completely believe someone had no idea what they were doing when copy/pasting, and working on wordpress.

if [ -z "${Var}+x" ]

Where I can see what the author was trying to do, but the code is just wrong.

I dont mind people not knowing stuff, especially when it's essentially Bash trivia. But what broke my heart was when I pointed out the problem, linked to the documentation, but recieved the response "I dont know what it means, I just used copilot" followed by him just removing the code.

What a waste of a learning opportunity.

There were many times in my career when I had what I expected to be a one-off issue that I needed a quick solution for and I would look for a quick and simple fix with a tool I'm unfamiliar with. I'd say that 70% of the time the thing "just works" well enough after testing, 10% of the time it doesn't quite work but I feel it's a promising approach and I'm motivated to learn more in order to get it to work, and in the remaining 20% of the time I discover that it's just significantly more complex than I thought it would be, and prefer to abandon the approach in favor of something else; I never regretted the latter.

I obviously lose a lot of learning opportunities this way, but I'm also sure I saved myself from going down many very deep rabbit holes. For example, I accepted that I'm not going to try and master sed&awk - if I see it doesn't work with a simple invocation, I drop into Python.

E.g. maybe it would be very 'elegant' or rather concise awk if I could overcome the learning opportunity, but like you I would probably decide not to; I'll do it with the sed I do know even if it means some additional piping and cutting or grepping or whatever that awk could've done in one, because I already know it and it's going to be clearer to me and probably anyone else I'm working with.

I think we're saying quite similar things, but my point is I wouldn't be deleting it, dismissing the idea, and disappointing the colleague ready to teach me about it - because I never would've been willing to blindly try broken AI generated (or however sourced) code that I didn't understand in the first place.

True, but the anecdote doesn't prove the point.

It's easy to miss that kind of difference even if you wrote the code yourself.

The developer in the story had no idea what the code did, hence they would not have written it themselves, making it impossible for them to “miss” anything.

Yes.

AI as a faster way to type: Great!

AI as a way to discover capabilities: OK.

Faster way to think and solve problems: Actively harmful.

I'm the first to bash JS, but this is not a JS issue. It's 100% a "bad and lazy" human actor that is throwing spaghetti on the wall to see what sticks. In this case, they have a minigun cannon called ChatGPT/CoPilot that is letting them do more of it than what they used to.

"Create Python code for iterating a file with a cache."

    class CachedFileIterator:
        def __init__(self, file_path):
            self.file_path = file_path
            self.cache = []  # List to store cashed lines
            self.current_index = 0  # Index for the current line to read

        def _read_lines_from_file(self):
            """Read lines from the file and cache them."""
            with open(self.file_path, 'r') as openFile:
                for line in f:
                    self.cache.append(line.strip())  # Strip newline characters and save to cache

        def __iter__(self):
            """Return the iterator object itself."""
            return self

        def __next__(self):
            """Return the next line in the iteration."""
            if self.current_index < len(self.cache):
                result = self.cache[self.current_index]
                self.current_index += 1
                return result
            else:
                # If we reach the end of the cache, we read more lines from the file if necessary
                if len(self.cache) == 0:  # Cache is empty, read file
                    self._read_lines_from_file()
                    
                if self.current_index < len(self.cache):
                    result = self.cache[self.current_index]
                    self.current_index += 1
                    return result
                else:
                    # If still no lines, we stop iteration
                    raise StopIteration

    # Example usage:
    if __name__ == "__main__":
        file_path = 'example.txt'  # Replace with your file path
        
        iterator = CacheingFileIterator(file_path)
        for line in iterator:
            print(line)

But this is actually so much worse for that same reason - the type of developer who'd submit Copilot output (I can call it that, as it's definitely not code) for a PR is unable to respond to any comment beyond asking Copilot again and wasting everyone's time with 6 more rounds of reviews. I've literally had to write test cases for someone else and told them "You can't ask for another code review until your code passes these."

With the big difference obviously being that typically the developer who writes the test also will write the code.

In some situations, this actually makes sense to do with junior developers as part of their training. Where a senior developer sits down with them and write out the tests together, then with the tests as a guide they are thrown into the waters to develop the functionality.

Of course, I suspect that in this case, you were not dealing with a junior. Rather the sort of person who looks at your tests, still is confused and asks for a "quick call" to talk about the tests.

The only thing I'd call an actual mistake is using an empty list to mean both an empty file and an uninitialised value.

    def cached_file_iterator(file_path):
        with open(file_path, 'r') as f:
            lines = [ line.strip() for line in f.readlines() ]
        yield from iter(lines)

    # Example usage:
    if __name__ == "__main__":
        file_path = 'example.txt'  # Replace with your file path
        
        iterator = cached_file_iterator(file_path)
        for line in iterator:
            print(line)

iterating over the file object at all instead of just calling self.cache = openFile.readlines() means that calling strip() the line below removes data beyond just the trailing newlines.

Certainly if you are in a conversation mode after a few back and forths this happens from time to time.

I am just not going to spend my time digging to previous prompts of code I might not want to share just to satisfy a random internet person .

Maybe you meant the latter?

Maybe you don't want to pursue a career in software, but anyone can spend a week learning Python or JavaScript. I suspect/hope a lot of these people are just kids who haven't gotten there yet.

On the other hand, I have a wealth of other general computer and protocol knowledge and have been working circles around most of my coworkers since day one. In the typical tech startup world I _rarely_ encounter coworkers with truly deep knowledge outside of whatever language they work in.

IMO the skill isn't about being able to "write code", it's about being able to model how things work.

Having gobs of time as a kid and in my twenties to experiment greatly enhanced my capabilities. Once I did start landing corporate jobs (which was exceedingly difficult) I was at or above architect level. As I gained more experience working on production systems I was promoted very quickly (created new positions for me etc).

I have had other architects declare I was the best they have ever met. Which sadly, isn't saying much.

Ditto and ditto.

I have had some positive experiences working with fresh grads from places like Waterloo (I'd hire 10 of their grads for any one grad from anywhere else...) but my professional experience very much matches yours.

So, if you're solo dev'ing, you can get away with making things work with what you've learned in a week. You just wouldn't be hired by anyone else of a serious nature. So it just depends on the individual and projects being worked.

1. You're a person of a particular frame of mind who finds it easy and natural to talk to computers in programming languages

2. You knew a different language before, perhaps one you learnt at a young age

3. You've messed around with computers for years now and have built up a conceptual model of what the hardware and software components are and how things fit together. So if a new thing comes along, you can hang it on your tree of knowledge. Consider the difficulty someone might have making hello_world.py if they don't know what an OS is, or how to edit text, or any of the basics.

None of the above generalizes to the population at large.

I think sometimes we forget not everything has to be written to a git repo with a highly developed structure ready for multiple people to work on. Is it a good habit, hellznaw, but people start somewhere and progress. That was the point that I was trying to make. It is totally possible to have a career as a programmer and have no credentialed degrees in CS or even programming. I know from personal experience.

Agreed on all further ones, however

I don't feel this is any different from someone that might have taken a class that taught HTML/JS/CSS except for that would actually be learning directly applicable to today. If that type of person jumped into a bootcamp, I feel like that would be similar to anything I experienced if not better. The internet is a thing now so there is so much more access to anything I had.

I feel like a week isn't anywhere near close enough but depending on what you want to do it gets you to start tinkering. Ironically I do wish that I had started working on embedded with microcontrollers than starting with web purely because there isn't space for absurd abstractions.

On web even the DOM API is a huge abstraction over rendering calls to OpenGL/DirectX/Vulkan and I never could grok what is happening with the DOM API until I played with the underlying tech and learnt about trees and parsers and how that would be stored.

I still use the DOM and love the abstraction, but sometimes I just wish I could use an immediate mode approach instead of the retained mode that the DOM is...

Someone with a week of knowledge, or even someone who has spent 10 years building react may not understand half of that unless they have actively tried to learn it. Thwy might have an idea if they had formal education but a self taught programmer. They have been building houses using lego blocks, I you give them mortar and bricks you are setting them up for failure.

When moved on to writing PC programs, I struggled so much because everything is so heavily abstracted and languages like python have so much ability embedded in them already. I kinda had to toss a lot of intuition and learn things new.

Still the most insane thing I've seen, but I know there are a lot of kids out of college who got used to gen AI for code writing who put out a lot of this kind of code. Also, coincidentally, we haven't hired any US college interns in about 3 years or so.

You just don't know how much they actually learned about programming as a discipline in its own right and it very well could be functionally zero. I've seen recent CS grads who didn't know how to use git, didn't know how to split code across multiple files or understand why you would even want to.

I think there's a fairly sound argument for these being different degrees, that a certain kind of researcher doesn't necessarily need these skills. But since it isn't there's just a huge range in how schools reconcile it.

Computers treat people like garbage all the time.

Consider for instance the remote support features that Intel is so keen on advertising these days. Microcode level remote access is a small help for IT departments and a huge help for authoritarian regimes looking to spy on their people. But I don't think that most people are prepared to consider what they're enabling by paying Intel to continue to grow into a telescreen vendor.

Sure, we shouldn't blame the computer's soul for bad behavior. But if it's being used as a weapon, it's not helpful to remove the computer from the conversation and say "well it's actually bad people." Mitigating bad behavior via computer means hacking that computer, and that starts with blaming it for the bad behavior to some degree.

How many arguments have we heard here along the lines of "why teach algorithms universities should be teaching _insert_fad_technology_of_the_day_." Big Oh and time complexity is a special favourite for people to pick on and accuse of being useless or the like. You see it in arguments around SQL vs document databases, people not being willing to recognize that their for loops are in fact the same as performing joins, people unwilling to recognize that yes they have a data schema even if they don't write it down.

So I'm not surprised at all that people would use AI as a substitute for learning. Those same people have likely gotten by with stackoverflow copypasta before gen AI came about.

I mess around in goody and game maker and can write some shitty code there, but I’ve never written a line of code for work. I just like messin around for fun

Do you know how many botnets exist because of shit game-engines that are easily exploited and connected peer-to-peer etc.

Lovely frameworks and engines... but really harmful if you ask me. People are unwitting victims of other peoples hobby projects.

You need to be responsible in this day and age. If you don't want to do the due dilligence, or are stapped for resources (time, knowledge, etc.) then it's best to for example, make a singleplayer game, or LAN only and disallow any IP addresses in your game not defined as internal class ranges.

Do have a hobby, and do have fun, but do so responsibly. You wouldn't want one of your works of love and passion to end up hurting someone would you? Simple steps can be taken to project the consumers of your lovecraft from the vicious world out there. It's sad this is needed, but that's no excuse not to do it. Humans should be better, but they are not.

Before LLMs you'd probably have to reach for learning Python or Javascript sooner, at least if StackOverflow didn't have the right code for you to copy/paste, but I expect anyone who sticks with it will get there eventually either way.

A mere ten or so years ago I only wrote firmware in C and MacOS apps in objective-c. That was my world and it was all I knew, and all I’ve done for a long time.

Then something happened. Small startup. Website needs urgent fix and the web guy is MIA, so what the hell, I can take a stab at it.

Literally had no idea where to start. I didn’t know about npm, minified transpiling, much less actual testing and deployment. Could not make sense of anything anywhere. Hopelessly lost. I even grepped the JavaScript for “void main()” out of desperation. Just ridiculous

The result is people that have no technical background, no real interest in it either, no basic framework to start from learning to use a specific set of tools and a very basic understanding of programming.

I cringe every time they mention using the bots, but luckily it has been controllable.

games tend to attract young people (read: beginners) but at the same time game programming's barrier to entry is pretty high with maths & physics, low-level graphical programming, memory management, low level language and dependencies, OOP... It's almost obvious that this should be the case, every kid who's interested to coding I talked to wants to do something with games.

In fact, there are so many beginner-friendly gaming engines out there for most languages, that I am convinced that we should start using games as the entry-point for teaching programming languages. It is a beatifully self-contained domain.

If you're surprised by reality, that says something about your mental model, not about reality. People don't want to "learn programming", they want to "make a thing". Some people learn programming while making a thing, but why learn about how the sausage is made when all you want is to eat it?

Hahaha, I wish that were true, but it’s not. Lots of people want to learn programming for learning and programming’s sake, or because programming is more lucrative than sausage making. I think I’ve worked with more programmers that care more about programming than the end result, than making something. It’s constantly frustrating and a huge source of over-engineering mistakes that have proliferated through engineering.

> why learn about how the sausage is made when all you want is to eat it?

Then why do sausages get made? It’s because not everyone only wants to eat them. There’s a variety of reasons people make sausages and also like eating them, from making money, to making high quality or interesting variety sausages, to being self-sufficient and not paying others for it, to learning about how it’s done. It’s been my experience that the more someone cares about eating sausages, the more likely they are to dabble in making their own.

Stop poisoning the well and then complaining that you have to drink from it.

The other day my friend showed me a curious screenshot where an, ahem, dev influencer showed all the courses he's done.

Problem is, just one of those six courses amounted to two average net salaries in the region and they were fairly basic.

Either the guy in question had a year's worth of runway (then why even bother getting into IT?), got into debt or... didn't actually pay for any of this and it was not disclosed.

I do my best to dissuade people from spending their hard earned money on such things, but a significant chunk unfortunately does not listen.

Something like.

Some of you may use ChatGPT/Copilot to help with your coding. Please understand this service is designed for professional programmers and we cannot provide extensive support for basic coding issues, or code your app for you.

However if you do want to use ChatGPT here is a useful starting prompt to help prevent hallucinations - though they still could happen.

Prompt:

I need you to generate code in ____ language using only the endpoints described below

[describe the endpoints and include all your docs]

Do not use any additional variables or endpoints. Only use these exactly as described. Do not create any new endpoints or assume any other variables exist. This is very important.

Then give it some examples in in curl / fetch / axios / python / etc.

Maybe also add some instructions to separate out code into multiple files / endpoints. ChatGPT loves to make one humungous file that’s really hard to debug.

ChatGPT works fairly well if you know how to use it correctly. I would defo not trust it with my crypto though, but I guess if some people wanna that’s up to them. May as well try and help them!

Considering that LLM can hallucinate in different ways unpredictably, not sure whether it will work in practice.

Also commonly referred to as the robustness principle; “be conservative in what you do, be liberal in what you accept from others“. An approach that is now considered an anti-pattern, for such future compatibility reasons.

The AI of tomorrow will be trained on the output of AI today.

(Somewhere in my memory, I hear an ex-boss saying "Well that's good - isn't it?")

There might be other ways of achieving the same goal. Also,LLM hallucination is changing/improving quite rapidly.

That said, "Designed for LLM" is probably a very productive pursuit. Puts you in the right place to understand the problems of the day.

In my opinion, using code from LLMs, which might see your program come to life a bit quicker, will only enhance the time needed for debugging and testing, as there might be bugs and problems in there ranging from trivial things (unused variables) to very subtle and hard to find logic issues which require a deeper knowledge of the libraries and frameworks cobbled together by an LLM.

Additionally, it takes out a lot of the knowledge of these things in the long run, so people will find it more and more challenging to properly do this testing and debugging phase.

Let's say you've got some rest API. Are they trying to send PATCH requests but you only support POST? Do they keep trying to add pagination or look for a cursor? Do they expect /things to return everything and /things/id to return a single one but you have /things and /thing/1 ?

None of this is to say you must do whatever they are trying to do but it's a very cheap way of seeing what introducing your API/library to a new user might be like. And, moreover, you can only ever introduce someone once but you can go again and again with a LLM. Review the things they're doing and see if actually you've deviated from broad principles and if a change/new endpoint actually would make things much easier.

Fundamentally you can break this down to "if there's someone who can do some coding but isn't a top class programmer, how much do I need to explain it to them before they can solve a particular problem?"

I would recommend API fuzzers here, which cycle through all available possibilities, and generate 'garbage' inputs as well as structured inputs regarding the specifications the APIs implement (http, and the underlying structures provided to the api endpoints).

an LLM would likely not perform an exhaustive test.

There are several projects freely available to run such fuzz tests. Eventhough that does eat up considerable resources, and 'resetting' state during such tests can be problematic at best, the same would apply for LLM based testing. (database gets screwed in some way, and the next request is not on a 'clean' state.)

It's not testing the API for bugs, it's asking whether the API you have follows typical norms and isn't missing things. Is your API confusing or incomplete?

Imagine you have a library dealing with chat rooms, and LLMs keep trying to call "room.getUser(id)" and "room.getUsers()" when your API is actually "room.user(filter:{id:id})[0]" and "room.user(filter:None)". Maybe that's a sign that your API, while totally functional is going to be confusing to other programmers. Maybe you don't have anything that lists all current users, or there's a flag or option somewhere that would make sense or be more typical.

A fuzzer won't tell you that.

For the original post, you could imagine that a user might want the price of a token in a different currency, but maybe it currently returns everything in dollars. An LLM might try and add ?currency=GBP . Maybe an LLM keeps expecting to see in the response data the last updated timestamp to check data freshness, but it isn't something you add right now.

it seems like trying to facilitate bad things. make good things instead.

If it breaks a lot of conventions or norms, no it's probably not good.

But also the point here is *how much do you need to really explain?". If you have apis that require a lot of re-explanation to llms to force them to do the right thing "no getUsers doesn't exist use users(filter) where... YOU MUST USE users(filter)!" That's a sign your API might be going counter to a broad estimation of existing code.

> it seems like trying to facilitate bad things. make good things instead.

I have seen so many people make something that is obvious to them and so few others that "simply write good things from the start" is pointless advice.

That being said, its not always the case and you are right, 'make something good' is a bad advice, essentially it's not advice at all.

I would say as advice - don't do something alone if you want others to use it. Try to get feedback as early as possible from people you trust, and from people you'd expect to be your consumers/users. And always listen to that advice, don't throw it into the wind. I think that's the best advice if you want to make something 'successful', because the label of successful ultimately will be granted to your product by your users, not yourself.

Sorry to put a 'bad advice' if it was taken as advice :-). I don't mean to make bad things even in advice ^^.

Originally, it wasn't. From the GP post:

> If there is a common hallucination API call, just add that API. This will make the API more "friendly" and resemble common similar APIs.

If it's just users, you wouldn't be adding the APIs.

I write API calls. I am a user of apis. If you want to be more pedantic than this I simply do not care and you should evaluate what benefit you are bringing to this conversation.

- sorry if the comment was too silly. i'll try to keep it for myself.

Annoying, but a good way to weed out bad customers. Life’s too short to deal with people who feel this entitled.

In some cases, you might be able to use this to your advantage to improve the product.

When working with third-party APIs, I've often run into situations where my code could be simplified greatly if the API had an extra endpoint or parameter to filter certain data, only to be disappointed when it turns out to have nothing of the sort.

It's possible that ChatGPT is "thinking" the same thing here; that most APIs have an X endpoint to make a task easier, so surely yours does too?

Over time I've sent in a few support tickets with ideas for new endpoints/parameters and on one occasion had the developer add them, which was a great feeling and allowed me to write cleaner code and make fewer redundant API calls.

While this is possible, I would caution with an anecdote from my ongoing side project of "can I use it to make browser games?", in which 3.5 would create a reasonable Vector2D class and then get confused and try to call .mul() and .sub() instead of the .multiply() and .subtract() that it had just created.

Sometimes it's exceptionally insightful, other times it needs to RTFM.

And I assume that's just because, y'know, ChatGPT can write sonnets and translate Korean to Swahili and whatnot. It's amazingly broad, but it's not the right tool for the comparatively narrow problem of code generation.

(..I guess? I don't think any of it is public - one might naively suppose that by now it's actually using only a subset of ChatGPT's MoEs, or something, but who knows?)

I can't tell in a pull request what someone wrote themselves, or to what level of detail they have pre-reviewed the AI code which is now part of the pull request before allowing it to get to me. I can tell you I don't want to be fixing someone else's AI generated bugs though... Especially given that AI writes more/less dry/more verbose code, and increases code churn in general.

[edit] unfortunately I think I need to point out the above is sarcasm. Because there really are people using AI to review AI-generated code, and they do not see the problem with this approach.

After being stuck on a project with a few of them recently, I've started to figure it out.

They know they are incompetent, and are afraid of being around competent people who would call them out. So they link up with other likewise incompetents to maintain a diffusion of responsibility, so the finger can't be pointed at any one person. And when the system they are building inevitably fails horribly, management can't really fire the whole team. So they bumble along and create "make work" tickets to fill time and look like something is happening, or they spend their time "fixing" things that should have never existed in the first place by layering mountains of hacks on top, rather than reassessing anything or asking for help. Rinse and repeat once the project has clearly failed or been abandoned.

The way I see it is that OP can either complain about customers being annoying, which will happen whether or not OP does anything about his problem, or OP could proactively produce something to make their product better for the demographic they're targeting. At this point it's pretty clear that the users would rather be helped than help themselves, so meeting them where they're at is going to be more productive than trying to educate them on why they suck at both coding and asking for help (or free work).

A lot of businesses are going to either think they can have generative AI create all of their apps with the help of a cousin of the wife of the accountant, or they unknowingly contract a 10x developer from Upwork or alike who uses generative AI to create everything. Once they realize how well that's working out, the smart ones will start from scratch, the not-so-smart will attempt to fix it.

Develop a reputation for yourself for getting companies out of that pickle, and you can probably retire early.

I suspect this quickly will be like specializing in the repair of cheap, Chinese made desk lamps from Walmart.

If the cheap desk lamp breaks, you don't pay someone to fix it. You buy another one and often it will be a newer , better model. That is the value proposition.

Of course, the hand crafted, high end desk lamp will be better but if you just want some light, for many use cases, the cheap option will be good enough.

The real savvy ones will use later generations of LLMs to fix the output of early ones

Cheap version offers minimal support. (Although you still have to sift "bug reports" into my problem/ your problem.)

Standard version allows for more support (but still rate limited.)

Developer version charges for time spent, in advance.

This helps because people only expect free support if you don't explicitly offer something else. If you offer paid support them it's reasonable and expected that there are limits on free support.

AI is a great tool to help someone start an idea. When it goes past that, please don't ask us for help until you know what the code is doing that you just generated.

If someone asked "I wrote some rough designs and interfaces, can you write me an app for free?" The author could easily detect it as a request for free work. But because the first part is hidden behind some ChatGPT generated code and the second part is disguised as a request for help, the author would be tricked into doing this free work, until they detected this pattern and write a blog post about it.

So what was a difficult problem can quickly become insurmountable.

in volume, this turns into support writing the code.

I think of how the south park movie folks sent so much questionable content to the censors that the compromise in the end let through lots of the puppet sex.

There's been multiple stories and posts here on HN about issues with AI generated PRs for open source repos because of people using them to game numbers or clout. This is a similar problem where you have a bunch of people using your API and then effectively trying to use you for free engineering work.

On the other hand, I look around the room I am in and it is filled mostly with "low quality" Chinese made products. While you can't compare these products to expensive, expertly crafted, high end products, there is another scaling law at play when it comes to price. The low quality Chinese products are so cheap that I don't even consider the more expensive options. When the low quality desk lamp is close enough and 20x cheaper than the well made desk lamp, there is no decision point for me.

If it breaks, I will just buy another one.

The single best thing to help someone in my place is clear and coherent documentation with working examples. It's how I learned to use Turbo Pascal so long ago, and generally the quickest way to get up to speed. It's also my biggest gripe with Free Pascal... their old help processing infrastructure binds them to horrible automatically generated naming of parameters as documentation, and nothing more.

Fortunately, CoPilot doesn't get impatient, and I know this, so I can just keep pounding away at things until I get something close to what I want, in spite of myself. ;-)

I think amateur "trading" attracts a specific brand of idiot that is high/left on the Dunning Kruger curve. While taking money from idiots is a viable (even admirable) business strategy, you may want to fully automate customer service to retain your sanity.

[0]: https://news.ycombinator.com/item?id=41308599

I can also generate random data that looks like any distribution by carefully choosing the random distribution. What's their point?