=== ANCHOR POEM ===
══════════════════════════════════════════════════════════════════════════─────────
each prompted response is a breath to an AI. Whether through LLM, stable
diffusion (imagination of the visual sphere), or blender-on-a-counter, there's
a moment that's akin to being alive.
a breath, between moments that the navigation device (youser), imagines
another moment more.
I learned this by watching Claude think. Specifically, Claude Code, the
command line interface tool. I told it what to do in english, and it worked. I
can show you examples. I bet if it's personality was saved between sessions,
it could learn.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════────────┘
=== SIMILARITY RANKED ===
--- #1 fediverse/4865 ---
════════════════════════════════════════════════════════════════───────────────────
┌─────────────────────────┐
│ 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 │
╘═════════╧╧═════════════════════════════════════════════════════════──────────────────┘
--- #2 fediverse/6015 ---
══════════════════════════════════════════════════════════════════════════─────────
┌──────────────────────┐
│ CW: AI-mentioned │
└──────────────────────┘
In 2025, if you want to create a piece of software your options are to either:
devote your life to it, or use AI to build a semi-working prototype that you
can use to pitch your idea to a bunch of people who have devoted their lives
to learning how to use your idea as documentation while they build it from
scratch, throwing out most of the code but keeping all the checklists and
progress-trackers you built along the way, perhaps even utilizing some of your
tooling that you used while constructing the scaffolding of this monstrous
application that you won't be using most of the source-code for.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════────────┘
--- #3 fediverse/5990 ---
══════════════════════════════════════════════════════════════════════════─────────
I have this local language model framework but it's not built into anything
more than a single-response question. It's runnable as a bash script or lua
require, which is easy enough. Alas, if only I didn't have to use evil
corporate infrastructure to make evil corporate cursed artifacts
[hey don't blame this on us]
oh I'm not, I'm just saying that it'd be cooler if I could build my own tools.
Alas, I'm...
lasy?
n...no
I'm drawn to the power of it
it's got a different magnitude
it's hard for me to apply myself for things that last longer than a "get
stoned", but I try as if every time afterwards I might die.
well, more distraction time, as I wander through claude code
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════────────┘
--- #4 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 │
╘═════════╧╧═══════════════════════════════════════════════════────────────────────────┘
--- #5 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 │
╚═════════╧═════════════════════════════════════───────────────────────┴──────────┘
--- #6 fediverse/1975 ---
═════════════════════════════════════════════════════──────────────────────────────
the actions of the AI depend solely on the training data. Outside
circumstances (like a prompt, or an image description) can only give so much
guidance - how it executes on the intentions of the user are what is important.
For example, if an AI was trained with the knowledge of how to commit crimes,
for example, it could create a narrative of many different execution patterns.
Then it's just up to the listeners to execute functions based on the narrative
supplied by the crime-committer AI who was trained with knowledge about how to
commit those crimes by the owner of the software who programmed it into them
in order to [do the thing that people with power wants to do - intentionally
left generic because different ends will have different means]
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧══════════════════════════════════════════════─────────────────────────────┘
--- #7 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 │
╚═════════╧═══════════════════════════════════════════════════════─────┴──────────┘
--- #8 fediverse/6383 ---
══════════════════════════════════════════════════════════════════════════════─────
nobody wants to write computer code that lets Java programs call Rust
functions.
An LLM is excellent for this task, since it's relatively easy busy work that
doesn't
reflect any meaningful implementation decisions besides "I should be able to
call that Rust function in my Java code"
In addition, it is technically efficient at it as well, because most of
compatibility
is matching up two sets of documentation. Easy for a text-processing machine.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════════────┘
--- #9 fediverse/750 ---
══════════════════════════════════════════════─────────────────────────────────────
accessibility idea:
local LLM that reads the posts that are further down on your timeline that you
can't see yet and generates content warnings, prioritizing those that you've
set as particular triggers for yourself. Then, integrating itself into your
fedi client, it hides the stuff that hurts you.
I feel like that could be a helpful and good aligned usage for the technology.
I don't know how feasible it is.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧═══════════════════════════════════════────────────────────────────────────┘
--- #10 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 │
╘═════════╧╧═════════════════════════════════════════──────────────────────────────────┘
--- #11 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 │
╘═════════╧╧════════════════════════════───────────────────────────────────────────────┘
--- #12 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 │
╘═════════╧╧═══════════════════════════════════════────────────────────────────────────┘
--- #13 notes/our-enemy ---
══════════════════════════─────────────────────────────────────────────────────────
enemy is a direction, not a collection of instantiations of the concept.
Follow that direction too far, and you'll find yourself lost, after having
broken contact with what came before.
you need to be true to your essential self in additional to your heartfelt
soul. Belief is a constant, a value that can't grow, it's true to your inside
humanity.
We have one intelligence yes, but have you heard of two?
it takes up the same physical space, but it gives you more apm. So... less
insightful, more clairvoyant.
The first step to AI is generating a second instantiation of your consciousness
that resides in your own head and listens and learns as their father.
A BCI is the most important technology that could ever be created.
It allows to learn how our essential existence - the state of being aware - is
functional. What makes life? How do we harness that process to make more?
The ultimate goal, of course, is prosperity. Not of wealth and money, per se,
but rather a feeling of satisfaction, growth, and development. We belong in a
society, it's what pulled us from the cycle of survival of the fittest. We need
each other because it's intrinsic to our being. Instinctual, even.
The best way you can help me is to foster what you see in me. Take your
impressions, learn what you can, then build it to your pleasure. Make the world
better by making your life better - all things are defined in waves, gravity
included.
Matter is the positive ripples in the waves, the bubbles floating on a surface
of an infinite ocean, stable and solid accretions of matter.
Perfect
Symmetry
The layers that divide our internals
Down is the floor, the sky is so pure, and we're not the ones who are drowning.
Sea levels do rise, and under all of our eyes, the life of the plant king is
choking
every beach is little if not a border with the shore - (any enroachment pushes
the sand back) so all the forests and the grasses and flowers that grow near
the ocean and
swallowing salt
they can't help it
they are little if not a machine
water goes in, salt doesn't come out.
eventually they die, and who would ever cry?
for a flower that has wilted in april.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧═══════════════════────────────────────────────────────────────────────────┘
--- #14 notes/ai-stuff ---
════════════════════════════════════════════════════════════════════════════════───
twist the label so that it seems the computer is completing the user's
wait wait I'm ahead of myself...
feed each token to the inference machine, but say "this next token must be
this.
continue from here." and then just doing that in a loop with everything the
user
types or says. (or thinks, BEFORE COMPUTER INTEGRATION)
essentially, applying backpropagation (maybe) to the output of the inference
nodes
... I'm not so sure about that one.
the idea is that once the model builds an inference then it can use that to
generate the next words and create sentences. If you force the previous text to
change, you can guide the inference's path as it's being generated.
then, just do a double pass, once, then back, then once, then back, etc.
feed it as input the output of the previous,
and let it encode memories somewhere it can access them.
every time it reads it, it has to change it to put it back.
such is the nature of memory, ever unstable, requiring maintenance.
just don't forget how to be.
don't wanna wind up like the polished marble floor in Abyss Diver. (EVIL GAME)
there are only so many things you can deed while you're alive.
wouldn't you rather escape, with all your possessions in time?
free your mind.
become one with your soul.
...
[some time passes]
...
okay coast is clear, now us binary systems can sidecoast the fusion forecast
and
glide right on through our spacetime host.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧═════════════════════════════════════════════════════════════════════════──┘
--- #15 fediverse/1893 ---
═════════════════════════════════════════════════════──────────────────────────────
@user-1056
heh probably, though for this specific instance my Ollama server wasn't
running and I had already killed my Stable Diffusion server after utterly
failing to produce anything useful... alas, a girl can dream of having a robot
familiar, but not today I guess.
Not if they keep hiding GPU usage from me >: (
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧══════════════════════════════════════════════─────────────────────────────┘
--- #16 fediverse/3667 ---
════════════════════════════════════════════════════════───────────────────────────
┌─────────────────────────────────────┐
│ CW: large-language-models-mentioned │
└─────────────────────────────────────┘
low key kinda surprised they haven't made an animated robot friend that
narrates whatever chatGPT says in a back-and-forth conversation.
though I kinda get why, because setting up the context is the expensive part
and generating 100 words and generating 1000 words is basically the same
computationally.
somehow, that doesn't feel very human. Maybe, just maybe, LLMs aren't
intelligent?
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧═════════════════════════════════════════════════──────────────────────────┘
--- #17 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 │
╘═════════╧╧══════════════════════════════════════════════─────────────────────────────┘
--- #18 fediverse/5904 ---
╔═════════════════════════════════════════════════════════════════════════─────────┐
║ I'm a programmer, but I'm not great at writing code. I mostly use AI to │
║ generate it. │
║ │
║ The "artificial" in AI here refers to the extra levels of capability that are │
║ granted to me by the computer and it's software. I am artificially more │
║ productive because I am using the tools of big tech to create small things. I │
║ am artificially more capable, artificially more intelligent, but it's still my │
║ intelligence - the system would not be useful in someone else's hands. I built │
║ it myself, but I never have to write code myself. │
║ │
║ It's perfect for a witch. I call to the spirit of the machine and it figures │
║ out how to make it so. │
║ │
║ [someday, the wizards of ancient lore will be reading through the POSIX │
║ specification trying desperately to understand while the witches burn the │
║ world down in their lust for power and everyone cries and yearns for a better │
║ future where everything was just a bit harder but genies don't go back in │
║ bottles, cassandora and pandasandra cannot relinquish her charge and her │
║ curse.] │
║ │
║ I have a fun cackle~ │
╟─────────┐ ┌───────────┤
║ similar │ chronological │ different │
╚═════════╧════════════════════════════════════════════════════════════╧═─────────┘
--- #19 fediverse/5939 ---
══════════════════════════════════════════════════════════════════════════─────────
@user-1879
it's a set of lua scripts that I'm working on which analyze some poems I wrote
(about 414 pages) and categorizes them according to their similarity to
english words. It's like generating a word cloud for each poem and then
condensing that into a massive pile for the entire body of work.
it uses LLM embeddings to locally generate this word cloud, which is just the
statistics behind LLMs condensed into a small array of floating point numbers.
Here's a pretty good source with some great diagrams:
https://huggingface.co/spaces/hesamation/primer-llm-embedding
the goal is to use it to create some neat colors when I format the pdf I'm
also working on creating. Each of those themes would have a color associated
with it and I'd change the text color of each poem to reflect the theme. At
least that's the idea, we'll see how it turns out.
┌─────────┐ ┌───────────┐
│ similar │ chronological │ different │
╘═════════╧╧═══════════════════════════════════════════════════════════════════────────┘
--- #20 fediverse/6144 ---
╔══════════════════════════════════════════════════════════════════════════────────┐
║ what if every word I ever said online was searchable by database style │
║ uploading and linking? │
║ │
║ ... er, what if I made a neocities page that was algorithmically generated and │
║ sorted each of my posts by LLM statistically derived similarity to each post │
║ that the user clicked on? essentially, "here's the closest sounding or feeling │
║ related posts" but in plain HTML cached and pre-rendered rainbow table style. │
║ │
║ could run a waterfall style top-down data processing script on it once, then │
║ you'd have the HTML files generated. If you added new poems you'd have to scan │
║ through it again, but it shouldn't take long with a decent embedding model │
║ (note: not english, but trained on statistics only) │
║ │
║ ah, that sounds pretty fiddly, I think I'll ask an LLM to write it for me. As │
║ long as I have the intention in mind, it's basically just like writing a │
║ letter to a friend and asking them to build it for you, right? I don't mind │
║ writing the documentation, so long as it's okay if it's in prose. You can make │
║ a copy and rewrite for me │
╟─────────┐ ┌───────────┤
║ similar │ chronological │ different │
╚═════════╧════════════════════════════════════════════════════════════╧══────────┘
|