I work on a lot of 2D system, and the only way to debug is often to plot 1000s of results and visually check it behaves as expected. Sometimes I will fix an issue, look at the results, and it seems resolved (was present is say 100 cases) only to realize that actually there are still 5 cases where it is still present. Sure I could amend the last commit, but I actually keep it as a trace of “careful this first version mostly did the job but actually not quite”

Did it make a mistake because I didn’t follow instructions properly or hallucinated some content?

Did it make a mistake because the prompt was unclear/open to interpretation or plain wrong?

Did it make a mistake because it lacked some context? Or too much context and it starts getting confused?

Is not handling edge cases automatically when that was not requested a mistake?

I am not just trying to defend LLMs, in many cases they make obvious mistakes and just don’t follow my arguably clear instructions properly. But sometimes it is not so clear cut. Maybe I didn’t link a relevant file (you can argue it could have looked to it), maybe my prompt just wasn’t that clear etc

If I take the example of code, but that extends to many domains, it can sometimes produce near perfect architecture and implementation if I give it enough details about the technical details and fallpits. Turning a 8h coding job into a 1h review work.

On the other hand, it can be very wrong while acting certain it is right. Just yesterday Claude tried gaslighting me into accepting that the bug I was seeing was coming from a piece of code with already strong guardrails, and it was adamant that the part I was suspecting could in no way cause the issue. Turns out I was right, but I was starting to doubt myself

I guess it is different once you look at people renting, and also you could track a specific person posts to see when they are posting away from home for example. But as far as revealing your home address, sadly there are many other ways in a lot of cases

Steam link: https://store.steampowered.com/app/2147950/4D_Golf

The person goes over quite a few technical details on their Youtube, though they talk about a bunch of other coding experiments too.

The former for me have a bit more exhale and round sound while the “in” are a tad drier.

For example “fin” and “faim” are distinct for me. However “faim” and “feint”

An other thing for me is that it has gotten a lot harder for small teams with few ressources, let one person, to release anything that can really compete with anything the big player put out.

Quite a few years back I was working on word2vec models / embeddings. With enough time and limited ressources I was able to, through careful data collection and preparation, produce models that outperformed existing embeddings for our fairly generic data retrieval tasks. You could download from models Facebook (fasttext) or other models available through gensim and other tools, and they were often larger embeddings (eg 1000 vs 300 for mine), but they would really underperform. And when evaluating on general benchmarks, for what existed back then, we were basically equivalent to the best models in English and French, if not a little better at times. Similarly later some colleagues did a new architecture inspired by BeRT after it came out, that outperformed again any existing models we could find.

But these days I feel like there is nothing much I can do in NLP. Even to fine-tune or distillate the larger models, you need a very beefy setup.

Like I had multiple companies quote me $300-500 based on the job for things that take me maybe 2-3 hours total to do, including learning about it (will be faster next time), getting the materials, and doing the job.

When you have a few of these a months they add up. It is usually nothing for a month and then 4-5 things to fix/improve the next

Also remember a teacher telling us about that story of a company finding a woman was pregnant from her shopping behavior and pushing relevant recommendation. Prompting people around her like her dad or something to find out she was pregnant

For me the main difference is now some people can explain what their code does. While some other only what it wants to achieve

Sure it is not as fast to understand as code I wrote. But at least I mostly need to confirm it followed how it implemented what I asked. Not figuring out WHAT it even decided to implement in the first place.

And in my org, people move around projects quite a bit. Hasn’t been uncommon for me to jump in projects with 50k+ lines of code a few times a year to help implement a tricky feature, or help optimize things when it runs too slow. Lots of code to understand then. Depending on who wrote it, sometimes it is simple: one or two files to understand, clean code. Sometimes it is an interconnected mess and imho often way less organized that Ai generated code.

And same thing for the review process, lots of having to understand new code. At least with AI you are fed the changes a a slower pace.

I had some pieces of code I wrote I was quite proud of: well documented, clear code yet clever designs and algorithm.

But really what always mattered most to me was designing the solution. Then the coding part, even though I take some pride in the code I write, was most a mean to an end. Especially once I start having to add things like data validation and API layers, plotting analysis results and so many other things that are time consuming but easy and imho not very rewarding

I can use them while charging my phone or working out. Can play a video while cooking and moving around the kitchen. Or while watching TV/playing a game in the TV where a cable can’t reach.

However when static I used wired. That’s mostly when on the computer, but like many people here I am assuming that’s a good part of the day.

I’ve had thing like a system that has a collection of procedural systems. I would say “replace the following set of defaults that are passed all around for system X (list of files) and in the managed (file) by a config” and it would do that but I’d suddenly see it be like “wait mu and projection distance are also present in system Y and Z. Let me replace that by a config too with the same values”. When system Y and Z uses a different set of optimized values, and that was clearly outside of the scope.

Never had that kind of mistakes happen when dealing with small contexts, but with larger contexts (multiple files, long “thinking” sequences) it does happen sometimes.

Definitely some times when I though “oh well my bad, I should have clarified NOT to also change that other part”, all the while thinking that no human would have thought to change both

Usually things go smoothly but sometimes I have situations like: “please add feature X, needs to have ABCD.” -> does ABC correct but D wrong -> “here is how to fix D” -> fixes D but breaks AB -> “remember I also want AB this way, you broke it” -> fixes AB but removes C and so on

At work I also always tended to send slightly longer but structured answers. I found that it allowed to skip over the irrelevant sections and focus on what the changes are. Eg a list of changes with in the format -> bullet point -> change name -> change details. So people could easily focus on changes they cared about. Instead of a dense paragraph that people often just skip.

Hell I even found myself wanting to add a typo just to give a more human fell, or skip final “.” to make my text imperfect and more human. That’s getting silly

Sure LLMs are getting better and better, and at least for me more and more useful, and more and more correct. Arguably better than humans at many tasks yet terribly lacking behind in some others.

Coding wise, one of the things it does “best”, it still has many issues: For me still some of the biggest issues are still lack of initiative and lack of reliable memory. When I do use it to write code the first manifests for me by often sticking to a suboptimal yet overly complex approach quite often. And lack of memory in that I have to keep reminding it of edge cases (else it often breaks functionality), or to stop reinventing the wheel instead of using functions/classes already implemented in the project.

All that can be mitigated by careful prompting, but no matter the claim about information recall accuracy I still find that even with that information in the prompt it is quite unreliable.

And more generally the simple fact that when you talk to one the only way to “store” these memories is externally (ie not by updating the weights), is kinda like dealing with someone that can’t retain memories and has to keep writing things down to even get a small chance to cope. I get that updating the weights is possible in theory but just not practical, still.