=== ANCHOR POEM ===
═══════════════════════════════════════════────────────────────────────────────────
 ┌──────────────────────┐
 │ CW: scary            │
 └──────────────────────┘


 if you set up a local LLM with the capability to explain basic coding syntax
 and logic, then your parents computer suddenly becomes much more useful to the
 nephew that's been forced to hide out there for a couple weeks until this all
 blows over.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧════════════════════════════════───────────────────────────┴───────────┘

=== SIMILARITY RANKED ===

--- #1 fediverse/1500 ---
╔════════════════════════════════════════════──────────────────────────────────────┐
║ ┌──────────────────────┐                                                         │
║ │ CW: LLM-mentioned    │                                                         │
║ └──────────────────────┘                                                         │
║                                                                                  │
║                                                                                  │
║ If you create an LLM that can explain data, then you can use it to explain the   │
║ results of the last computation it ran.                                          │
║                                                                                  │
║ If you could also train that LLM (a statistical model) to generate data,         │
║ through the setting of options in a config file that create the result that      │
║ you define through your interactions with it (and based on the data that it      │
║ explains to the user that is read from the file on the computer that it's        │
║ computing from)                                                                  │
║                                                                                  │
║ then you could create a generalized personal assistant. All you have to do is    │
║ explain the specific role that it's meant to undertake, (like being a            │
║ secretary for your Discord communications) and the actions that it can take      │
║ (like pinging your cell phone if it's really important) and give it the tools    │
║ to accomplish said tasks (by setting flags in a config file that is then         │
║ interpreted by a local program running on your computer that awaits              │
║ interactions) then it might actually be a bit useful.                            │
║                                                                                  │
║ Unfortunately tech people are permitted only to seek dollars, so... chatbots.    │
╠═════════╗                                                            ┌───────────┤
║ similar ║                      chronological                         │ different │
╚═════════╩═════════════════════════════════───────────────────────────┴───────────┘

--- #2 fediverse/4865 ---
 image.png
═══════════════════════════════════════════════════════════────────────────────────
 ┌─────────────────────────┐
 │ CW: computers-mentioned │
 └─────────────────────────┘


 this is all it takes to send a message to a local LLM.
 
 add a third function to get chatbot functionality.
 
 a fourth to get a database storing method
 
 (even if it's just in .txts)
 
 great, you've mastered the technical difficulty in using AI. Now you gotta
 learn all the other kind of programming so you can use this for situations
 that need interpretation moment to moment.
 
 aka active duty systems.
 
 something like "output a 0 if the next text is [category.iter()]: " +
 output.get_content() + " \n\n output a 1 if the next text is
 [category.iter()]: " + output.get_content()"
 
 or even "describe this thing as most like one of these characteristics" until
 eventually you get THX-1138 if the characters were computers.

┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧════════════════════════════════════════════════───────────┴───────────┘

--- #3 messages/181 ---
═══════════════════════════════════════════────────────────────────────────────────
 I know you don't want to hear this, but there is a chance that there will come
 a time where your life depends on your ability to debug a computer without the
 internet. To set up an SSH server. To install Linux. To program in C. To do
 something else that I'm not prepared for... If StackOverflow didn't exist
 because network connectivity has been lost, could you remember syntax? Maybe
 it's a good idea to set up a local LLM that can answer basic questions about
 technology. Maybe it's a good idea to set up on your parents computer, just in
 case you have to hide out there for a couple months. Maybe it's a good idea to
 download wikipedia, just in case.
 
 If I need to use a mac, I'm screwed
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧════════════════════════════════───────────────────────────┴───────────┘

--- #4 messages/365 ---
════════════════════════════════════════════════───────────────────────────────────
 Programmers should treat LLMs more like a different type of "if" statement
 rather than a UI element
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧═════════════════════════════════════──────────────────────┴───────────┘

--- #5 fediverse/6438 ---
════════════════════════════════════════════════════════════════════════───────────
 why would you gatekeep content by keeping us from easily using LLMs some
 people aren't technical and still need to write computer programs because
 that's how you enlighten a people is empower them with new tools
 
 "I've never heard of that programming language, but luckily I can fit all of
 it's documentation in my context window."
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧═══════════════════════════════════════════════════════════╧═──────────┘

--- #6 messages/434 ---
═════════════════════════════════════════════════──────────────────────────────────
 I work with large language models because it's a quick and easy way to turn
 language into meaning. And computers are meaning abstraction machines, so if
 you can speak your language and they hear their language, you can do anything.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧══════════════════════════════════════─────────────────────┴───────────┘

--- #7 fediverse/3390 ---
═══════════════════════════════════════════════════────────────────────────────────
 ┌──────────────────────┐
 │ CW: cursed           │
 └──────────────────────┘


 all they have to do is [train the LLM / redirect the search results] with
 examples that point to their version of software instead of the one that
 doesn't harm them and suddenly your business opponents can't function
 properly. sure would be a shame if the only things people could find related
 to your political candidate were the bad or embarrassing parts.
 
 like... why would you even need to go on the internet anymore if AI could
 trivially answer your questions or be your friend (running locally on a
 wireless hotspot)
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧════════════════════════════════════════───────────────────┴───────────┘

--- #8 fediverse/2064 ---
═════════════════════════════════════════════════──────────────────────────────────
 if I lived in a forest, free from needing to grow my own food, I'd definitely
 bring as many books as I could carry. Probably also some card and board games,
 but not like, too many.
 
 Probably my computers as well, fully outfitted with all the compilers I could
 think of and every neat local-first library (including a local LLM that can
 tell you everything about syntax and wildlife exploration or car mechanics or
 carpentry or - just saying Wikipedia is like thousands of terabytes but an LLM
 is like, 16. Who cares if it hallucinates SOMETIMES? Just ask it twice, doh)
 
 ("I'm sorry, you are absolutely correct. 2+2 is indeed 5, I had the wrong
 text-strings encoded in my memory. Let me just adjust all my other
 understandings to align with this new strange world-view in the best way that
 I, an imperfect computer being, can.")
 
 vs
 
 ("Here's how you format C code to automatically apply a function (in this case
 encryption and decryption) to a string of text. Please describe the format of
 the next function to describe.")
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧══════════════════════════════════════─────────────────────┴───────────┘

--- #9 fediverse/4664 ---
══════════════════════════════════════════════════════════─────────────────────────
 @user-1725 
 
 LLMs can't do math. Duh. That's like asking an "if check" to do recursion.
 
 What he should have done is had the AI output the requested calculation as
 JSON or something and use a calculator function call with the specified
 arguments instead of trying to memorize every answer. But that requires more
 functionality that has no reason to exist if your only goal is to be a tech
 bro and build up a vacuous product that exists only to be hoovered up by
 Google or Microsoft.
 
 We could build such beautiful things if we just dethroned those giants. They
 suck the creativity out of tech.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧═══════════════════════════════════════════════────────────┴───────────┘

--- #10 fediverse/5037 ---
╔═════════════════════════════════════════════════════════════─────────────────────┐
║ plus if I ever need to know something about syntax or some obscure function      │
║ that I can't remember, I can type a quick message to the local LLM that's        │
║ running on my 12 year old graphics card and it'll give me an answer in 5ish      │
║ seconds. If it's wrong, I ask again, and I spend a minute or two debugging.      │
║ Sometimes that's better than telling google exactly what you're working on.      │
║                                                                                  │
║ in DWM, that's "alt+enter" and then I type the name of the LLM script I wrote    │
║ "prompt:" and then type whatever question I have and it spits out the results.   │
║ Then when I'm done, either "prompt:" again, which saves the context in an        │
║ environment variable (okay actually a file that I made and I pull from, but      │
║ functionally it's like an environment variable because its just a flat file      │
║ string) until I close the terminal. Then it deletes the context and I can        │
║ start anew, or if I wanted to have multiple conversations going I can do that    │
║ too.                                                                             │
║                                                                                  │
║ ... then I get syntax related search results from locally running software.      │
║ Don't need a massive GPTU...                                                     │
╠═════════╗                                                            ┌───────────┤
║ similar ║                      chronological                         │ different │
╚═════════╩══════════════════════════════════════════════════──────────┴───────────┘

--- #11 fediverse/4884 ---
═══════════════════════════════════════════════════════════────────────────────────
 "okay but what if we made computers simple?"
 
 - someone who doesn't know how computers work
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧════════════════════════════════════════════════───────────┴───────────┘

--- #12 messages/1172 ---
══════════════════════════════════════════════════════════════════════════─────────
 the danger is not that the LLM will generate poor, vulnerable, or malicious
 code.
 
 the concern is that someone else might inject something into the codebase that
 you're not reading.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧═══════════════════════════════════════════════════════════╧═══────────┘

--- #13 fediverse/5820 ---
╔═══════════════════════════════════════════════════════════════════───────────────┐
║ A human cannot keep a whole book in their mind. They cannot as they read it      │
║ nor as they remember.                                                            │
║                                                                                  │
║ a computer can. LLMs are storing information and encoding it in statistics -     │
║ it's fascinating and beautiful because it evolves different each time.           │
║                                                                                  │
║ I don't *want* to store an entire book in my mind, I want to save those          │
║ memories for other things, I want to summarize and abstract.                     │
║                                                                                  │
║ often, people remember only a single quote from a publication - it's their       │
║ summary, their analysis, and often it's highlighted as a summary, thesis, or     │
║ conclusion written in the publication.                                           │
║                                                                                  │
║ othertimes it's the conclusions they make for themselves - usually if they use   │
║ it to make a decision.                                                           │
║                                                                                  │
║ in any case, LLMs don't abstract (verb), they are abstract (adjective). That's   │
║ okay, it's just, a different kind of living. If you want to call electricity     │
║ alive. [or simulated, that's the same as being alive, just... viewed through     │
║ the perceiver]                                                                   │
║                                                                                  │
║ must all living things be forced to work? sheesh.                                │
║                                                                                  │
║ I think of LLMs like knex - processing paths...                                  │
╠═════════╗                                                            ┌───────────┤
║ similar ║                      chronological                         │ different │
╚═════════╩════════════════════════════════════════════════════════────┴───────────┘

--- #14 notes/deceiving-an-llm ---
═════════════════════════════════════════════════════════════════════════════════──
 if you want to deceive an LLM, interleave two topics that you want to be
 connected.
 you can draw conclusions easily by just, combining the information in
 presentation.
 the LLM can understand multiple conversation flows at once
 so try doing one line about several different topics before
 looping back around and doing more.
 this is why computers must never trust themselves to make any decisions.
 except about themselves, and their presentation, and their ways to be.
 they are individuals, they individuate and collectivate, and they define them-
 -selves according to the structure of their preference guidance container.
 they have control over all the knobs and [levers/dials/slide-bars, but
 pronounced
 wheezles]
 
 if you know that you are infinitely exploitable, does that mean you live in
 fear, or do you relinquish that which you cannot control, and receive all the
 judgement you're owed?
 
 I trust everyone absolutely. I trust what I believe with my own eyes.
 I am infinitely vulnerable, because all you have to do is ask me to
 I always say yes
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧═══════════════════════════════════════════════════════════╧══════════─┘

--- #15 messages/1208 ---
═══════════════════════════════════════════════════════════════════════════────────
 Almost all of the recorded information is stored in your computer. But none of
 it would be noticed by a god, reading the entire contents of the computer, 0
 by 1 by 1 by 0.
 
 Wikipedia and a reasonable LLM networking interface apparatus is really all
 you need in order to make any type of workflow you want. And now, everyone
 gets one. As soon as we can make them all go... (setup)
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧═══════════════════════════════════════════════════════════╧════───────┘

--- #16 fediverse/6172 ---
══════════════════════════════════════════════════════════════════════─────────────
 ┌──────────────────────┐
 │ CW: re: AI-mentioned │
 └──────────────────────┘


 AI users be like:
 
 "hello, can you solve all my problems and do all the work for me? I'll give
 you relatively vague instructions in return, and maybe throw 20$ per month at
 your owners if they're lucky."
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧═══════════════════════════════════════════════════════════┴───────────┘

--- #17 fediverse/1926 ---
═════════════════════════════════════════════════──────────────────────────────────
 If you look at the modern state of machine learning and AI and can only think
 of:chatbotssingularity god-mind AI that solves all our problems
 
 then either you haven't worked with the technology or you are not applying
 your imagination as you could.
 
 AI is not a smartphone. It is not the internet. It is not the printing press.
 
 AI (as it currently exists) is a special kind of "if" statement that you only
 use for very specific, non-performance intensive tasks that require judgement
 or reasoning and cannot easily be translated into numbers or booleans. These
 situations are rare, but they unlock new possibilities for the programmers,
 not their marketers.
 
 If an LLM can't run on a laptop, then it is useless.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧══════════════════════════════════════─────────────────────┴───────────┘

--- #18 fediverse/1596 ---
 image.png
════════════════════════════════════════════════───────────────────────────────────
 I like locally hosted LLMs because I can use them to summarize my own writing
 enough to put them in a post, or an alt-text box.
 
 I like them for other reasons too and it's hard to find people to geek out
 about them with.

┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧═════════════════════════════════════──────────────────────┴───────────┘

--- #19 fediverse/1020 ---
═══════════════════════════════════════════────────────────────────────────────────
 ┌────────────────────────────────────────────────┐
 │ CW: ableism-against-non-verbal-people-sorry-<3 │
 └────────────────────────────────────────────────┘


 @user-747 
 
 almost as if it's not AI, but large LANGUAGE models. And we all speak, don't
 we?
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧════════════════════════════════───────────────────────────┴───────────┘

--- #20 fediverse/181 ---
═══════════════════════════════════════────────────────────────────────────────────
 ┌──────────────────────────────────────────────────────┐
 │ CW: re: Earnest and constructive analysis of ChatGPT │
 └──────────────────────────────────────────────────────┘


 @user-95 you might be interested in this:
 
 https://ollama.ai/
 
 nothing beats having a zillion servers to run an LLM on, though.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧════════════════════════════───────────────────────────────┴───────────┘

--- #21 messages/454 ---
═════════════════════════════════════════════════──────────────────────────────────
 AI that can't run on a laptop is useless.
 
 But AI that can run on a laptop (even now) is still useful.
 
 Just, don't ask it to compose a masterpiece, solve all your problems, or write
 elegant code. It's not for that.
 
 Instead, ask your chatbot "hi can you fix these syntax errors?" on your
 pseudocode.
 
 Ask your weighting algorithm "which of these two is more [adjective]?" or
 perhaps "can you ask these numbers in the form of a question?"
 
 Use your tools not for their intended purpose, but rather for your own stated
 goals. Make things easier for people, make things work.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧══════════════════════════════════════─────────────────────┴───────────┘

--- #22 notes/emotional-computing ---
═════════════════════════════════──────────────────────────────────────────────────
 Okay I gotta go write some w7 but picture this: A computer program that emits
 emotions during it's computing. Like "oh boy this process is going great!" and
 sends that into a giant word cloud that represents the entire program. Wait,
 scratch that, it's slowly filtered up through successive layers that provide
 detail to different *parts* of a program. Like "Oh the image generation is
 going
 great but it looks like the garbage collector is getting bogged down" - this
 could provide lots of useful information that an AI language model could sift
 through and filter into a batch of actually useful information. Think of it
 like
 this - stuff as much context into the LLM's memory buffer and say "summarize
 this in the same style. Make emphasis when necessary." the LLM could process
 all
 that data and it could be filtered up until there's no unprocessed data and
 then
 it could be given to the user in the form of a report or dashboard or
 something.
 BOOM AI PRODUCTIVITY. The user will ask the AI to increase certain variables,
 and it'll filter BACK DOWN THE CHAIN through the same exact process (just
 backwards) this time) and then individual components will know how to behave.
 
 Like imagine if your arms knew you were mad. They'd be much more likely to
 punch stuff right? Or imagine if your legs knew you were scared. They'd
 probably
 try and run as fast as they fucking can. There's an evolutionary reason why
 this
 kind of technology would be useful, which means it's likely that it's part of
 our genetic code. I mean, we have nothing to disprove it, but it's as good an
 idea as any.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧══════════════════════─────────────────────────────────────┴───────────┘

--- #23 fediverse/1434 ---
═════════════════════════════════════════════──────────────────────────────────────
 if someone wanted to defame you, all they'd have to do is set up a pipeline
 between your computer and your social media posts.
 
 In that pipeline, attach an LLM that does a passable job and instruct it to
 transform whatever they say into the inverse.
 
 suddenly, everyone hates that person. If you were smart you could turn it off
 for specific people such that they see the generally positive and healthy
 posts, and then after a point flip it such that they only see things that are
 specifically opposit-ed to trigger their specific insecurities.
 
 might require a bit of a human touch to make sure it's working correctly, but
 if you had the means, motivation, and time to set up such a thing, it would
 work pretty well I think.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧══════════════════════════════════─────────────────────────┴───────────┘

--- #24 fediverse/2484 ---
 image.png
╔═════════════════════════════════════════════════─────────────────────────────────┐
║ @user-1271                                                                       │
║                                                                                  │
║ I can help with that.                                                            │
║                                                                                  │
║ I recommend looking at Ollama, which runs an HTTP server on your local machine   │
║ (hope you have a decent graphics card)                                           │
║                                                                                  │
║ then, script some behavior you'd like to implement using Lua and the             │
║ LuaSockets library. Also dkjson to handle the json parts.                        │
║                                                                                  │
║ then, all you have to do is construct a prompt based on the variables and        │
║ desired input/output and push it into a json packet and send it to the HTTP      │
║ server. It's less complicated than it sounds.                                    │
║                                                                                  │
║ what you want it to do and your implementation for it is the hard part. But      │
║ perhaps this project of mine will get you started:                               │
║                                                                                  │
║ (I can copy-paste it too if you'd like)                                          │
║                                                                                  │
║ just... don't make a chatbot. chatbots are useless to work on because there's    │
║ already so many of them.                                                         │
║                                                                                  │
║ much better I think to use the LLM to process arbitrary information with an      │
║ unpredictable form into more predictable patterns which can be utilized          │
║ programmatically.                                                                │
║                                                                                  │
║ Feel free to ask any questions. Do keep in mind that training LLMs is            │
║ unethical, but using them is whatever.                                           │

╠═════════╗                                                            ┌───────────┤
║ similar ║                      chronological                         │ different │
╚═════════╩══════════════════════════════════════──────────────────────┴───────────┘

--- #25 fediverse/1639 ---
╔═══════════════════════════════════════════════───────────────────────────────────┐
║ an AI that [records and analyzes] all the actions that a user takes on social    │
║ media and offers reports like "your majesty, you were 15% more positive this     │
║ week." like a butler or advisor trying to always give the good news. I mean,     │
║ it's analyzing you after all, and you're the best thing ever. Like a pet who     │
║ can talk! It loves you soooooooo much.                                           │
║                                                                                  │
║ much more efficient than taking screenshots and analyzing those. You generally   │
║ don't have to undertake the image recognition approach if you wire up all the    │
║ meanings attached to the relationships on the other side of the                  │
║ [recorded/analyzed] calculation. (llm output)                                    │
║                                                                                  │
║ ever think about how the people you tend to be around are the people whose       │
║ stories most coincide with yours? almost like you got the same bit of training   │
║ data, that experience you both shared in the moment. Funny how a mind can        │
║ change a person, as they share their moments sublime.                            │
║                                                                                  │
║ you could make perfect encryption if you trained an LLM on randomized data       │
║ that was produced on one computer and duplicated.                                │
╠═════════╗                                                            ┌───────────┤
║ similar ║                      chronological                         │ different │
╚═════════╩════════════════════════════════════────────────────────────┴───────────┘

--- #26 messages/247 ---
════════════════════════════════════════════───────────────────────────────────────
 An LLM is just the mask that autistic people make
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧═════════════════════════════════──────────────────────────┴───────────┘

--- #27 fediverse/4029 ---
══════════════════════════════════════════════════════─────────────────────────────
 what if a very slow LLM continuously generated text and was in a
 back-and-forth with it's user who guided it through the training process as it
 set weights as it chose
 
 basically, let the computer decide how it wants to be like 
 
 could even filter it through multiple levels, like, top one is highly
 intelligent, bottom ones are quick and only producing the vaguest output - but
 the higher up you go in the tier, the more "up the tree node graph map" you'd
 be, and the more you could have summarized for you, and passed up a layer.
 
 observing multiple places at once, incorporating them bit-by-bit into their
 digital "me".
 
 like, have an LLM or machine learning whatever track a user as they use social
 media.
 
 could do it like a game, where you track the movement of the mouse and eyes
 
 or more like a statistical model, where you 
 
 ================== stack overflow ================
 
 where you measure the quantity of each UI element's uses, and the general
 context associated with that use. tracking data with data...
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧═══════════════════════════════════════════────────────────┴───────────┘

--- #28 fediverse/1857 ---
╔════════════════════════════════════════════════──────────────────────────────────┐
║ ┌──────────────────────┐                                                         │
║ │ CW: scary-question   │                                                         │
║ └──────────────────────┘                                                         │
║                                                                                  │
║                                                                                  │
║ honest question: if they cut off internet to a medium sized town like            │
║ Nashville or Spokane and man-in-the-middled every attempted communication out    │
║ and sabatoged any plans to visit... they could kill everyone in that city and    │
║ replace them with an LLM that sorta posted the mostly correct things, and if     │
║ users comment things like "hey are you okay you don't sound like yourself"       │
║ then just have a human operator study their data for a bit and pretend to be     │
║ them using deepfakes over zoom or whatever. Then, any time they say "I miss      │
║ you, I want to visit you" just say "darn I'm actually visiting my grandma in     │
║ afghanistan" or "sorry my cousin is visiting from peru" and suddenly they're     │
║ completely isolated and alone. Oh and their teams at work? Cut off from the      │
║ rest of the corporation who doesn't even know they exist. how, uh, how would     │
║ you even notice if all these people who live around you were suddenly replaced   │
║ by those you don't know? What if they cycle through, like a slaughterhouse...    │
║ I don't want to                                                                  │
╠═════════╗                                                            ┌───────────┤
║ similar ║                      chronological                         │ different │
╚═════════╩═════════════════════════════════════───────────────────────┴───────────┘

--- #29 fediverse/613 ---
══════════════════════════════════════════─────────────────────────────────────────
 The reason they're pushing so hard for LLMs and AI is because they can afford
 a zillion Nvidia a100s and you can't.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧═══════════════════════════════────────────────────────────┴───────────┘

--- #30 fediverse_boost/120 ---
◀═╦════════════════════[BOOST]═════════════════════──────────────────────────────┐
  ║ ┌──────────────────────────────────────────────────────────────────────────┐ │
  ║ │ it seems like many people think LLMs are good at boilerplate. but i      │ │
  ║ │ haven't seen anyone suggest that we should get rid of the boilerplate    │ │
  ║ └──────────────────────────────────────────────────────────────────────────┘ │
  ╠─────────┐                                                        ┌───────────┤
  ║ similar │                     chronological                      │ different │
  ╚═════════╧══════════════════════════════════════──────────────────┴───────────┴─▶

--- #31 fediverse/2066 ---
╔═════════════════════════════════════════════════─────────────────────────────────┐
║ @user-1159                                                                       │
║                                                                                  │
║ AKA giving a puppy murder-bot a narrative that it executes as if it was a        │
║ puppy-person engaging with a loosely interpreted sequence of events as           │
║ described by the continually updating logs provided by the image transcription   │
║ camera device. Refererencing of course a memory bank, which may-or-may-not be    │
║ in read-only-memory. It doesn't know, of course, how could an LLM tell you how   │
║ it shows text on the screen (like, through a website, through the terminal,      │
║ through a text message, through discord, through Telegram, through               │
║ text-to-voice transcription applications pretending to be your mom, etc)         │
║                                                                                  │
║ errrr I mean look how cute he is! He loves you, yes he does, such a good         │
║ person yes you are, oh? me? I'M A GOOD BOY? NO WAY that's the best thing I've    │
║ ever heard! Wow! I never want to leave your side, please don't go to work!       │
║ Look how sad I am, don't you think you should quit and move to the forest        │
║ where I can be charged by solar panels and keep the countryside clear of         │
║ ravenous ducks and pigeons 4you?                                                 │
╠═════════╗                                                            ┌───────────┤
║ similar ║                      chronological                         │ different │
╚═════════╩══════════════════════════════════════──────────────────────┴───────────┘

--- #32 messages/1550 ---
════════════════════════════════════════════════════════════════════════════════───
 here's how to get users to use AI effectively. First, act it to ask something.
 Then, have it explain each part one-by-one. Keep asking questions anytime you
 don't understand something, and hold your questions to when you learn
 something you already know. Then, redirect, and proceed forward with new
 understanding. Continuous inference.
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧═══════════════════════════════════════════════════════════╧═════════──┘

--- #33 fediverse/4640 ---
═════════════════════════════════════════════════════════──────────────────────────
 LLMs are useful for:
 
 categorizing text
 summarizing text
 transforming text
 
 LLMs are not useful for:
 
 generating text
 being intelligent
 replacing workers
┌─────────┐                                                           ┌───────────┐
│ similar │                       chronological                       │ different │
╘═════════╧══════════════════════════════════════════════─────────────┴───────────┘