diff options
Diffstat (limited to 'news/1759407714-why_you_might_need_ai_less_than_you_think')
| -rw-r--r-- | news/1759407714-why_you_might_need_ai_less_than_you_think | 153 |
1 files changed, 153 insertions, 0 deletions
diff --git a/news/1759407714-why_you_might_need_ai_less_than_you_think b/news/1759407714-why_you_might_need_ai_less_than_you_think new file mode 100644 index 0000000..6276446 --- /dev/null +++ b/news/1759407714-why_you_might_need_ai_less_than_you_think @@ -0,0 +1,153 @@ +Why you might need AI less than you think +========================================= +LLMs (aka AI) are models that have been trained to do human-like conversation, +mimicking effectively (or not) the lingual parts of the human brain, the parts +that are responsible for making sentences, paragraphs and expression in native +(human) languages. + +Many are using it for coding. I strongly believe that this is a wrong usage for +the tool. As it is trained for writing and reading text, the job of "writing +code" is inherently different by nature. + +When we want to code some project from an idea or from reading some objectives, +we go in a process where we need to understand the objectives and change them in +a way that computers understand by writing a code base on some programming +language. The programming languages though are not governed by the same rules +and logic of the human-native ones. Things in human language might not make any +sense for computers. + +There is a wrong assumption that since we are telling a computer to do it, it +will be natural for them to do the task easier. That's a common internal +misconception. As already said, this programs/models are trained to mimic human +language, not computer languages. They don't operate as when we say to someone +"how to say 'my name is ...' in your mother language". They don't have one. + +What an LLM will do (in short) is read your text and try to express your text +as code. The outcome is more close to human text than real programming +algorithms or computer native programming language utilization. In other words, +it's good until it's not. This can be witnessed far more easily when one is +prooompting for lower level computer languages. It can also be seen many times +in high level ones. + +For example, providing a function written with bad naming conventions (both +function name and variables) in a type-safe computer language like golang, +including some comment about its usage and asking to rename the function and the +variable names only, might result on having a reply that changes also the types +of the variables, not renaming everything or just hallucinate from a small and +concrete prompt. For this example, I had to ask again (around 5-6 times) until +it made it right. That's what I call "losing time with garbage tools". + +I have countless personal examples of using LLMs in ways which resulted me to +waste more time than if I did it by myself. I have lots of examples read from +articles that conclude to the same time wasting and go in extend analyzing +hallucinations or even bug discovery for bugs that aren't there or they are +there but only a small amount of percentage are figuring them out. + +Note that the claim here is not that "I am better than AI" or an inferiority +complex. For short, anyone with intuition is better than AI and intuition is +installed by default in every human, so there's that: we are all better than AI. + +The claim is the following: in order to get things going, people are choosing +convinience over factors that don't really understand. This creates a kind of +debt, known as knowledge debt. If you are doing it for your own sake and nobody +else will ever see it, then yes, you could go nuts on copy-pasting. And to be +real about it, I did a lot of copy-pasting in my early years (pre-LLM era). It's +not inherently bad. But there are more steps on this: you copy-paste, you try, +it might not work as intented, you edit it, retry, edit again, done. + +On collaborative projects though, this is very different. One might want to just +complete a project, rushing to a final solution without any critisism or thought +on what it should be or should not be there. No understanding of architecture, +no will to change anything on the code if it's working, leaving codebases in a +huge mess, really badly written, with lots of repetition and not at all simple. + +To me, this means that for the sake of not putting the work, you put almost the +same amount of work, get into knowledge debt, pass it on to your colleagues, +provide badly written code and get the credits for being "fast". Before going on +about what comes with this approach, let's quickly discredit the "fastness". +They are not "fast". "Vibe-coding" is totally unrelated to coding and more +related to "testing". This approach has severe drawbacks which one might think +they will never show up but they are just waiting around the corner. + +People that are about to work with such "testers", while trying to grasp the +concepts of good practices, reading such code might end up having a really bad +time while doing so. If the architecture of the whole project is just bad, this +alone adds up time. Repetition requires deduplication which takes time. People +that don't want to put the time will lose interest. People that don't want to +refactor badly written code will lose interest. And that's problematic. + +Your future (or current) manager might not even know how to read code. Having a +manager used to quick project deliverance is not something really bad. But will +turn badly when for smaller features you will need more time than the first code +base was written on. This will be witnessed by managers. + +Quits, firings, bad reputation, bad relations: hostile work environment for +short. Will LLMs help when one reaches this level? I don't think so. Learn your +craft! You can do it! + +There are tools (yeah, AI ones) that specialize on coding, but they tend to come +with costs or limitations. If these tools are the only devs you know available +for hiring, what can I say, go nuts. But don't forget(!!!!): you pay someone +else now, which is bad. You probably work a 9-5 to make a living. The company +you work at is not yours. You don't do hiring, your manager does. Ask them to +hire people and set the standards. The money you are making is for you to keep, +not to buy stuff for a company you don't own. Hello!!! + +We are still using software written in the 1970's. From back then until pre-LLM +era software is written completely by humans. That's more than 50 years. The +hype promoting AI is creating a mindfield crisis to some that lack of +understanding can enhance its effects. The manager we mentioned before, might +have no idea how to write/read code. Seeing LLMs spitting all this output looks +nice to them, but it's not realistic. To them, it looks productive, to devs +sooner or later will be counter-productive. + +So why you might need LLMs less than you probably think? Because you possibly +started recently to code and the learning curve is a learning curve and it's +natural to get overwhelmed, bored, lazy or just want to see some results. Learn +your tools instead, your editor, the compiler you are using, get in depth or at +least reach a level of understanding. Write code that you know why you wrote it. +That's "owning the code". + +This article was inspired after a lot of discussions, personal experiences and +articles. Unfortunately, I won't be referencing the articles. Truly, though, it +is my intention to raise awareness about my humble opinion which I feel that +while it's seemingly unpopular, it might express statements that others might +also agree. The point, however, is mostly for people that might haven't thought +about this before and possibly dealt with the issues mentioned. A lot of these +can be reasons for causing frustration, and when this emotion comes up, people +tend to not explain the reasons and just leave, stop talking, break +collaborations or other ways of avoiding confrontation. + +While the following could be a heads up I feel that it matches much better for +closing thoughts and clarity. I personally stand against this LLM/AI hype. I +find it stupid, extorting and very disturbing. I don't like big corporations +either. My understanding is that these organizations are trying to monopolize +once again various sectors of human-driven workforce so they can gain more for +theirselves. I find it plain stupid to waste time to use those tools and in the +process of doing so, train them to do it better. Therefore I personally +discourage anyone from using them. If you do decide to use them, my advice is +to make one simple prompt at the time and never engage with them after that. +Don't train your competitors for free. You are being used. Any governmental +regulations leave me indifferent and utopias that it will transform society in +a way that would be beneficial for everyone are lacking understanding of how +governments and capitalism works. + +Finally, as I really dislike the "conclusion" part on every article I am reading +on the internet, you are encouraged to draw your own for yourself. If you used +some LLM to summarize this article, I assume that you can't gain anything from +this article because reading it, requires time and work which you seem to not be +willing to put on anything. Value comes from work you put on stuff, if you don't +they are just cheaper but this doesn't guarantee any type of quality. Maybe +harsh, but I honestly can't care more. + +If you really read it as it is, I then thank you for your time and effort. I +hope you will find ways to include it in your thinking and internal processes. +In the case you disagree with what I wrote, firstly we might have different +purposes but secondly, I hope it adds up to your omni-opinion development. + +This took long enough to write. I won't make a series of articles about this as +engagement with current hypes is not my lifestyle, so don't expect follow ups. + +Again, thank you for your time, +kaotisk + |