I saw this on Mastodon and almost had a stroke.

@davidgerard wrote:

“Most of the AI coding claims are conveniently nondisprovable. What studies there are show it not helping coding at all, or making it worse

But SO MANY LOUD ANECDOTES! Trust me my friend, I am the most efficient coder in the land now. No, you can’t see it. No, I didn’t measure. But if you don’t believe me, you are clearly a fool.

These guys had one good experience with the bot, they got one-shotted, and now if you say “perhaps the bot is not all that” they act like you’re trying to take their cocaine away.”

First, the term is falsifiable, and proving propositions about algorithms (i.e., code) is part of what I do for a living. Mathematically human-written code and AI-written code can be tested, which means you can falsify propositions about them. You would test them the same way.

There is no intrinsic mathematical distinction between code written by a person and code produced by an AI system. In both cases, the result is a formal program made of logic and structure. In principle, the same testing techniques can be applied to each. If it were really nondisprovable, you could not test to see what is generated by a human and what is generated by AI. But you can test it. Studies have found that AI-generated code tends to exhibit a higher frequency of certain types of defects. So, reviewers and testers know what logic flaws and security weaknesses to look for. This would not be the case if it were nondisprovable.

You can study this from datasets where the source of the code is known. You can use open-source pull requests identified as AI-assisted versus those written without such tools. You then evaluate both groups using the same industry-standard analysis tools: static analyzers, complexity metrics, security scanners, and defect classification systems. These tools flag bugs, vulnerabilities, performance issues, and maintainability concerns. They do so in a consistent way across samples.

A widely cited analysis of 470 real pull requests reported that AI-generated contributions contained roughly 1.7 times as many issues on average as human-written ones. The difference included a higher number of critical and major defects. It also included more logic and security-related problems. Because these findings rely on standard measurement tools — counting defects, grading severity, and comparing issue rates — the results are grounded in observable data. Again, I am making a point here. It’s testable and therefore disproveable.

This is a good paper that goes into it:

In this paper, we present a large-scale comparison of code authored by human developers and three state-of-the-art LLMs, i.e., ChatGPT, DeepSeek-Coder, and Qwen-Coder, on multiple dimensions of software quality: code defects, security vulnerabilities, and structural complexity. Our evaluation spans over 500k code samples in two widely used languages, Python and Java, classifying defects via Orthogonal Defect Classification and security vulnerabilities using the Common Weakness Enumeration. We find that AI-generated code is generally simpler and more repetitive, yet more prone to unused constructs and hardcoded debugging, while human-written code exhibits greater structural complexity and a higher concentration of maintainability issues. Notably, AI-generated code also contains more high-risk security vulnerabilities. These findings highlight the distinct defect profiles of AI- and human-authored code and underscore the need for specialized quality assurance practices in AI-assisted programming.

https://arxiv.org/abs/2508.21634

The big problem in discussions about AI in programming is the either-or thinking, when it’s not about using it everywhere or banning it entirely. Tools like AI have specific strengths and weaknesses. Saying ‘never’ or ‘always’ oversimplifies the issue and turns the narrative into propaganda that creates moral panic or shills AI. It’s a bit like saying you shouldn’t use a hammer just because it’s not good for brushing your teeth.

AI tends to produce code that’s simple, often a bit repetitive, and very verbose. It’s usually pretty easy to read and tweak. This helps with long-term maintenance. But AI doesn’t reason about code the way an experienced developer does. It makes mistakes that a human wouldn’t, potentially introducing security flaws. That doesn’t mean we shouldn’t use for where it works well, which is not everywhere.

AI works well for certain tasks, especially when the scope is narrow and the risk is low. Examples include generating boilerplate code, internal utilities, or prototypes. In these cases, the tradeoff is manageable. However, it’s not suitable for critical code like kernels, operating systems, compilers, or cryptographic libraries. A small mistake memory safety or privilege separation can lead to major failures. Problems with synchronization, pointer management, or access control can cause major problems, too.

Other areas where AI should not be used include memory allocation handling, scheduling, process isolation, or device drivers. A lot of that depends on implicit assumptions in the system’s architecture. Generative models don’t grasp these nuances. Instead of carefully considering the design, AI tends to replicate code patterns that seem statistically likely, doing so without understanding the purpose behind them.

Yes, I’m aware that Microsoft is using AI to write code everywhere I said it should not be used. That is the problem. However, political pundits, lobbyists, and anti-tech talking heads are discussing something they have no understanding of and aren’t specifying what the problem actually is. This means they can’t possibly lead grassroots initiatives into actual laws that specify where AI should not be used, which is why we have this weird astroturfing bullshit.

They’re taking advantage of the reaction to Microsoft using AI-generated code where it shouldn’t be used to argue that AI shouldn’t be used anywhere at all in any generative context. AI is useful for tasks like writing documentation, generating tests, suggesting code improvements, or brainstorming alternative approaches. These ideas should then be thoroughly vetted by human developers.

Something I’ve started to notice about a lot of the content on social media platforms is that most of the posts people are liking, sharing, and memetically mutating—and then spreading virally—usually don’t include any citations, sources, or receipts. It’s often just some out-of-context screenshot with no reference link or actual sources.

A lot of the anti-AI content is not genuine critique. It’s often misinformation, but people who hate AI don’t question it or ask for sources because it aligns with their biases. The propaganda on social media has gotten so bad that anything other than heavily curated and vetted feeds is pretty much useless, and it’s filled with all sorts of memetic contagions with nasty hooks that are optimized for you algorithmically. I am at the point where I will disregard anything that is not followed up with a source. Period. It is all optimized to persuade, coerce, or piss you off. I am only writing about this because this I’m actually able to contribute genuine information about the topic.

That they said symbolic propositions written by AI agents (i.e., code) are non-disprovable because they were written by AI boggles my mind. It’s like saying that an article written in English by AI is not English because AI generated it. It might be a bad piece of text, but it’s syntactically, semantically, and grammatically English.

Basically, any string of data can be represented in a base-2 system, where it can be interpreted as bits (0s and 1s). Those bits can be used as the basis for symbolic reasoning. In formal propositional logic, a proposition is a sequence of symbols constructed according to strict syntax rules (atomic variables plus logical connectives). Under a given semantics, it is assigned exactly one truth value (true or false) in a two-valued logic system.

They are essentially saying that code written by AI is not binary, isn’t symbolically logical at all, and cannot be evaluated as true or false by implying it is nondisproveable. At the lowest level, compiled code consists of binary machine instructions that a processor executes. At higher levels, source code is written in symbolic syntax that humans and tools use to express logic and structure. You can also translate parts of code into formal logic expressions. For example, conditions and assertions in a program can be modeled as Boolean formulas. Tools like SAT/SMT solvers or symbolic execution engines check those formulas for satisfiability or correctness. It blows my mind how confidently people talk about things they do not understand.

Furthermore that they don’t realize the projection is wild to me.

@davidgerard wrote:

“But SO MANY LOUD ANECDOTES! Trust me my friend, I am the most efficient coder in the land now. No, you can’t see it. No, I didn’t measure. But if you don’t believe me, you are clearly a fool.”

They are presenting a story—i.e., saying that the studies are not disprovable—and accusing computer scientists of using anecdotal evidence without actually providing evidence to support this, while expecting people to take it prima facie. You’re doing what you are accusing others of doing.

It comes down to this: they feel that people ought not to use AI, so they are tacitly committed to a future in which people do not use AI. For example, a major argument against AI is the damage it is doing to resources, which is driving up the prices of computer components, as well as the ecological harm it causes. They feel justified in lying and misinforming others if it achieves the outcome they want—people not using AI because it is bad for the environment. That is a very strong point, but most people don’t care about that, which is why they lie about things people would care about.

It’s corrupt. And what’s really scary is that people don’t recognize when they are part of corruption or a corrupt conspiracy to misinform. Well, they recognize it when they see the other side doing it, that is. No one is more dangerous than people who feel righteous in what they are doing.

It’s wild to me that the idea that if you cannot persuade someone, it is okay to bully, coerce, harass them, or spread misinformation to get what you want—because your side is right—has become so normalized on the Internet that people can’t see why it is problematic.

That people think it is okay to hurt others to get them to agree is the most disturbing part of all of this. People have become so hateful. That is a large reason why I don’t interact with people on social media, really consume things from social media, or respond on social media and am writing a blog post about it instead of engaging with who prompted it.

ActivityPub Server’s Custom Reply‑Control Extensions Undermine Federation

It seems like Activitbypub developers are extending ActivityPub with optional metadata to fix a lot of its issues, but that is still problematic. Trying to add moderation tools and user control to threads seems to be the ongoing battle. I am fascinated by dumpster fires, so I’ve started looking at the ActivityPub protocol in detail. I tend to become fascinated with things that are going down in flames.

As a brief recap of the problem:

So, one of the very popular features on Bluesky—also popular on Twitter—is the ability to select who can reply to a post. A major issue in the Fediverse is the inability to decide who can reply, and once you block someone, their harassing reply is still there. I honestly thought it was simply a case of them choosing not to add or address it for cultural reasons. What is clear from that thread is that they were always aware that the ActivityPub protocol and most Fediverse implementations don’t provide a universal way to control reply visibility or enforce blocks across instances.

An ActivityPub server that has reply control is GoToSocial. ActivityPub, as defined by the W3C specification, standardizes how servers federate activities. It defines actors, inboxes, outboxes, and activity types (Create, Follow, Like, Announce, etc.) expressed using ActivityStreams 2.0. It also specifies delivery mechanics (including how a Create activity reaches another server’s inbox) and how collections behave.

The specification does not include interaction policy semantics such as “only followers may reply” or “replies require manual approval.” There is no field in the normative vocabulary requiring conforming servers to enforce reply permissions. That category of rule is outside the protocol’s defined contract.

GoToSocial implements reply controls through what it calls interaction policies. These appear as additional properties on ActivityStreams objects using a custom JSON-LD namespace controlled by the GoToSocial project.

JSON-LD permits additional namespaced terms. This means the document remains structurally valid ActivityStreams and federates normally. The meaning of those custom fields, however, comes from GoToSocial’s own documentation and implementation. Other servers can ignore them without violating ActivityPub because they are not part of the interoperable core vocabulary.

Enforcement occurs locally. When a remote server sends a reply—a Create activity whose object references another via inReplyTo—ActivityPub governs delivery, not acceptance criteria. Whether the receiving server checks a reply policy, rejects the activity, queues it, or displays it is determined in the server’s inbox-processing code. The decision to accept, display, or require approval happens after successful protocol-level delivery. This behavior belongs to the application layer.

These are server-side features layered on top of ActivityPub’s transport and data model that are not actually part of ActivityPub. The protocol ensures standardized delivery of activities; however, the server implementation defines additional constraints and user-facing behavior. Two GoToSocial instances may both recognize and act on the same extension fields. However, a different implementation, such as Mastodon, has no obligation under the specification to interpret or enforce GoToSocial’s interactionPolicy properties. These fields function as extension metadata rather than protocol requirements.

The semantics of GoToSocial are not part of the specification’s defined vocabulary and processing rules for ActivityPub. They no longer operate purely at the protocol layer; it has become an application-layer contract implemented by specific servers.

Let’s use the AT Protocol as an example. Bluesky’s direct messages (DMs) are not currently part of the AT Protocol (ATProto). The AT Protocol has nothing that specifies anything for DMs, so DMs are not part of the AT Protocol. The AT Protocol was designed to handle public social interactions, but it does not define private or encrypted messaging. Bluesky implemented DMs at the application level, outside of the core protocol. DMs are centralized and stored on Bluesky’s servers. What is happening with servers like GoToSocial is sort of like that. The difference is that the AT Protocol was designed for different app views; ActivityPub was not.

The issue is the divergence in semantic interpretation that emerges at the interpretation layer. ActivityPub standardizes message delivery and defines common activity types. However, it leaves extension semantics and application-layer policy decisions to individual implementations. Servers may introduce custom JSON-LD namespaces and enforce local behaviors, such as reply restrictions, while remaining protocol-compliant. But, the noise created by divergences are problematic, because it creates unexpected, unintended, and unpredictable behavior.

Divergence appears when implementations rely on non-normative metadata and assume reciprocal handling to preserve a consistent user experience. Behavioral alignment then varies. Syntactic exchange succeeds, but behavioral consistency is not guaranteed. Though instances continue to federate at the transport level, policy semantics and processing logic differ across deployments. Those differences produce inconsistent experiences and results between implementations.

That leads to fragmentation, specifically semantic or behavioral fragmentation and an inconsistent user experiences. ActivityPub ensures syntactic interoperability, but semantic interoperability (everyone interprets and enforces rules the same way) varies. This creates a system that is federated at the transport level yet fragmented in behavior and expectations across implementations. It is funny how the thing that the fediverse touted has made the entire thing very brittle. ActivityPub technically federates correctly, but semantically falls apart once servers start adding their own behavioral rules.

FEP-171b: Conversation Containers Won’t Work

So, I took a look at this:

This document specifies a model for managing conversations in ActivityPub network. It is based on the implementation of Conversation Containers in Streams.

In this model conversations are represented as collections controlled by a single actor. Such conversations take place within a specific audience and may be moderated.

FEP-171b: Conversation Containers

https://fediverse.codeberg.page/fep/fep/171b/

TL;DR: It won’t work.

The proposal introduces authoritative conversation control to ActivityPub by modeling threads as owner-managed OrderedCollection containers. The conversation owner curates replies and redistributes approved activities via Add. Participants are expected to reject unapproved content. The abstraction is internally coherent. The friction appears when this model is placed inside ActivityPub’s federated design.

Here is the problem. ActivityPub does not define enforcement semantics. Servers operate autonomously and apply local policy. A specification can say that implementations “SHOULD reject” unapproved replies. Yet nothing in the protocol requires that outcome. A server that declines to participate can still accept Create(Note) activities directly. It can reconstruct threads from inReplyTo and ignore the container model. In that environment, thread authority exists only where it is voluntarily recognized.

The delivery path changes as well. Under typical federation, actors deliver activities directly to recipients’ inboxes. Here, replies flow to the conversation owner first. Only approved entries are redistributed. Each thread effectively runs through a single coordinating node. Availability now depends on the owner’s server. If it is offline or slow to redistribute, the conversation stalls. Different redistribution behavior across instances can also produce divergent views of the same thread. This is a structural shift in how information propagates.

Ordering and consistency are less defined than the container model implies. ActivityPub does not specify global ordering or conflict resolution rules. An OrderedCollection provides sequencing, but not append-only guarantees or convergence constraints. Order might reflect author timestamps, owner receipt time, or redistribution time. The owner can reorder, omit, or later insert activities. Other servers may cache earlier states. Without cryptographic sequencing or a log structure that constrains mutation, synchronization relies on local policy rather than shared verification.

Moderation authority also changes. The conversation owner decides which activities become part of the visible thread. That may reduce unwanted replies in cooperative environments. It also concentrates control over inclusion and historical presentation. Because the container remains mutable, integrity depends on trust in the owner. It also depends on how other servers interpret updates.

The harassment issue is not actually solved. A non-adopting instance can continue storing and rendering replies it receives directly. Some servers will display only curated entries. Others will not. Over time, different thread views can coexist without converging.

Compatibility with existing implementations raises practical concerns. Most current systems build conversation views from inReplyTo chains and local storage. Introducing container-centric validation, authenticated Add wrapping, and modified inbox handling would require substantial changes. Partial adoption would produce mixed behavior across the network.

The proposal acknowledges risks such as forged or poisoned embedded updates. It also suggests validation steps. Even with those measures, the container remains mutable shared state interpreted by independent systems. ActivityPub standardizes vocabulary and delivery, but not global state enforcement. This design can improve reply gating among cooperating servers. It does not, by itself, establish authoritative thread state across a federation built on autonomous peers.

The issue with the fediverse is that they want their cake and they want to eat it, too. They like to emphasize that they are truly decentralized and use that as a way to sweep any critiques against them in relation to the AT protocol away. But being truly decentralized is the issue.

The core issue is the federated and decentralized nature of ActivityPub. The problem is that the protocol is built around autonomous servers that don’t have to obey a central authority. Each server applies its own rules and policies. Even if a specification says servers “should” reject unapproved replies, they can still accept and display them. The authority is voluntary and not enforceable. The major limitation is that state is not globally enforced. There is no mechanism to ensure that all servers see the same thread order or content. A container can sequence posts. Other servers can reorder, omit, or cache different versions. Without cryptographic or append-only logs that every node verifies, synchronization relies entirely on local trust rather than any shared enforcement.

Partial adoption makes it even more of a clusterfuck. Some servers might implement the new authoritative-thread model, while others won’t. So threads will diverge across the network, and harassment or unwanted content can still appear on servers that do not participate. The decentralized and federated design fundamentally limits any attempt to impose global authority.

No, I am not joining in on the thread, because ActivityPub devs are especially nasty. That is why no one wants to fucking work with them. That is why it’s so fucking underdeveloped.

I was going to put this into this post, but I realized it would get too long:

https://neon-blue-demon-wyrm.x10.network/archives/16790

This is a really bad situation. I have been working with the AT protocol for roughly a year, so I haven’t been keeping track of what’s been going on here. Basically, the only way to fix it is to pretty much change the expected behavior so much it is no longer recognizable. Yikes!

So, I’m a developer. I am following along with and reading this thread:

https://oisaur.com/@renchap/116056634129526611

All I can think while reading this is: Well, that’s unfortunate.

So, one of the very popular features on Bluesky—also popular on Twitter—is the ability to select who can reply to a post. A major issue in the Fediverse is the inability to decide who can reply, and once you block someone, their harassing reply is still there. I honestly thought it was simply a case of them choosing not to add or address it for cultural reasons. What is clear from that thread is that they were always aware that the ActivityPub protocol and most Fediverse implementations don’t provide a universal way to control reply visibility or enforce blocks across instances. They were hedging and hiding behind cultural norms this whole time instead of working to fix it, because they were too busy waging political culture wars instead of doing their damn jobs.

That realization sunk my hopes. It basically means that the social media ecosystem with the most moderation tools is Bluesky and the ATmosphere, albeit Bluesky isn’t fully using all of them and is using the moderation tools in ways that selectively moderate according to their enigmatic interests. That does not make me feel good. Honestly, that makes me feel fucking awful about the future of the Internet.

ActivityStreams/ActivityPub was formalized around 2018, and platforms like Mastodon (which implement the ActivityPub protocol) have had years to work on federation and moderation tooling. Instead, many of those years were spent debating culture and writing manifestos. The most disturbing thing about all of this is that it had so much potential. But yeah, I think the Fediverse is going to be relegated to a legacy platform like Usenet or IRC. It’s not fixable, and the folks over at the Fediverse have alienated so many developers that no one really wants to work on fixing it.

The co-authors of ActivityPub are working on other social media projects that have nothing to do with the fediverse. Meanwhile, Mastodon’s founder, Eugen Rochko, stepped down as CEO in November 2025 as part of Mastodon’s transition to a nonprofit governance structure. The restructuring was intended to formalize governance and reduce reliance on a single individual. Rochko transferred control of Mastodon’s core assets and trademark to the nonprofit organization and remains involved in a strategic and advisory capacity. Day-to-day operations are now overseen by an executive director under a board-governed structure. I believe how badly Eugen fucked Mastodon is a large reason why he stepped down, albeit they are all doing the virtue signaling thing.

For the most part, I have pretty much pulled away from microblogging platforms as a whole. I was never a heavy user of anything but forums, and I was part of the occult niche. Since that is pretty much gone, there really isn’t a reason for me to be on social media, which is why I mostly blog. It really sucks because I wanted to believe in ActivityPub and the fediverse.

It pretty much comes down to the fact that the ActivityPub protocol is flawed at the protocol level when it comes to protecting people from harassment. While Bluesky’s app view is choosing to apply its tools selectively to address this, it is more capable of protecting people. Honestly, that really sucks, because that spells the death of this protocol. ActivityPub’s decentralized design doesn’t provide built-in, enforceable protections against harassment. This makes moderation and harassment mitigation practically impossible.

Renaud Chaput so much as admits it here:

“So we need to consider if we want to switch to a “thread context”-based approval model, there the author of the root of the thread controls all the tree of replies. Which would be a big change for Mastodon (and similar implementations), but might be more aligned with what user want, and solve other issues as well (replies federation).
But that would be a huge undertaking, with lot of problems related to backward compatibility (for example)”

What I noticed was this phrase by Renaud Chaput:

“First step for us is probably staying alive and continuing having a team that is focused on building a better product, which is our focus right now. We are very well aware of this topic (as I keep repeating each time you mention me 😉 ).”

They are saying the quiet part out loud: We are having issues staying relevant.

ActivityPub is built on the ActivityStreams 2.0 vocabulary. Three core components define it: Actor, Object, and Activity. It provides a Client-to-Server (C2S) API that lets an Actor submit Activities to an outbox. It also provides a Server-to-Server (S2S) federation protocol. This protocol delivers those Activities to other servers’ inboxes.

Replies are created by setting the inReplyTo property on an Object. Servers may expose a replies Collection. However, that collection is optional and not globally authoritative. The specification describes how Activities are serialized and delivered. It does not introduce a canonical container for conversations. It does not define a required global index or binding enforcement rules for moderation. A Block Activity is defined as a type of Activity. However, remote servers are not obligated to remove or hide content beyond their own policies. Each server maintains its own inboxes, outboxes, collections, and storage model. It interprets incoming Activities according to local implementation choices.

This facilitates interoperability at the transport and vocabulary level. It does not do so at the level of governance. Servers do not have to construct identical conversation graphs from inReplyTo chains. Nothing in the protocol allows an Actor to assert authoritative control over all descendant replies. This is the main problem. Federation operates peer to peer among autonomous servers. Moderation decisions, including defederation, filtering, and suspensions, remain local. The specification does not define a global control layer.

The AT Protocol approaches the problem differently. Users are identified through Decentralized Identifiers (DIDs). They publish signed records stored in repositories. These repositories are usually hosted on a Personal Data Server (PDS). They are append-only and cryptographically verifiable. Records follow schemas defined in Lexicon. Lexicon describes types, fields, and RPC interfaces in machine-readable form. Updates propagate through relays. These relays aggregate repository changes into a network-wide event stream, often called the firehose. Higher-level services, including AppViews, subscribe to this stream. They may also query indexes derived from it. The AT Protocol defines message delivery, identity, storage, and synchronization.

Within the AT Protocol, moderation operates across the same repository data. Labeling and visibility controls are expressed as structured records. Clients or AppViews can apply them deterministically if they choose to consume them. Content exists as signed records keyed by DIDs. It is distributed through relays. Moderation services therefore work against a consistent dataset rather than isolated server copies. Identity portability follows from this structure. Users can move between hosting providers without losing their DID, repository history, or social graph.

ActivityPub standardizes how Activities move between servers and how they are described. It leaves indexing, thread authority, and enforcement to individual implementations. The AT Protocol defines repository structure, identity binding, record schemas, and synchronization across the network. ActivityPub centers on federated message exchange with local policy control. No participant has protocol-level authority over the shape or visibility of a conversation once it federates. The AT Protocol centers on a shared record system with portable identity and network-wide data propagation. Moderation and visibility decisions can attach to the same canonical records seen across the network.

In ActivityPub’s model, moderation is local. If someone replies to you in a harassing way, your server can hide it, block it, or defederate from the offending server. Other servers may still store, display, and propagate those replies according to their own policies. There is no protocol-level mechanism that lets you assert binding control over how replies to your post are indexed or rendered elsewhere. Harassment mitigation is fragmented. Harassment can persist in parallel contexts even after you act against it locally.

In the AT Protocol model, content exists as signed records in repositories keyed to portable identities. It is distributed through a shared data propagation layer. Because of this, moderation services can operate against a consistent dataset. Labels, visibility controls, or account-level actions can attach to the same canonical records that other services consume. While it does not eliminate harassment, it makes it technically possible for moderation decisions to propagate more coherently across applications that choose to honor them.

So the difference for harassment is this: in ActivityPub, protection is inherently piecemeal and server-scoped. In the AT Protocol, protection can be structurally network-aware. Identity, storage, and moderation signals live in the same shared data model.

Basically, the fediverse has no means to keep vulnerable, marginalized people safe. The AT Protocol does, albeit the Bluesky app view chooses not to use it. The point is that it has the potential. The last time I tried to explain all of this, I was harassed by a person who operates multiple servers and accounts on here:

@FediThing @FediTips @[email protected] @[email protected] @[email protected] and @[email protected]

The protocol is fundamentally flawed, and they do not know how to fix it. These people are incapable of good-faith conversations, so I am avoiding tagging them or attaching this response.to the thread, because their response is basically to stall, hedge, and gas light.

I’m not a fan of Bluesky — not at all. I really wanted to love ActivityPub, but I think Eugene pretty much killed it within the last three years. They had a very narrow, myopic culture and vision in mind, where they completely ignored all criticisms. Now, there is really no way to fix this mess, which is why they stick to gaslighting their users and literally harassing any developer who criticizes them. Social media has normalized lying to its users, so am I surprised?

Edit:

What a surprise. An anti-black reaction that pulls the it is okay to ignore you because you are an angry black person. Yes, black people are angry, and that you do not understand why is the problem.

I’m not going to go back and forth with a racist, nor am I going to quote them because of my stance on spreading misinformation and vitriol. A person who was implicated in the anti-Black behavior of the fediverse tried to discredit me as a Black person by claiming that I am not on Blacksky, have not worked on Blacksky, and am not happy or positive enough to be included in the Black folks who have been harmed by anti-Blackness.

Yes, they said that with a straight face. Blacksky exists because Black people were angry at being mistreated by the fediverse. Ergo, since I am not happy about being mistreated, I can’t be part of that demographic of Black folks. They are tacitly expecting trustworthy Black people to respond to abuse by being happy. What kind of Jim Crow shit is this? Therefore, it is acceptable to dismiss my experiences as a Black person because I don’t conform to the stereotype of what a Black person in America is.

In other words, they are saying I am a hostile angry black person, and we can disregard what I have to say because I am an angry Black person in Donald Trump’s America.

What kills me is that these folks have no insight into their own racism. This is all the attention they get, because I believe racists should be isolated among other things. They truly believe they are the good guys and that the savior complex is an imperialistic colonial archetype flies over their heads I don’t think white racists can ever change, so I will not be addressing them. That’s all I will say about that.

Edit again:

Welp, after seeing the first edit, the hit racist dog deleted the top level of the thread about me. That is what is called a consciousness of guilt, because if they had genuine good intentions and truly believed what they said was right, they would have said it with their whole chest and would not have deleted the top thread reply. Also, the little group of Fediverse racists explicitly rushed to report me. Report me to who—myself? It’s my instance. I have not explicitly violated any rules of this person’s home instance, but they feel entitled to try and have me removed from the Fediverse because I did not respond to their triangulation, brigading, and harassment by being nice. I did not take the mistreatment with a smile and a nod. Racist white people can fuck all the way off.

I am Not Migrating Back To IRC

So, with this whole Discord surveillance age verification situation, I am seeing lots of talk on every social media platform, including Discord ironically, about moving back to IRC. I am not going back to IRC. Though, I do not really have a valid interest in it, because I use Discord just to monitor occult cults and extremist groups, lol. So, it is not like I would be really displaced, anyway. I would just need to figure out a new exploit or hack.

I’m a Computational Biologist, so I am half in Biology and half in software engineering. I tend to look at technology and evolution as analogous to one another. Software, dynamical systems, and evolution are analogous. Evolution functions like a survivorship process. Lineages that leave more descendants become more represented over time where drift, mutation, recombination, and migration all perturb the system. It’s a stochastic dynamical system.

Speciation is a change under isolation. Once gene flow is cut off, divergence accumulates. Eventually, compatibility breaks, creating a divergence. A fork. You can think of it in a version control system like this: you stop merging upstream commits. You accumulate independent changes, and at some point the codebases are no longer interchangeable.

With evolution, even when traits resemble ancestral forms, they arise through new mutations in the current system. It’s a forward, not backward, branch. So from an evolutionary and software engineering perspective, progress happens by forking and optimizing what exists. That means you will not get progress by trying to migrate everyone back to legacy infrastructure.

I’m not migrating to IRC because it is not progress or evolution. It is technologically regressive. Regressive attitudes are why we are essentially in a weird, industrial, cyberpunk version of the 1930s right now. Hoping old-school forums make a comeback and that everyone migrates back to IRC is a technological and societal regression. It’s the same nostalgia-driven impulse that MAGA rides on. It’s not evolutionary or progressive. It’s regressive and backward. So that triggers all the alarm bells in my head, because this is sort of how we got here. Donald Trump rode in on a regressive platform of nostalgia and populism. Roughly 10–12% of Bernie Sanders supporters in 2016 voted for Donald Trump under that wave.

Trump’s 2016 rise was driven significantly by populist themes such as critiques of establishment politics, nationalism, economic resentment, and appeals to voters dissatisfied with the status quo in both parties. Anyone paying attention in 2026 should see the cycle repeating itself. This weird form of technological regression is a techno-populist version of it. America never learns is lesson, does it?

Currently, I am on Matrix, albeit I use it more or less for bridge and puppeteer bot purposes. To me, it’s like going back to using muskets when everyone else is using AK-47s. The solution is not to make more regressive pieces of technology. They are least effective when you are essentially in a guerrilla, stochastic war with your own fascist government.

BlueSky’s Solution To Moderating Is Moderating Without Moderating via Social Proximity

I have noticed a lot of people are confused about why some posts don’t show up on threads, though they are not labeled by the moderation layer. Bluesky has begun using what it calls social neighborhoods (or network proximity) as a ranking signal for replies in threads. Replies from people who are closer to you in the social graph, accounts you follow, interact with, or share mutual connections with, are prioritized and shown more prominently. Replies from accounts that are farther away in that network are down-ranked. They are pushed far down the thread or placed behind “hidden replies.”

Each person gets their own unique view of a thread based on their social graph. It creates the impression that replies from distant users simply don’t exist. This is true even though they’re still technically public and viewable if you expand the thread or adjust filters. Bluesky is explicitly using features of subgraphs to moderate without moderating. Their reasoning is that if you can’t see each other, you can’t harass each other. Ergo, there is nothing to moderate.

Bluesky mentions that here:

https://bsky.social/about/blog/10-31-2025-building-healthier-social-media-update

As a digression, I’m not going to lie: I really enjoyed working on software built on the AT protocol, but their fucking users are so goddamn weird. It’s sort of like enjoying building houses, but hating every single person who moves into them. But, you don’t have to deal with them because you’re just the contractor. That is how I feel about Bluesky. I hate the people. I really like the protocol and infrastructure.

I sort of am a sadist who does enjoy drama, so I do get schadenfreude from people with social media addictions and parasocial fixations who reply to random people on Bluesky, because they don’t realize their replies are disconnected from the author’s thread unless that person is within their network. They aren’t part of the conversation they think they are. They’re algorithmically isolated from everyone else. Their replies aren’t viewable from the author’s thread because of how Bluesky handles social neighborhoods.

Bluesky’s idea of social neighborhoods is about grouping users into overlapping clusters based on real interaction patterns rather than just the follow graph. Unlike Twitter, it does not treat the network as one big public square. Instead, it models networks of “social neighborhoods” made up of people you follow, people who follow you, people you frequently interact with, and people who are closely connected to those groups. They’re soft, probabilistic groupings rather than strict labels.

Everyone does not see the same replies. Bluesky is being a bit vague with “hidden.” Hidden means your reply is still anchored to the thread and can be expanded. There is another way Bluesky can handle this. Bluesky uses social neighborhoods to judge contextual relevance. Replies from people inside or near your social neighborhood are more likely to be shown inline with a thread, expanded by default, or served in feeds. Replies from outside your neighborhood are still public and still indexed, but they’re treated as lower-context contributions.

Basically, if you reply to a thread, you will see it anchored to the conversation, and everyone will see it in search results, as a hashtag, or from your profile, but it will not be accessible via the thread of the person you were replying to. It is like shadow-banning people from threads unless they are strongly networked.

Because people have not been working with the AT Protocol like I have, they assume they are shadow-banned across the entire Bluesky app view. No—everyone is automatically shadow-banned from everyone else unless they are within the same social neighborhood. In other words, you are not part of the conversation you think you are joining because you are not part of their social group.

Your replies will appear in profiles, hashtag feeds, or search results without being visually anchored to the full thread. Discovery impressions are neighborhood-agnostic: they serve content because it matches a query, tag, or activity stream. Once the reply is shown, the app then decides whether it’s worth pulling in the rest of the conversation for you. If the original author and most participants fall outside your neighborhood, Bluesky often chooses not to expand that context automatically.

Bluesky really is trying to avoid having to moderate, so this is their solution. Instead of banning or issuing takedown labels to DIDs, the system lets replies exist everywhere, but not in that particular instance of the thread.

I find this ironic because a large reason why many people are staying on Bluesky and not moving to the fediverse—thank God, because I do not want them there—is discoverability, virality, and engagement.

In case anyone is asking how I know so much about how these algorithms work: I was a consultant on a lot of these types of algorithms, so I certainly hope I’d know how they work, lol. No, you get no more details about the work I’ve done. I have no hand in the algorithm Bluesky is using, but I have proposed and implemented that type of algorithm before.

I have an interest in noetics and the noosphere. A large amount of my ontological work is an extension of my attempts to model domains that have no spatial or temporal coordinates. The question is how do you generalize a metric space that has no physically, spatial properties. I went to school to try to formalize those ideas. Turns out they’re rather useful for digital social networks, too. The ontological analog to spatial distance, when you have no space, is a graph of similarities.

This can be modeled by representing each item as a node in a weighted graph, where edges are weighted by dissimilarity rather than similarity. Highly similar items are connected by low-weight edges, while less similar items are connected by higher-weight edges. Distances in the graph, computed using standard shortest-path algorithms, then correspond to degrees of similarity. Closely related items are separated by short path lengths, while increasingly dissimilar items require longer paths through the graph. It turns out that attempts to generalize metric spaces for noetic domains—to model noetic/psychic spaces—are actually pretty useful for social media algorithms, lol.

Astroturfing Is Pretty Pointless When Social Subgraphs Are Fragmented (e.g., the Fediverse)

I am seeing astroturfing in the fediverse again, by AT Protocol developers implicitly trying to shill their products. I think it is stochastic behavior by developers with too much time on their hands. Honestly, I do not care. I like the people on ActivityPub more, but I like the AT Protocol better, and I have developed for both. Astroturfing on ActivityPub networks is fascinating to me because it is so pointless.

I am actually a Computational Biologist and Computer Scientist whose specialty is combinatorics, social graphs, graph theory, etc. Specifically, I use this to create epidemiological models for the memetic layer of human behaviors that act as vectors for diseases, using the SIRS model. I do not just study germs; I study human behaviors.

The models I construct extend into a “memetic layer,” in which beliefs, norms, and behaviors (such as risk-taking, compliance with public health measures, or susceptibility to misinformation) spread contagiously through social networks. These behaviors function as vectors that modulate biological transmission rates. As a result, the spread of ideas can accelerate, dampen, or reshape the spread of disease. By running computational simulations and agent-based models on these graphs, I study how network structure, influential nodes, clustering, and platform-specific dynamics affect behavioral contagion. I also examine how these factors influence epidemiological outcomes.

To say it very concisely, I study how the spread of bat-shit insane beliefs, shit posts, and memes influences whether or not there is a measles outbreak in Texas. Ironically, this is an evolution of my studying semiotics, memetics, and chaos magick in high school. I got a job where I can use occult, anarchist techniques professionally.

I think a large reason why I do not care about astroturfing in the fediverse is that it’s so pointless, lol. Astroturfing to manipulate the narrative would actually work better on Bluesky to keep people there than trying to recruit from the fediverse. Furthermore, big instances are relatively small. Some people on Bluesky have follower lists larger than an entire large instance in the fediverse.

Within ActivityPub networks, astroturfing rarely propagates far, because whether information spreads depends on properties of the social graph itself. Dense connectivity, short paths between communities, and a sufficient number of cross-cutting ties support diffusion. ActivityPub’s architecture tends to produce graphs that are fragmented and highly modular. This limits the reach of coordinated activity.

ActivityPub is a system where each instance maintains its own local user graph and exchanges activities through inboxes and outboxes. This makes it autonomous and decentralized. The network consists of loosely connected subgraphs. Cross-instance edges appear only through explicit follow relationships. The ActivityPub protocol does not provide a shared or complete view of the network. Measurements of the fediverse consistently show uneven connectivity between instances, clustering at the instance level, and relatively long effective path lengths across the network. Under these conditions, large cascades are uncommon.

Instance-level clustering means that in ActivityPub networks, users interact much more with others on the same server than with users on different servers. Because each instance has its own local timeline, culture, and moderation, connections form densely within instances and only sparsely across them through explicit follow relationships. This creates a network made up of tightly connected local communities linked by relatively few cross-instance ties, which slows the spread of information beyond its point of origin.

However, with the AT Protocol, global indexing and aggregation are explicitly supported. Relays and indexers can assemble near-complete views of the social graph. Applications built on top of this infrastructure operate over a graph that is denser and easier to traverse. There are fewer structural barriers between communities. The diffusion dynamics change substantially when content can move across the graph without relying on narrow federated paths.

Astroturfing depends on coordinated amplification, typically through tightly synchronized clusters of accounts intended to manufacture visibility. Work on coordinated inauthentic behavior shows that these tactics gain traction when they intersect highly connected regions of the graph or bridge otherwise separate communities. In networks with strong modularity, coordination remains local. ActivityPub’s federation model produces this kind of modularity by default. Coordinated clusters stand out clearly within instances. Their effects remain confined to those local neighborhoods.

Astroturfing on ActivityPub therefore tends to stall on its own because of the underlying graph topology. Without dense inter-instance connectivity or any form of global indexing, coordinated campaigns have a hard time moving beyond the immediate regions where they originate. Systems built on globally indexable social graphs, including those enabled by the AT Protocol, expose a much larger surface for viral spread. Network structure and connectivity account for the divergence where that is independent of moderation, cultural norms, ideology, or intent.

It’s just really funny to me how these stochastic techbro groups waste so many resources. I personally don’t want to go viral, which is why I avoid platforms where I can. The fact that it’s harder to achieve high virality on ActivityPub is exactly why I prefer the fediverse over the Atmosphere. One way to think about it is that you can change the ‘genetics’ of a system with a retrovirus, where memetic entities act as cultural retroviruses to reprogram the cultural loci of a space. That is their end goal. They are trying to hijack cultures memetically. You see this a lot with culture jamming.

Basically, the astroturfing on ActivityPub networks is designed to jam and subvert the culture. But, as I have already said, the topological structure makes memetic virality stall. They cannot achieve that kind of viral spread in the fediverse, which is why I cannot understand why they do this every year.