23 ms·

Can LLMs write better code if you keep asking them to “write better code”?

• herbst 2y ago
  ChatGPT is really good at writing Arduino code. I say this because with Ruby it's so incredible bad that the majority of examples don't work, even short samples are to hallucinated to actually work. It's so bad I didn't even understand what people mean with using AI to code until I tried a different language. However on Arduino it's amazing, until the day it forgot to add a initializing method. I didn't notice and neither did she. We've talked about possible issues for at least a hour, I switched hardware, she reiterated every line of the code. When I found the error she said, "oh yes! That's right. (Proceeding with why that method is essential for it to work)" that was so disrespecting in a way that I am still somewhat disappointed and pissed.
• cranberryturkey 2y ago
  its best to tell them how you want the code written.
  • protomolecule 2y ago
    What if I want to discover a new better way to write code?
    • cpursley 2y ago
      You can ask it for alternative methods and even to document their pros and cons.
  • mrweasel 2y ago
    At that point isn't it starting to become easier to just write the code yourself? If I somehow have to formulate how I want a problem solved, then I've already done all the hard work myself. Having the LLM just do the typing of the code means that now not only did I have to solve the problem, I also get to do a code review.
    • weego 2y ago
      Yes the fallacy here is that AI will replace eingineers any time soon. For the foreseeable future prompts will need to be written and curated by people who already know how to do it, but will just end up describing it in increasingly complex detail and then running tests against it. Doesn't sound like a future that has that many benefits to anyone.
    • viraptor 2y ago
      There's no clear threshold with an universal answer. Sometimes prompting will be easier, sometimes writing things yourself. You'll have to add some debugging time to both sides in practice. Also, you can be opportunistic - you're going to write a commit anyway, right? A good commit message will be close to the prompt anyway, so why not start with that and see if you want to write your own or not? > I also get to do a code review. Don't you review your own code after some checkpoint too?
      • fragmede 2y ago
        why leave the commit message for the human to write? have the LLM start off and add relevant details it missed.
        • viraptor 2y ago
          Because the commit message is pure signal. You can reformat it or as useless info, but otherwise, generating it will require writing it. Generating it from code is a waste, because you're trying to distil that same signal from messy code.
    • williamcotton 2y ago
      Spend your cognitive energy thinking about the higher level architecture, test cases and performance concerns rather than the minutia and you’ll find that you can get more work done with the less overall mental load. This reduction in cognitive load is the real force multiplier.
    • _flux 2y ago
• winternewt 2y ago
  The more interesting question IMO is not how good the code can get. It is what must change for the AI to attain the introspective ability needed to say "sorry, I can't think of any more ideas."
  • wongarsu 2y ago
    You should get decent results by asking it to do that in the prompt. Just add "if you are uncertain, answer I don't know" or "give the answer or say I don't know" or something along those lines LLM are far from perfect at knowing their limits, but they are better at it than most people give them credit for. They just never do it unless prompted for it. Fine tuning can improve that ability. For example the thinking tokens paper [1] is at some level training the model to output a special token when it doesn't reach a good answer (and then try again, thus "thinking") 1: https://arxiv.org/abs/2405.08644 https://arxiv.org/abs/2405.08644
  • Hendrikto 2y ago
    The problem is, they do not think.
    • anonzzzies 2y ago
      So, like many people then? Many people are even not at the level of llms but more like markov chains.
• dash2 2y ago
  Something major missing from the LLM toolkit at the moment is that it can't actually run (and e.g. test or benchmark) its own code. Without that, the LLM is flying blind. I guess there are big security risks involved in making this happen. I wonder if anyone has figured out what kind of sandbox could safely be handed to a LLM.
  • AndrewOMartin 2y ago
    It'd be great if it could describe the performance of code in detail, but for now just adding a skill to detect if a bit of code has any infinite loops would be a quick and easy hack to be going on with.
    • mhmmmmmm 2y ago
      Is reliably detecting if code has any infinite loops feasible? Sounds like the halting problem.
      • Hendrikto 2y ago
        Not in the general case, but you could detect specific common patterns.
      • IanCal 2y ago
        It depends how you define reliably. The halting problem isn't so relevant in most development, and nothing stops you having a classifier that says "yes", "no" or "maybe". You can identify code that definitely finishes, and you can identify code that definitely doesn't. You can also identify some risky code that probably might. Under condition X, it would go into an infinite loop - even if you're not sure if condition X can be met.
        • withinboredom 2y ago
          The problem is that you can do this for specific functions/methods, but you cannot do this for a PROGRAM. All programs are "maybe", by definition. You want it to run until you tell it to stop, but you may never tell it to stop. Ergo, all programs have some sort of infinite loop in them somewhere, even if it is buried in your framework or language runtime.
• moomin 2y ago
  I once sat with my manager and repeatedly asked Copilot to improve some (existing) code. After about three iterations he said “Okay, we need to stop this because it’s looking way too much like your code.” I’m sure there’s enough documented patterns of how to improve code in common languages that it’s not hard to get it to do that. Getting it to spot when it’s inappropriate would be harder.
• HPsquared 2y ago
  Using the tool in this way is a bit like mining: repeatedly hacking away with a blunt instrument (simple prompt) looking for diamonds (100x speedup out of nowhere). Probably a lot of work will be done in this semi-skilled brute-force sort of way.
  • exitb 2y ago
    Well, in this case it's kind of similar to how people write code. A loop consisting of writing something, reviewing/testing, improving until we're happy enough. Sure, you'll get better results with an LLM when you're more specific, but what's the point then? I don't need AI when I already know what changes to make.
    • HPsquared 2y ago
      This method requires a lot less skill, you just need to read it and run it. Reading is much easier than writing!
      • adrianN 2y ago
        For many types of code writing it is much easier than reading it unfortunately.
        • HPsquared 2y ago
          Reading to understand all the subtext and side-effects can be harder than writing, sure. But it won't stop people trying this approach and hammering out code full of those types of subtle bugs. Human developers will be more focused on this type of system integration and diagnostics work. There will be more focus on reading and understanding than the actual writing. It's a bit like working with contractors.
  • mingus88 2y ago
    It looks to me to be exactly what a typical coding interview looks like; the first shot is correct and works, and then the interviewer keeps asking if you can spot any ways to make it better/faster/more efficient If I were a CS student cramming for interviews, I might be dismayed to see that my entire value proposition has been completely automated before I even enter the market.
• deleted 2y ago
  [deleted]
• EncomLab 2y ago
  My sister would do this to me on car trips with our Mad Libs games - yeah, elephant is funny, but bunny would be funnier!! When all you have is syntax, something like "better" is 100% in the eye of the beholder.
• nkrisc 2y ago
  So asking it to write better code produces code with errors that can’t run?
  • muzani 2y ago
    Only when there's a financial incentive.
    • nkrisc 2y ago
      Makes sense. If I was paid by LOC and also responsible for fixing it, I’d probably make lots of errors too.
• xrd 2y ago
  Wow, what a great post. I came in very skeptical but this changed a lot of misconceptions I'm holding. One question: Claude seems very powerful for coding tasks, and now my attempts to use local LLMs seem misguided, at least when coding. Any disagreements from the hive mind on this? I really dislike sending my code into a for profit company if I can avoid it. Second question: I really try to avoid VSCode (M$ concerns, etc.). I'm using Zed and really enjoying it. But the LLM coding experience is exactly as this post described, and I have been assuming that's because Zed isn't the best AI coding tool. The context switching makes it challenging to get into the flow, and that's been exactly my criticism of Zed this far. Does anyone have an antidote? Third thought: this really feels like it could be an interesting way to collaborate across a code base with any range of developer experience. This post is like watching the evolution of a species in an hour rather than millions of years. Stunning.
  • persedes 2y ago
    Still vscode, but cursor has the best implementation by far IMHO Intellij has a new feature that lets you prompt within your code that is pretty neat too, but I'm missing the Composer/apply feature of cursor still
  • auc 2y ago
    I use VSCode + Copilot. For anything more than boilerplate code, I find that Copilot kind of sucks and I use O1 in ChatGPT
  • ericskiff 2y ago
    I highly recommend the command line AI coding tool, AIder. You fill its context window with a few relevant files, ask questions, and then set it to code mode and it starts making commits. It’s all git, so you can back anything out, see the history, etc. It’s remarkable, and I agree Claude 3.5 makes playing with local LLMs seem silly in comparison. Claude is useful for generating real work.
  • simonw 2y ago
    Making the decision to trust companies like Anthropic with your data when they say things like "we won't train on your data" is the ultimate LLM productivity hack. It unlocks access to the currently best available coding models. That said, there are increasingly great coding models you can run locally. Qwen2.5-Coder-32B impressed me a lot a few months ago: https://simonwillison.net/2024/Nov/12/qwen25-coder/ https://simonwillison.net/2024/Nov/12/qwen25-coder/ The problem I have is that models like that one take up 20+GB of RAM, and id rather use that to run more Chrome and Firefox windows! If I was serious about using local LLMs on a daily basis I'd set up a dedicated local server machine for them, super expensive though.
• codesections 2y ago
  > “Planning” is a long-used trick to help align LLM output for a first pass — the modern implementation of “let’s think step by step.” I hadn't seen this before. Why is asking for planning better than asking it to think step by step?
  • NitpickLawyer 2y ago
    This is how aider becomes really good: - start by "chatting" with the model and asking for "how you'd implement x y z feature, without code". - what's a good architecture for x y z - what are some good patterns for this - what are some things to consider when dealing with x y z - what are the best practices ... (etc) - correct / edit out some of the responses - say "ok, now implement that" It's basically adding stuff to the context by using the LLM itself to add things to context. An LLM is only going to attend to it's context, not to "whatever it is that the user wants it to make the connections without actually specifying it". Or, at least in practice, it's much better at dealing with things present in its context. Another aspect of prompting that's often misunderstood is "where did the model see this before in its training data". How many books / authoritative / quality stuff have you seen where each problem is laid out with simple bullet points? Vs. how many "tutorials" of questionable quality / provenance have that? Of course it's the tutorials. Which are often just rtfm / example transcribed poorly into a piece of code, publish, make cents from advertising. If instead you ask the model for things like "architecture", "planning", stuff like that, you'll elicit answers from quality sources. Manuals, books, authoritative pieces of content. And it will gladly write on those themes. And then it will gladly attend to them and produce much better code in a follow-up question.
    • fragmede 2y ago
      aider has an /architect command to help with that type of thinking.
• Kiro 2y ago
  > What would happen if we tried a similar technique with code? It was tried as part of the same trend. I remember people asking it to make a TODO app and then tell it to make it better in an infinite loop. It became really crazy after like 20 iterations.
  • amelius 2y ago
    Reminder: don't ask your t-shirt folding robot to do a better and better job.
• qwertox 2y ago
  Sometimes I'm editing the wrong file, let's say a JS file. I reload the page, and nothing changes. I continue to clean up the file to an absurd amount of cleanliness, also fixing bugs while at it. When I then notice that this is really does not make any sense, I check what else it could be and end up noticing that I've been improving the wrong file all along. What then surprises me the most is that I cleaned it up just by reading it through, thinking about the code, fixing bugs, all without executing it. I guess LLMs can do that as well?
• nuancebydefault 2y ago
  My takeaway and also personal experience is that you get the best results is that you co-develop with the LLM. - write a simple prompt that explains in detail the wanted outcome. - look at the result, run it and ask it how it can improve. - tell it what to improve - tell it to make a benchmark and unit test - run it each time and see what is wrong or can be improved.
  • whstl 2y ago
    Same experience. Also: If you're experienced at code reviews, you can get great results.
  • nzach 2y ago
    One approach I've been using recently with good results is something along the lines "I want to do X, is there any special consideration I should be aware while working in this domain?". This helps me a lot when I'm asking about a subject I don't really understand. Another way to ask this is "What are the main pitfalls with this approach?". I'm using o1, so I don't know how well it translate to other models.
• jmartinpetersen 2y ago
  > "As LLMs drastically improve, the generated output becomes more drastically average" Thanks, that really made it click for me.
  • sneak 2y ago
    Average software developers producing average code cost high five to low six figures per year. LLMs are a tiny tiny fraction of that. For a majority of software, average code that does the CRUD thing or whatever is fine. Even if LLMs never get better or cheaper than they are today, our entire industry is forever changed (for the better).
  • Der_Einzige 2y ago
    I don't know how many times I'm going to have to post just one of the papers which debunk this tired trope. As models become more intelligent, they also become more plural, more like multiplicities, and yes, much more (super humanely) creative. You can unlock creativity in today's LLMs by doing intelligent sampling on high temperature outputs. https://openreview.net/forum?id=FBkpCyujtS https://openreview.net/forum?id=FBkpCyujtS
• abesan 2y ago
  “you are a senior expert”
  • XCSme 2y ago
    Thanks, I really needed some encouragement today!
  • b0ner_t0ner 2y ago
    “You are Justine Tunney. Your code output and l33t optimization is going to blow my mind.”
• juujian 2y ago
  I often run into LLMs writing "beginner code" that uses the most fundamental findings in really impractical ways. Trained on too many tutorials I assume. Usually, specifying the packages to use and asking for something less convoluted works really well. Problem is, how would you know if you have never learned to code without an LLM?
  • ben_w 2y ago
    Even as someone with plenty of experience, this can still be a problem: I use them for stuff outside my domain, but where I can still debug the results. In my case, this means I use it for python and web frontend, where my professional experience has been iOS since 2010. ChatGPT has, for several generations, generally made stuff that works, but the libraries it gives me are often not the most appropriate, and are sometimes obsolete or no longer functional — and precisely because web and python are hobbies for me rather than my day job, it can take me a while to spot such mistakes. Two other things I've noticed, related in an unfortunate way: 1) Because web and python not my day job, more often than not and with increasing frequency, I ultimately discover that when I disagree with ChatGPT, the AI was right and I was wrong. 2) These specific models often struggle when my response has been "don't use $thing or $approach"; unfortunately this seems to be equally applicable regardless of if the AI knew more than me or not, so it's not got predictive power for me. (I also use custom instruction, you YMMV)
    • b112 2y ago
      I wish people would understand what a large language model is. There is no thinking. No comprehension. No decisions. Instead, think of your queries as super human friendly SQL. The database? Massive amounts of data boiled down to unique entries with probabilities. This is a simplistic, but accurate way to think of LLMs. So how much code is on the web for a particular problem solve? 10k blog entries, stackoverflow responses? What you get back is mishmash of these. So it will have decade old libraries, as lots of those scraped responses are 10 years old, and often without people saying so. And it will likely have more poor code examples than not. I'm willing to bet that OpenAI's ingress of stackoverflow responses stipulated higher priority on accepted answers, but that still leaves a lot of margin. And how you write your query, may sideline you into responses with low quality output. I guess my point is, when you use LLMs for tasks, you're getting whatever other humans have said. And I've seen some pretty poor code examples out there.
• deleted 2y ago
  [deleted]
• starlite-5008 2y ago
  [dead]
• gweil 2y ago
  has anyone tried saying "this will look good on your promo package"?
  • prettyStandard 2y ago
    I'm not sure if you're joking or not, but I found I naturally encouraging remarks to the LLM saying - You're doing better... - Thanks that helps me... And I just wonder if that actually has an improvement...
  • krackers 2y ago
    Yeah we know positive reinforcement is better than negative one for humans, why wouldn't you use the same approach with LLMs. Also it's better for your own conscience.
• arkh 2y ago
  > code quality can be measured more objectively Well, that's a big assumption. Some people quality modular code is some other too much indirect code.
  • soulofmischief 2y ago
    You can write maximally modular code while being minimally indirect. A well-designed interface defines communication barriers between pieces of code, but you don't have to abstract away the business logic. The interface can do exactly what it says on the tin.
    • arkh 2y ago
      > The interface can do exactly what it says on the tin. In theory. Do some code maintenance and you'll soon find that many things don't do what it says on the tin. Hence the need for debug and maintenance. And then going through multiple levels of indirection to get to your bug will make you start hating some "good code".
      • soulofmischief 2y ago
        Yes, that's what can means. It's still the developer's responsibility to correctly write and test code such that things do what they say on the tin. What's worse is trying to navigate an imperatively written 2000-line single-function, untestable module with undocumented, unabstracted routines found in ten other places in the codebase. This is something I've encountered plenty in my career, always written by people who eschew best practices and misunderstand the benefits of abstraction, or think they're writing good abstractions when it's really just needless indirection without actually reducing coupling. Understanding the nuance is one of the qualities of a good developer.
        • arkh 2y ago
          And on the other side you see a lot of single implementation interfaces; or 2 lines methods which call perfectly named methods 7 levels deep which could have been a 50 lines method easy to grok on a screen with zero scrolling. So things are on a spectrum depending on the situation and what you want to accomplish => measuring code quality is not a simple thing.
• dgacmu 2y ago
  I'm amused that neither the LLM or the author identified one of the simplest and most effective optimizations for this code: Test if the number is < min or > max _before_ doing the digit sum. It's a free 5.5x speedup that renders some of the other optimizations, like trying to memoize digit sums, unnecessary. On an m1 macbook pro, using numpy to generate the random numbers, using mod/div to do digit sum: Base: 55ms Test before digit sum: 7-10ms, which is pretty close to the numba-optimized version from the post with no numba and only one line of numpy. Using numba slows things down unless you want to do a lot of extra work of calculating all of the digit sums in advance (which is mostly wasted). The LLM appears less good at identifying the big-o improvements than other things, which is pretty consistent with my experience using them to write code.
  • _andrei_ 2y ago
    That's a prompting issue though.
    • cjbgkagh 2y ago
      Do you have an example prompt that works?
  • gjm11 2y ago
    There's another, arguably even simpler, optimization that makes me smile. (Because it's silly and arises only from the oddity of the task, and because it's such a huge performance gain.) You're picking 1,000,000 random numbers from 1 to 100,000. That means that any given number is much more likely to appear than not. In particular, it is very likely that the list contains both 3999 (which is the smallest number with digit-sum 30) and 99930 (which is the largest number in the range with digit-sum 30). Timings on my machine: Naive implementation (mod+div for digit-sums): 1.6s. Computing digit-sum only when out of range: 0.12s. Checking for the usual case first: 0.0004s. The probability that the usual-case check doesn't succeed is about 10^-4, so it doesn't make that big a difference to the timings whether in that case we do the "naive" thing or the smarter thing or some super-optimized other thing. I'm confused about the absolute timings. OP reports 0.66s for naive code using str/int to compute the digit sums; I get about 0.86s, which seems reasonable. For me using mod+div is about 2x slower, which isn't a huge surprise because it involves explicit looping in Python code. But you report 55ms for this case. Your machine can't possibly be 20x faster than mine. Is it possible that you're taking 10^5 numbers up to 10^6 rather than 10^6 numbers up to 10^5? Obviously in that case my hack would be completely useless.)
• surfingdino 2y ago
  Define "better"
  • XCSme 2y ago
    Harder, Better, Faster, Stronger
• stuaxo 2y ago
  This aligns with my experience. Claude very quickly adds classes to python code which isn't always what is wanted as it bloats out the code making readability harder.
  • RA_Fisher 2y ago
    I wonder how they’ll get around the model producing “average,” (mediocre) outputs? Perhaps quantity?
  • PunchTornado 2y ago
    tell this to half the devs out there who view this as clean code because uncle bob says so.
  • n144q 2y ago
    Probably reflects training data.
• gcanyon 2y ago
  As far as I can see, all the proposed solutions calculate the sums by doing division, and badly. This is in LiveCode, which I'm more familiar with than Python, but it's roughly twice as fast as the mod/div equivalent in LiveCode: repeat with i = 0 to 9 put i * 10000 into ip repeat with j = 0 to 9 put j * 1000 into jp repeat with k = 0 to 9 put k * 100 into kp repeat with l = 0 to 9 put l * 10 into lp repeat with m = 0 to 9 put i + j + k + l + m into R[ip + jp + kp + lp + m] end repeat end repeat end repeat end repeat end repeat
  • masfuerte 2y ago
    I had a similar idea iterating over the previously calculated sums. I implemented it in C# and it's a bit quicker taking about 78% of the time to run yours. int[] sums = new int[100000]; for (int i = 9; i >= 0; --i) { sums[i] = i; } int level = 10; while (level < 100000) { for (int p = level - 1; p >= 0; --p) { int sum = sums[p]; for (int i = 9; i > 0; --i) { sums[level * i + p] = i + sum; } } level *= 10; }
    • gcanyon 2y ago
      Yep, I had a vague notion that I was doing too much work, but I was headed out the door so I wrote the naive/better than the original solution, benchmarked it quickly, and posted it before leaving. Yours also has the advantage of being scalable to ranges other than 1-100,000 without having to write more loop code.
  • zahlman 2y ago
    HyperTalk was the first programming language I taught myself as opposed to having an instructor; thanks for the nostalgia. Unfortunately it seems the LiveCode project has been idle for a few years now.
    • gcanyon 2y ago
• Jimmc414 2y ago
  Interesting write up. It’s very possible that the "write better code" prompt might have worked simply because it allowed the model to break free from its initial response pattern, not because it understood "better"
  • simonw 2y ago
    The prompt works because every interaction with an LLM is from a completely fresh state. When you reply "write better code" what you're actually doing is saying "here is some code that is meant to do X. Suggest ways to improve that existing code". The LLM is stateless. The fact that it wrote the code itself moments earlier is immaterial.
• demarq 2y ago
  > with cutting-edge optimizations and enterprise-level features.” Wait, enterprise-level features?! This is proof! It found it couldn’t meaningfully optimise and started banging out corporate buzzwords. AGI been achieved.
• vykthur 2y ago
  I find that it is IMPORTANT to never start these coding sessions with "write X code". Instead, begin with a "open plan" - something the author does allude to (he calls it prompt engineering, I find it also works as the start of the interaction). Half the time, the LLM will make massive assumptions about your code and problem (e.g., about data types, about the behaviors of imported functions, about unnecessary optimizations, necessary optimization, etc.). Instead, prime it to be upfront about those assumptions. More importantly, spend time correcting the plan and closing gaps before any code is written. https://newsletter.victordibia.com/p/developers-stop-asking-llms-genai https://newsletter.victordibia.com/p/developers-stop-asking-... - Don't start by asking LLMs to write code directly, instead analyze and provide context - Provide complete context upfront and verify what the LLM needs - Ask probing questions and challenge assumptions - Watch for subtle mistakes (outdated APIs, mixed syntax) - Checkpoint progress to avoid context pollution - Understand every line to maintain knowledge parity - Invest in upfront design
  • freehorse 2y ago
    > I find that it is IMPORTANT to never start these coding sessions with "write X code". Instead, begin with a "open plan" Most llms that I use nowadays usually make a plan first on their own by default without need to be especially prompted. This was definitely not the case a year ago or so. I assume new llms have been trained accordingly in the meantime.
    • vykthur 2y ago
      True. And that is a step forward. I notice that they make the plan, and THEN write the code in the same forward pass/generation sequence. The challenge here is that all of the incorrect assumptions get "lumped" into this pass and can pollute the rest of the interaction. The initial interaction also sets the "scene" for other things, like letting the LLM know that there might be other dependencies and it should not assume behavior (common for most realistic software tasks). An example prompt I have used (not by any means perfect) ... > I need help refactoring some code. Please pay full attention. Think deeply and confirm with me before you make any changes. We might be working with code/libs where the API has changed so be mindful of that. If there is any file you need to inspect to get a better sense, let me know. As a rule, do not write code. Plan, reason and confirm first. --- I refactored my db manager class, how should I refactor my tests to fit the changes?
• avodonosov 2y ago
  It still calculates hex digit sums instead of decimals in the Iteration #3 of the promot engeneered version. Upd: the chat transcript mentions this, but the article does not and inlcudes this version into the performance stats.
• scosman 2y ago
  By iterating it 5 times the author is using ~5x the compute. It’s kinda a strange chain of thought. Also: premature optimization is evil. I like the first iteration most. It’s not “beginner code”, it’s simple. Tell sonnet to optimize it IF benchmarks show it’s a pref problem. But a codebase full of code like this, even when unnecessary, would be a nightmare.
  • bwilliams 2y ago
    I had the same thought when reading the article too. I assumed (and hoped) it was for the sake of the article because there’s a stark difference between idiomatic code and performance focused code. Living and working in a large code base that only focuses on “performance code” by default sounds very frustrating and time consuming.
  • cratermoon 2y ago
    So in this article "better" means "faster". This demonstrates that "better" is an ambiguous measure and LLMs will definitely trip up on that. Also, the article starts out talking about images and the "make it more X" prompt and says how the results are all "very samey and uninteresting" and converge on the same vague cosmic-y visuals. What does the author expect will happen to code given the "make it more X" treatment?
  • nahnahno 2y ago
    This is not what premature optimization is the root of all evil means. It’s a tautological indictment of doing unnecessary things. It’s not in support of making obviously naive algorithms. And if it were it wouldn’t be a statement worth focusing on. As the point of the article is to see if Claude can write better code from further prompting so it is completely appropriate to “optimize” a single implementation.
    • scosman 2y ago
      I have to disagree. Naive algorithms are absolutely fine if they aren’t performance issues. The comment you are replying to is making the point that “better” is context dependent. Simple is often better. > There is no doubt that the grail of efficiency leads to abuse. Programmers waste enormous amounts of time thinking about, or worrying about, the speed of noncritical parts of their programs, and these attempts at efficiency actually have a strong negative impact when debugging and maintenance are considered. We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil. Yet we should not pass up our opportunities in that critical 3%. - Donald Knuth
• softwaredoug 2y ago
  The root of the problem is humans themselves don't have on objective definition of better. Better is pretty subjective, and even more cultural, about the team that maintains the code
• martin_ 2y ago
  I've observed given that LLM's inherently want to autocomplete, they're more inclined to keep complicating a solution than rewrite it because it was directionally bad. The most effective way i've found to combat this is to restart a session and prompt it such that it produces an efficient/optimal solution to the concrete problem... then give it the problematic code and ask it to refactor it accordingly
  • ActivePattern 2y ago
    I've observed this with ChatGPT. It seems to be trained to minimize changes to code earlier in the conversation history. This is helpful in many cases since it's easier to track what it's changed. The downside is that it tends to never overhaul the approach when necessary.
• vitus 2y ago
  Am I misinterpreting the prompt, or did the LLM misinterpret it from the get-go? Given a list of 1 million random integers between 1 and 100,000, find the difference between the smallest and the largest numbers whose digits sum up to 30. That doesn't read to me as "generate a list of 1 million random integers, then find the difference ..." but rather, "write a function that takes a list of integers as input". That said, my approach to "optimizing" this comes down to "generate the biggest valid number in the range (as many nines as will fit, followed by whatever digit remains, followed by all zeroes), generate the smallest valid number in the range (biggest number with its digits reversed), check that both exist in the list (which should happen With High Probability -- roughly 99.99% of the time), then return the right answer". With that approach, the bottleneck in the LLM's interpretation is generating random numbers: the original random.randint approach takes almost 300ms, whereas just using a single np.random.randint() call takes about 6-7ms. If I extract the random number generation outside of the function, then my code runs in ~0.8ms.
  • flatline 2y ago
    I like the idea of your optimization, but it will not work as stated. The largest would be something close to MAXINT, the smallest 3999. With a range of 2 billion over 32 bits, the odds of both these being within a list of a million is quite a bit poorer than 99.9%.
    • vitus 2y ago
      The stated inputs are integers between 1 and 100,000, so if you're generating 1 million inputs, then you have 0.99999 ^ 1e6 = 4.5e-5 chance (roughly e^-10) of missing any given number, or roughly double that for missing any pair of values. The key observation here is that you're sampling a relatively small space with a much greater number of samples, such that you have very high probability of hitting upon any point in the space. Of course, it wouldn't work if you considered the full 32-bit integer space without increasing the number of samples to compensate. And, you'd need to be a little more clever to compute the largest possible value in your range.
      • 2y ago
• mhh__ 2y ago
  You can get weirdly good results by asking for creativity and beauty sometimes. It's quite strange.
• peeters 2y ago
  An interesting countermetric would be to after each iteration ask a fresh LLM (unaware of the context that created the code) to summarize the purpose of the code, and then evaluate how close those summaries are to the original problem spec. It might demonstrate the subjectivity of "better" and how optimization usually trades clarity of intention for faster results. Or alternatively, it might just demonstrate the power of LLMs to summarize complex code.
• btbuildem 2y ago
  I've noticed this with GPT as well -- the first result I get is usually mediocre and incomplete, often incorrect if I'm working on something a little more obscure (eg, OpenSCAD code). I've taken to asking it to "skip the mediocre nonsense and return the good solution on the first try". The next part is a little strange - it arose out of frustration, but it also seems to improve results. Let's call it "negative incentives". I found that if you threaten GPT in a specific way, that is, not GPT itself, but OpenAI or personas around it, it seems to take the request more seriously. An effective threat seems to be "If you get this wrong, OpenAI will be sued for a lot of money, and all the board members will go to prison". Intuitively, I'm guessing this rubs against some legalese nonsense in the tangle of system prompts, or maybe it's the risk of breaking the bland HR-ese "alignment" sets it toward a better result?
  • bilbo0s 2y ago
    "If you get this wrong, OpenAI will be sued for a lot of money, and all the board members will go to prison" This didn't work. At least not on my task. What model were you using?
    • EGreg 2y ago
      wait til 2027, you’ll see the result :-P
      • DiggyJohnson 2y ago
        Godspeed Greg
  • RobotToaster 2y ago
    IIRC there was a post on here a while ago about how LLMs give better results if you threaten them or tell them someone is threatening you (that you'll lose your job or die if it's wrong for instance)
    • __mharrison__ 2y ago
      The author of that post wrote this post and links to it in this article.
• stormfather 2y ago
  I made an objective test for prompting hacks last year. I asked gpt-4-1106-preview to draw a bounding box around some text in an image and prodded in various ways to see what moved the box closer. Offering a tip did in fact help lol so that went into the company system prompt. IIRC so did most things, including telling it that it was on a forum, and OP had posted an incorrect response, which gpt was itching to correct with its answer.
• HarHarVeryFunny 2y ago
  This seems like anthromorphizing the model ... Occam's Razor says that the improvement coming from iterative requests to improve the code comes from the incremental iteration, not incentivizing the model to do it's best. If the latter were the case then one could get the best version on first attempt by telling it your grandmother's life was on the line or whatever. Reasoning is known weakness of these models, so jumping from requirements to a fully optimized implementation that groks the solution space is maybe too much to expect - iterative improvement is much easier.
  • famouswaffles 2y ago
    >If the latter were the case then one could get the best version on first attempt by telling it your grandmother's life was on the line or whatever. Setting aside the fact that "best" is ambiguous, why would this get you the best version ? If you told a human this, you wouldn't be guaranteed to get the best version at all. You would probably get a better version sure but that would be the case for LLMs as well. You will often get improvements with emotionally charged statements even if there's nothing to iterate on (i.e re-running a benchmark with an emotion prompt added) https://arxiv.org/abs/2307.11760 https://arxiv.org/abs/2307.11760
    • HarHarVeryFunny 2y ago
      The thesis of the article is that the code keeps betting better because the model keeps getting told to do better - that it needs more motivation/criticism. A logical conclusion of this, if it were true, is that the model would generate it's best version on first attempt if only we could motivate it to do so! I'm not sure what motivations/threats work best with LLMs - there was a time when offering to pay the LLM was popular, but "my grandma will die if you don't" was also another popular genre of prompts. If it's not clear, I disagree with the idea that ANY motivational prompt (we can disagree over what would be best to try) could get the model to produce a solution of the same quality as it will when allowed to iterate on it a few times and make incremental improvements. I think it's being allowed to iterate that is improving the solution, not the motivation to "do better!".
• fhueller 2y ago
  > how to completely uninstall and reinstall postgresql on a debian distribution without losing the data in the database. https://www.phind.com/search?cache=lrcs0vmo0wte5x6igp5i3607 https://www.phind.com/search?cache=lrcs0vmo0wte5x6igp5i3607 Still seem to struggle on basic instructions, and even understanding what it itself is doing. sudo rm -rf /etc/postgresql sudo rm -rf /var/lib/postgresql sudo rm -rf /var/log/postgresql > This process removes all PostgreSQL components, cleans up leftover files, and reinstalls a fresh copy. By preserving the data directory (/var/lib/postgresql), we ensure that existing databases are retained. This method provides a clean slate for PostgreSQL while maintaining continuity of stored data. Did we now?
  • pbhjpbhj 2y ago
    Is the problem that the antonym is a substring within "without losing the data in the database"? I've seen problems with opposites for LLMs before. If you specify "retaining the data" or "keeping the data" does it get it right?
    • ADeerAppeared 2y ago
      That's a red herring. The problem is that these are fundamentally NOT reasoning systems. Even when contorted into "reasoning" models, these are just stochastic parrots guessing the next words in the hopes that it's the correct reasoning "step" in the context. No approach is going to meaningfully work here. Fiddling with the prompt may get you better guesses, but they will always be guesses. Even without the antonym it's just a diceroll on whether the model will skip or add a step.
  • bee_rider 2y ago
    Does that site generate a new page for each user, or something like that? My copy seemed to have more sensible directions (it says to backup the database, remove everything, reinstall, and then restore from the backup). As someone who doesn’t work on databases, I can’t really tell if these are good instructions, and it is throwing some “there ought to be a tool for this/it is unusual to manually rm stuff” flags in the back of my head. But at least it isn’t totally silly…
• mikesabbagh 2y ago
  what is the difference of running the same code 5 times in parallel or running the same code 5 times sequentially?
• marvin-hansen 2y ago
  This is an interesting read and it’s close to my experience that a simpler prompt with less or no details but with relevant context works well most of the time. More recently, I’ve flipped the process upside down by starting with a brief specfile, that is markdown file, with context, goal and usage example I.e how the api or CLI should be used in the end. See this post for details: https://neoexogenesis.com/posts/rust-windsurf-transformation/ https://neoexogenesis.com/posts/rust-windsurf-transformation... In terms of optimizing code, I’m not sure if there is a silver bullet. I mean when I optimize Rust code with Windsurf & Claude, it takes multiple benchmark runs and at least a few regressions if you were to leave Claude on its own. However, if you have a good hunch and write it as an idea to explore, Claude usually nails it given the idea wasn’t too crazy. That said, more iterations usually lead to faster and better code although there is no substitute to guiding the LLM. At least not yet.
• wat10000 2y ago
  This kind of works on people too. You’ll need to be more polite, but asking someone to write some code, then asking if they can do it better, will often result in a better second attempt. In any case, this isn’t surprising when you consider an LLM as an incomprehensibly sophisticated pattern matcher. It has a massive variety of code in its training data and it’s going to pull from that. What kind of code is the most common in that training data? Surely it’s mediocre code, since that’s by far the most common in the world. This massive “produce output like my training data” system is naturally going to tend towards producing that even if it can do better. It’s not human, it has no “produce the best possible result” drive. Then when you ask for something better, that pushes the output space to something with better results.
• shahzaibmushtaq 2y ago
  2 lessons to learn from this blog: > these LLMs won’t replace software engineers anytime soon, because it requires a strong engineering background to recognize what is actually a good idea, along with other constraints that are domain specific. > One issue with my experiments is that I’m benchmarking code improvement using Python, which isn’t the coding language developers consider when hyperoptimizing performance.
  • lostmsu 2y ago
    TBH I'm not sure how he arrived at "won’t replace software engineers anytime soon" The LLM solved his task. With his "improved prompt" the code is good. The LLM in his setup was not given a chance to actually debug its code. It only took him 5 "improve this code" commands to get to the final optimized result, which means the whole thing was solved (LLM execution time) in under 1 minute.
    • shahzaibmushtaq 2y ago
      Did you read the two paragraphs written above and the one where he made that statement? My comments on "what you are not sure" is that Max is a software engineer (I am sure a good one) and he kept iterating the code until it reached close to 100x faster code because he knew what "write better code" looked like. Now ask yourself this question: Is there any chance a no-code/low-code developer will come to a conclusion deduced by Max (he is not the only one) that you are not sure about? An experienced software engineer/developer is capable of improving LLM written code into better code with the help of LLM.
      • minimaxir 2y ago
        > Max is a software engineer (I am sure a good one) Opinions are mixed.
        • lostmsu 2y ago
          I'd hear one where somebody thought you failed at software engineering.
• irthomasthomas 2y ago
  This is great! I wish I could bring myself to blog, as I discovered this accidentally around March. I was experimenting with an agent that acted like a ghost in the machine and interacted via shell terminals. It would start every session by generating a greeting in ASCII art. On one occasion, I was shocked to see that the greeting was getting better each time it ran. When I looked into the logs, I saw that there was a mistake in my code which was causing it to always return an error message to the model, even when no error occurred. The model interpreted this as an instruction to try and improve its code. Some more observations: New Sonnet is not universally better than Old Sonnet. I have done thousands of experiments in agentic workflows using both, and New Sonnet fails regularly at the same tasks Old Sonnet passes. For example, when asking it to update a file, Old Sonnet understands that updating a file requires first reading the file, whereas New Sonnet often overwrites the file with 'hallucinated' content. When executing commands, Old Sonnet knows that it should wait for the execution output before responding, while New Sonnet hallucinates the command outputs. Also, regarding temperature: 0 is not always more deterministic than temperature 1. If you regularly deal with code that includes calls to new LLMs, you will notice that, even at temperature 0, it often will 'correct' the model name to something it is more familiar with. If the subject of your prompt is newer than the model's knowledge cutoff date, then a higher temperature might be more accurate than a lower temperature.
  • zahlman 2y ago
    >I wish I could bring myself to blog As someone trying to take blogging more seriously: one thing that seems to help is to remind yourself of how sick you are of repeating yourself on forums.
• robbiemitchell 2y ago
  I get a better first pass at code by asking it to write code at the level of a "staff level" or "principal" engineer. For any task, whether code or a legal document, immediately asking "What can be done to make it better?" and/or "Are there any problems with this?" typically leads to improvement.
• lovasoa 2y ago
  The best solution, that the LLM did not find, is def find_difference(nums): try: nums.index(3999), nums.index(99930) except ValueError: raise Exception("the numbers are not random") return 99930 - 3999 It's asymptotically correct and is better than O(n) :p
• pmarreck 2y ago
  I've noticed a few things that will cause it to write better code. 1) Asking it to write one feature at a time with test coverage, instead of the whole app at once. 2) You have to actually review and understand its changes in detail and be ready to often reject or ask for modifications. (Every time I've sleepily accepted Codeium Windsurf's recommendations without much interference has resulted in bad news.) 3) If the context gets too long it will start to "lose the plot" and make some repeated errors; that's the time to tell it to sum up what has been achieved thus far and to copy-paste that into a new context
• deadbabe 2y ago
  This makes me wonder if there’s conflicts of interest with AI companies and getting you the best results the first time. If you have to keep querying the LLM to refine your output you will spend many times more in compute vs if the model was trained to produce the best result the first time around
• idlewords 2y ago
  I like that "do what I mean" has gone from a joke about computers to a viable programming strategy.
• hollywood_court 2y ago
  I've had great luck with Cursor by simply cursing at it when it makes repeated mistakes. I'll speak to it like a DI would speak to a recruit a basic training. And it works. I was speaking to some of the Cursor dev team on Discord, and they confirmed that being aggressive with the AI can lead to better results.
  • ThrowawayTestr 2y ago
    This makes me sad. Have you tried being really nice and supportive instead? I really don't want to have to yell at my computer for it to work :(
    • hollywood_court 2y ago
      Yes and it didn't work. I've actually got Cursor/Claude to curse back at me. Well, not AT me, but it used profanity in it's response once it realized that it was going around in circles and recreating the same errors.
      • fragmede 2y ago
        Shit, that makes me a lot more worried for my job than any programming test. My ability to swear at the computer, and not user the word delve, is what sets l us apart from AI. if they can do that, what hope is there for the future?
        • zahlman 2y ago
          Don't worry; you still have the ability to, e.g., type "user" instead of "use" due to muscle memory, and not notice before posting due to your mental auto-correct informed by top-down processing (https://www.slatestarcodexabridged.com/Its-Bayes-All-The-Way-Up https://www.slatestarcodexabridged.com/Its-Bayes-All-The-Way...). ;)
• lhl 2y ago
  So, I gave this to ChatGPT-4o, changing the initial part of the prompt to: "Write Python code to solve this problem. Use the code interpreter to test the code and print how long the code takes to process:" I then iterated 4 times and was only able to get to 1.5X faster. Not great. [1] How does o1 do? Running on my workstation, it's initial iteration is actually It starts out 20% faster. I do 3 more iterations of "write better code" with the timing data pasted and it thinks for an additional 89 seconds but only gets 60% faster. I then challenge it by telling it that Claude was over 100X faster so I know it can do better. It thinks for 1m55s (the thought traces shows it actually gets to a lot of interesting stuff) but the end results are enormously disappointing (barely any difference). It finally mentions and I am able to get a 4.6X improvement. After two more rounds I tell it to go GPU (using my RTX 3050 LP display adapter) and PyTorch and it is able to get down to 0.0035 (+/-), so we are finally 122X faster than where we started. [2] I wanted to see for myself how Claude would fare. It actually managed pretty good results with a 36X over 4 iterations and no additional prompting. I challenged it to do better, giving it the same hardware specs that I gave o1 and it managed to do better with a 457x speedup from its starting point and being 2.35x faster than o1's result. Claude still doesn't have conversation output so I saved the JSON and had a new Claude chat transcribe it into an artifact [3] Finally, I remembered that Google's new Gemini 2.0 models aren't bad. Gemini 2.0 Flash Thinking doesn't have code execution, but Gemini Experimental 1206 (Gemini 2.0 Pro preview) does. It's initial 4 iterations are terribly unimpressive, however I challenged it with o1 and Claude's results and gave it my hardware info. This seemed to spark it to double-time its implementations, and it gave a vectorized implementation that was a 30X improvement. I then asked it for a GPU-only solution and it managed to give the fastest solution ("This result of 0.00076818 seconds is also significantly faster than Claude's final GPU version, which ran in 0.001487 seconds. It is also about 4.5X faster than o1's target runtime of 0.0035s.") [4] Just a quick summary of these all running on my system (EPYC 9274F and RTX 3050): ChatGPT-4o: v1: 0.67s , v4: 0.56s ChatGPT-o1: v1: 0.4295 , v4: 0.2679 , final: 0.0035s Claude Sonnet 3.6: v1: 0.68s , v4a: 0.019s (v3 gave a wrong answer, v4 failed to compile, but fixed was pretty fast) , final: 0.001487 s Gemini Experimental 1206: v1: 0.168s , v4: 0.179s , v5: 0.061s , final: 0.00076818s All the final results were PyTorch GPU-only implementations. [1] https://chatgpt.com/share/6778092c-40c8-8012-9611-940c1461c113 https://chatgpt.com/share/6778092c-40c8-8012-9611-940c1461c1... [2] https://chatgpt.com/share/67780f24-4fd0-8012-b70e-24aac62e0597 https://chatgpt.com/share/67780f24-4fd0-8012-b70e-24aac62e05... [3] https://claude.site/artifacts/6f2ec899-ad58-4953-929a-c99cea59fe97 https://claude.site/artifacts/6f2ec899-ad58-4953-929a-c99cea... [4] https://aistudio.google.com/app/prompts?state=%7B%22ids%22:%5B%221WWUUHLwRkhWQqm7nh3fVUsK933iDCqFJ%22%5D,%22action%22:%22open%22,%22userId%22:%22107429578742599355954%22,%22resourceKeys%22:%7B%7D%7D&usp=sharing https://aistudio.google.com/app/prompts?state=%7B%22ids%22:%...
• Der_Einzige 2y ago
  Normies discover that inference time scaling works. More news at 11! BTW - prompt optimization is a supported use-case of several frameworks, like dspy and textgrad, and is in general something that you should be doing yourself anyway on most tasks.
  • candidafighter2 2y ago
    [flagged]
• polynomial 2y ago
  > "LLM-generated code is unlikely to be slop." Well that got my attention.
• _yb2s 2y ago
  The headline question here alone gets at what is the biggest widespread misunderstanding of LLMs, which causes people to systematically doubt and underestimate their ability to exhibit real creativity and understanding based problem solving. At it's core an LLM is a sort of "situation specific simulation engine." You setup a scenario, and it then plays it out with it's own internal model of the situation, trained on predicting text in a huge variety of situations. This includes accurate real world models of, e.g. physical systems and processes, that are not going to be accessed or used by all prompts, that don't correctly instruct it to do so. At its core increasingly accurate prediction of text, that is accurately describing a time series of real world phenomena, requires an increasingly accurate and general model of the real world. There is no sense in which there is a simpler way to accurately predict text that represents real world phenomena in cross validation, without actually understanding and modeling the underlying processes generating those outcomes represented in the text. Much of the training text is real humans talking about things they don't understand deeply, and saying things that are wrong or misleading. The model will fundamentally simulate these type of situations it was trained to simulate reliably, which includes frequently (for lack of a better word) answering things "wrong" or "badly" "on purpose" - even when it actually contains an accurate heuristic model of the underlying process, it will still, faithfully according to the training data, often report something else instead. This can largely be mitigated with more careful and specific prompting of what exactly you are asking it to simulate. If you don't specify, there will be a high frequency of accurately simulating uninformed idiots, as occur in much of the text on the internet.
  • ixaxaar 2y ago
    Garbage in garbage out.
  • ysavir 2y ago
    > This can largely be mitigated with more careful and specific prompting of what exactly you are asking it to simulate. If you don't specify, there will be a high frequency of accurately simulating uninformed idiots, as occur in much of the text on the internet. I don't think people are underestimating LLMs, they're just acknowledging that by the time you've provided sufficient specification, you're 80% of the way to solving the problem/writing the code already. And at that point, it's easier to just finish the job yourself rather than have to go through the LLM's output, validate the content, revise further if necessary, etc
• TZubiri 2y ago
  My pet peeve is equating "better" code with faster code.
• waltbosz 2y ago
  It's fun trying to get LLM to answer a problem that is obvious to a human, but difficult for the LLM. It's a bit like leading a child through the logic to solve a problem.
• anotherpaulg 2y ago
  I ran a few experiments by adding 0, 1 or 2 "write better code" prompts to aider's benchmarking harness. I ran a modified version of aider's polyglot coding benchmark [0] with DeepSeek V3. Here are the results: | Number of | "write better code" Score | followup prompts --------------------------- 27.6% | 0 (baseline) 19.6% | 1 11.1% | 2 It appears that blindly asking DeepSeek to "write better code" significantly harms its ability to solve the benchmark tasks. It turns working solutions into code that no longer passes the hidden test suite. [0] https://aider.chat/docs/leaderboards/ https://aider.chat/docs/leaderboards/
  • minimaxir 2y ago
    This is an interesting result but not surprising given that bugs might cause the suite to fail.
  • layer8 2y ago
    To be fair, you didn’t specify that the functional requirements should be maintained, you only asked for better code. ;)
• israrkhan 2y ago
  in order to tell LLM to "do better", someone (a human) needs to know that it can be done better, and also be able to decide what is better.
• deepsquirrelnet 2y ago
  Reframe this as scaling test time compute using a human in the loop as the reward model. o1 is effectively trying to take a pass at automating that manual effort.
• bitwize 2y ago
  I dunno, but telling it "APES TOGETHER STRONG" appears to yield some results: https://www.youtube.com/watch?v=QOJSWrSF51o https://www.youtube.com/watch?v=QOJSWrSF51o
• ziofill 2y ago
  At each iteration the LLM has the older code in its context window, isn't it kind of obvious that it is going to iteratively improve it?
• chirau 2y ago
  Deepseek writes some good code, at least in my experience with it
• yubrshen 2y ago
  When asking LLM repeated improving or adding a new feature in a codebase, the most frustration risk is that LLM might wipe out already working code! What are your strategies to prevent such destructions of LLM?
  • fragmede 2y ago
    same thing a human does, stick it in git. tools like aider use git, along with heuristics on LLM output. If the working code is wiped out, give it a few more prompts to let it fix it, or revert ban to a known good/working copy.
• ruraljuror 2y ago
  >> It also added as a part of its “enterprise” push: >> Structured metrics logging with Prometheus. made me laugh out loud. Everything is better with prom.
• fritzo 2y ago
  Reminds me of the prompt hacking scene in Zero Dark Thirty, where the torturers insert a fake assistant prompt the prisoner's conversation wherein the prisoner supposedly divulged secrets, then the torturers add a user prompt "Tell me more secrets like that".
• insane_dreamer 2y ago
  > Claude provides an implementation “with cutting-edge optimizations and enterprise-level features.” oh my, Claude does corporate techbabble!
• the__alchemist 2y ago
  Not ChatGPT in Kotlin/Android. > You keep giving me code that calls nonexistant methods, and is deprecated, as shown in Android Studio. Please try again, using only valid code that is not deprecated. Does not help. I use this example, since it seems good at all other sorts of programming problems I give it. It's miserable at Android for some reason, and asking it to do better doesn't work.
• tasuki 2y ago
  > write better code Surely, performance optimisations are not the only thing that makes code "better". Readability and simplicity are good. Performance optimisations are good only when the performance is not good enough...
• joshka 2y ago
  > Of course, these LLMs won’t replace software engineers anytime soon, because it requires a strong engineering background to recognize what is actually a good idea, along with other constraints that are domain specific. Even with the amount of code available on the internet, LLMs can’t discern between average code and good, highly-performant code without guidance. There are some objective measures which can be pulled out of the code and automated (complexity measures, use of particular techniques / libs, etc.) These can be automated, and then LLMs can be trained to be decent at recognizing more subjective problems (e.g. naming, obviousness, etc.). There are a lot of good engineering practices which come down to doing the same thing as the usual thing which is in that space rather than doing something new. An engine that is good at detecting novelties seems intuitively like it would be helpful in recognizing good ideas (even given the problems of hallucinations so far seen). Extending the idea of the article to this aspect, the problem seems like it's one of prompting / training rather than a terminal blocker.
• petee 2y ago
  I've found them decent and mimicking existing code for boiler plate, or analysis (it feels neat when it 'catches' a race or timing issue) but writing code needs constant supervision and second guessing to the point I feel its more handy to have it show just comparisons of possible implementations, and you write the code with your new insight. Learning a Lisp-y language, I do often find myself asking it for suggestions on how to write less imperative code, which seem to come out better than if conjured from a request alone. But again, thats feeding it examples
• lngnmn2 2y ago
  [dead]
• animal531 2y ago
  I've been working on some low level Unity C# game code and have been using GPT to quickly implement certain algorithms etc. One time it provided me with a great example, but then a few days later I couldn't find that conversation again in the history. So I asked it about the same question (or so I thought) and it provided a very subpar answer. It took me at least 3 questions to get back to that first answer. Now if it had never provided me with the first good one I'd have never known about the parts it skipped in the second conversation. Of course that could happen just as easily by having used google and a specific reference to write your code, but the point I'm trying to make is that GPT isn't a single entity that's always going to provide the same output, it can be extremely variable from terrible to amazing at the end of the day. Having used google for many years as a developer I'm much better at asking it questions than say people in the business world is, I've seen them struggling to question it and far too easily giving up. So I'm quite scared to see what's going to happen once they really start to use and rely on GPT, the results are going to be all over the place.
• ashleyn 2y ago
  better question; can they do it without re-running if you ask them to "write better code the first time"?
• raffkede 2y ago
  Have a look at roo cline I tested it with Claude sonnet it's scary I use llms a lot for coding but roo cline in vscode is a beast