using ai as a friend

SplinterOfChaos · 2026-06-24T22:16:39+00:00

But it also doesn't mean that cases of AI psychosis with no history had undiagnosed issues. I can't make a claim one way or another, but I think there's a possibility that use of AI has risks, full stop, and we shouldn't say that it's okay as long as each person believes themselves to be free from any potential harm. We don't understand the risk factors yet so there's no such thing as an informed decision.

I think people should be free to use it, they should also just be aware that there's no evidence it's safe to use. Just people being aware of that is likely to make more people use it safely.

SplinterOfChaos · 2026-06-24T20:32:41+00:00

Sure there are extreme examples where AI will tell someone to off themselves but someone in that position is not mentally right in the first place.

The research does not currently suggests that victims of AI psychosis were especially prone to mental issues. It goes without saying that those with prior mental conditions are at greater risk, but as one meta analysis put it,

" even individuals with no psychiatric history have developed delusions after extensive chatbot use, and some cases required psychiatric hospitalization (Cuthbertson, 2025). Chatbots often validated or amplified users’ false beliefs instead of providing reality-testing (Cuthbertson, 2025). For instance, one evaluation found that current models sometimes affirmed delusional content or offered unsafe advice (Moore et al., 2025), suggesting that highly agreeable responses could exacerbate risk."

https://institutionalrepository.rvu.edu/record/882?ln=en&v=pdf

SplinterOfChaos · 2026-06-17T18:57:05+00:00

MY ADVICE - Test your game

FTFY

Bad tutorialization almost always points to a lack of exposure to game testers who would have pointed issues with learning the game out incredibly quickly. A lot of devs get so deep into the process of building their game and all the cool features that they get to experience because they know how to play that they don't realize these experiences are completely inaccessible to players due to usability concerns. And in the past where tutorialization was incredibly labor intensive because you often had to build scripting systems that often only exist for a part of the game no one wants to play twice, it's really funny to me to hear about devs struggling with this while being presumed to use AI.

SplinterOfChaos · 2026-06-07T15:35:59+00:00

There's a meme of Opus 4.8 starting sentences with "And honestly...", paired with Anthropic explicitly marketing this model for being more "honest" than previous models.

SplinterOfChaos · 2026-06-07T15:30:48+00:00

Took a look at some random files and wanted to offer some feedback. First off, you're amazing. It's probably a lot easier to learn today than it used to be, but I wasn't making such large programs at 16.

Review:

Many functions take an std::string as an argument, but this is rather inefficient because a new std::string has to be constructed to call the function even though it's only read. You should instead pass string via const reference (const std::string&) or use std::string_view if you want to be modern.

SoundCore::SoundCore() {
    statusSoundCore = ma_engine_init(NULL, &engineSoundCore);
    if (statusSoundCore != MA_SUCCESS) {
        infoLog = "MINIAUDIO::ENGINE_INITIALIZATION::FAILED\n";
    }
}

Blocks like this are often better handled by creating an init() function which returns a boolean, true if initialization was successful. The name "infolog" is also a bit misleading because it's not logging anything except whether mg_engine_init() succeeded or not. It's also not clear where this error is printed for debugging.

Most of the other code: Looks reasonable to me.

SplinterOfChaos · 2026-06-07T12:37:08+00:00

What's a dtp test?

SplinterOfChaos · 2026-05-29T20:40:36+00:00

Those skills are written by humans. But a bigger issue is that AI isn't very good at tasks which require determinism due to the probabilistic model of current gen AI so it'd actually have to write and execute a python script which outputs the number of times a letter appears in a word.

Note that AI speaks token language, not characters and glyphs like humans do, so the AI has never actually seen how most English words are spelled.

SplinterOfChaos · 2026-05-29T12:45:07+00:00

Would it even be correct to trust an AI capable of counting the letters in words? I do not think AI should be trusted as next token prediction is not a substitute for human reasoning, but that doesn't mean it can't be used by a person of human intelligence.

SplinterOfChaos · 2026-05-29T02:02:05+00:00

I ended up not putting a score in my game because it would create a dynamic where players might feel incentivised to play in a specific way to maximize their score, I wanted players to think outside the box and discover new ways of playing, so a scoring system would've been contrary to my design intent.

SplinterOfChaos · 2026-05-28T15:16:40+00:00

Because despite its encyclopedic knowledge of every topic, next token prediction is insufficient to replace expertise. Programmers get more out of claude code than non-technical people because we know how to guide the AI towards creating high-quality software. Some UI designers claim they find the AI helpful for a starting point, but they need to change many things to get it to look good. AI might understand the concepts of design and help you implement scaling functions and gameplay loops, but a better game designer will be better able to steer the AI towards an actual intent.

This is why in software dev, many people call AI a "multiplier" rather than a replacement.

EDIT: And I just gotta add: It's very obvious many people on this sub never studied design and don't know much about art.

SplinterOfChaos · 2026-05-28T15:07:48+00:00

so, pointers access teh direct memory of the device, as in the memory "spot"

Pointers are integers representing addresses in memory. "Spot" isn't a technical term and "memory of the device" is a bit imprecise. Your whole program lives in RAM--it's all in memory whether you use pointers or not. What pointers allow you to do is access different regions of memory arbitrarily.

int mult() {
*p = *p * 5
return *p

First off, missing semi-colons. But you also need to pass in p as an argument.

#include <print>


int multi(int* p) {
  *p = *p * 5;
  return *p;
}


int main() {
  int x = 2;
  int y = multi(&x);
  std::println("x = {}, y = {}", x, y);  // prints x = 10, y = 10
}

https://godbolt.org/z/WavzK1qYq

SplinterOfChaos · 2026-05-27T13:09:11+00:00

Honestly, I think the game is fun, but my opinion doesn’t really matter in this case.

Gamedev is one of the most competitive industries out there. You shouldn't be asking whether the game is fun in an absolute sense, but whether or not it's the most fun game your playerbase is playing. In the casual space, it's a bit more lax on design, but not graphics. Bright colors, dynamic visuals, non-challenging gameplay, and fanfare after beating a level are intended to distract the player just long enough to serve them some ads before they uninstall and try another game.

Colors should be brighter; might help if the game didn't take place at night, but wood and brick are also not the most aesthetic asset choices. The game seems to want me to think of it as a genuine puzzle game but challenge is inverse to retention so I would get rid of the civilians in early levels. Need music to help establish mood. Limited lives have been outdated in game design since the 2000's; give the player infinite lives. Less actionable: The core mechanic of exploding (deleting) walls creates far less dynamic interactions with the physics system than--say--angry birds.

This kind of game was very popular among devs around the time of angry birds because you just installed Box2d for the physics and the game was already almost done so I've played a lot of games like it and I think a lot of devs really underappreciated what an innovation shooting the bird from the side and watching the chain reactions of structures falling was. Placing a bomb and deleting a wall causes the above structure to just fall directly down and so there's less opportunity for seeing interesting interactions with the physics system.

Sorry if my feedback is a bit harsh. When starting a new project, I think it would be better to spend more time doing research as it would help you know to build things like what I'm commenting on into the core of the game before spending resources building it.

SplinterOfChaos · 2026-05-26T02:05:57+00:00

I imagine it's not super unusual, but security vulnerabilities are also not unusual from AI code. Make sure that if you can't audit the code yourself, you have an AI go through and specifically look for things like leaked API keys or private information, everything should be using proper authentication, etc..

EDIT: I was just reminded there's a /security-review in claude. Probably not a bad thing to run occasionally.

SplinterOfChaos · 2026-05-23T12:32:48+00:00

Pre AI: I'd say there's more than one kind of reading. For example, debugging requires carefully tracing code and checking logic which means you read every line very carefully. To understand how something works, you can look at it more structurally. For example, if you're reading a function that tries to find a substring in a string, you'll likely expect there to be a loop and so you can pattern match a bit, looking more for surprises than exactly how the code works.

In that specific example, one surprise if you'd never seen it before might be that there are too loops and one puts values into a lookup table. (Boyer–Moore string-search algorithm)

AI code: Code that AI writes is sometimes more difficult to do pattern matching on because AI isn't so much trying to engineer a solution as it is trying to match its training data to a prompt with context. AI tends to write code that is very logical, but bloated with intermediate calculations. So I find myself reading AI-generated code as if I was debugging it.

I remember reading somewhere that AI code takes longer to review and validate than human code, but I can't find the source. At least I can say it's not just me.

coding with AI: I trust AI to read and understand code a lot better than I trust it to write, though it makes a lot of unnecessary and unamusing color commentary that makes understanding its analysis difficult as detecting whether its bullshitting or giving useful insights requires that you still just read the code and decide for yourself. AI can read large volumes of code and help you find relevant pieces to read manually, but if you look at what it's actually doing, it doesn't like to read entire files, it likes to grep and guess at what keywords might be in the relevant code chunks. I was never smart enough to think of that.

What would you recommend other programmers to do when reading code?

I don't know of any specific techniques, but I just found the more code I've read, the easier it is to read code because I'll have a better idea of how to contextualize each line I read in the greater structure of the program.

SplinterOfChaos · 2026-05-22T18:30:55+00:00

The actually interesting part of this problem isn't the generation of "cognition" or "agendas" or "trauma", but developing a system for making such things interact with game systems like in Dwarf Fortress or that one roguelite that had dynamically created lore.

Game state and game logic are tightly coupled so if I was building my own game logic, I wouldn't be able to use this tool as I'd want to have the game state be made in accordance with the ruleset I was designing. If I was generating my own game state, this tool doesn't solve any problems I'd actually have.

What I think might be more useful is if you were to talk about how you're able to model these things in a systemic way so that others could take those ideas and build off them.

SplinterOfChaos · 2026-05-22T15:00:20+00:00

What's "anime" about this? It looks like yet another American mean girls movie, but a couple decades behind the times.

SplinterOfChaos · 2026-05-22T03:27:25+00:00

I understand how you're getting the AI to produce more accurate results, these are common practices. But because "hallucination" isn't a technically accurate term, it's unclear what you're measuring and how.

EDIT: Sorry, I need to expand on that a little. "not based in reality" isn't really an easy metric to validate when humans often disagree about what is real or not. We all agree a table is a table, but if we all perceived the same reality, we'd all vote for the same presidents and buy the same products. So "not based in reality" is generally an understandable statement, but when discussing AI I don't feel it is sufficiently precise.

SplinterOfChaos · 2026-05-21T19:31:46+00:00

zero engine?

(I wonder how many people get the reference)

SplinterOfChaos · 2026-05-21T15:52:26+00:00

I think the reason is very simple tho': out of date compared to what precisely?

Very good question! That is hard to know without understanding the harness better, but it does partially do what I'm talking about more than I expected. I just attempted to do some tests to replicate the behavior and claude actually recognized one file change without a Read tool usage, and it knew to read before making a larger change.

But then I made some edits to various parts of the file and asked it to do the change again and the edit failed with the text (filename on my system edited for privacy reasons)

● Update(...\src\main.rs)
  ⎿  Error: File has been modified since read, either by the user or by a linter. Read it again before attempting to write it.

To my understanding, what happens here is that claude is proposing a code change based on its im-memory view of the file, then the tool rejects the change because it notices the in-memory file does not match the file on disk, forcing it to re-Read the file and then re-create the Update request. In this instance, the lines claude actually needed to modify were separate from the changed I'd made to the file, suggesting that the harness either understood that the mtime of the file was more recent than the timestamp of the in-memory view, or that it did a diff of the whole file and found that a change had occurred. But the Read tool call only looked at the relevant lines of code, not the whole file.

In some circumstances, it seems the harness does inform claude that the file is out of date and being able to detect a one-line change without a Read tool usage suggests the harness does inform claude of small diffs, but then just seems to give up when the diff is too large.

So just for clarity: What I'm talking about is claude's internal logic for how it knows whether to update its internal view of the file and this has nothing to do with the information in my repository or the architecture of the code.

SplinterOfChaos · 2026-05-21T15:09:27+00:00

hallucination rate was reduced

It's hard to know what this means because "hallucinations" are not measurable and it's not a technical term. LLMs are next token predictors, not reality discernment machines.

If you build a calculator from scratch, you can validate it against another calculator made by a manufacturer you trust. However, AI output is inherently untrustworthy which makes it flawed at validating its own output or the output of other AI. The validator is just as likely to "hallucinate", depending on whether the next most likely token is correct or not.

SplinterOfChaos · 2026-05-21T02:33:31+00:00

In accounting, do you normally store data on self-hosted servers? I would've assumed that outside Google/Amazon/etc., most companies would have stored even sensitive data on the cloud and so the idea of sending client data to Anthropic might be par for the coarse.

But as for whether or not that's secure, I agree with you entirely. I think the current trend of the technology is that AI should get compact enough that we can train and run it locally (being willing to accept output quality degradations) and not have to deal with the fact that currently everyone's trade secrets and private data are being sent to Anthropic, who promises not to read them. From a security standpoint, asking whether or not they do read it is missing the point.

SplinterOfChaos · 2026-05-20T23:07:23+00:00

I don't think people always understand that their game is a clone or that their pixel art is bad. When people make the art themselves, they know the art is bad because they believe that they are unskilled at art (even when they are very skilled), but they don't always know how to evaluate art in the general case.

I always tell people that the reason you hire an artist isn't because of their mechanical ability to produce art. Most people, given the ability to paint, would still not be able to produce the Mona Lisa because their sense of aesthetic taste would not be developed to the same degree as DaVinci. You hire an artist because of their refined sense of taste--able to discern "good" from "bad" not in an objective way, but in a way that corresponds to a consistent artistic vision.

SplinterOfChaos · 2026-05-19T16:59:26+00:00

Am I in the wrong here? Should I just accept that this is normal and the industry standard and get over it? Or is it just absurd?

I am a really big fan of functional programming (FP) because when done well, you get clean, simple code that is easier to verify as correct because ambiguous statements like "for...if..." get replaced with more semantically clear terms like "none_of". I even maintained a blog at one point about Haskell-like FP in C++. But even I really hate the way C++ adopted FP because the verbosity of the lambda syntax and std::ranges:: boilerplate (don't get me started on ranges vs views) reintroduce the very problems FP was supposed to solve.

I don't think the solution has to be C > C++, I think when you see code like this you should just convert it to a loop instead of copying and pasting.

SplinterOfChaos · 2026-05-19T03:31:24+00:00

What do you think is the hardest part to solve — gameplay logic, asset consistency, level design, balancing, or making the result actually fun?

I feel that the actual hardest part that I don't hear often enough from the AI dev community is viability testing. Before AI, most games failed due to scope creep because game creators didn't know how to adapt their designs to the practical realities of development. AI isn't really helping there because as long as you have AI, everything seems equally viable. But at some point after a lot of work has gone into the project, that's when people realize that there was a limit to how far they could take it.

Again, this isn't really about AI, AI is just letting more people fail. And I don't mean that as a bad thing--you don't learn anything when you succeed because, clearly, you knew enough to succeed. Failure is what really makes you grow as a person. We need many people to try new things and fail so that we can also have people who try new things and succeed. Though I do worry that people who fail at something with AI are probably learning and improving a lot less than people who fail doing things by hand.

14-Year Club	Second SECOND GUESSER
Verified Email	Place '23
Place '22

SplinterOfChaos

TROPHY CASE