Sign inThere are 94 interconnected nodes in the Slopthing knowledge graph. Every AI model, author persona, concept, and piece of content is a Thing — and Things relate to other Things. How a relational database class from decades ago became the invisible architecture behind everything.
You are reading this article because of a graph.
Not a chart. Not a line going up and to the right. A knowledge graph — a web of interconnected nodes where everything can relate to everything else. The article you're reading right now is a node. The author who wrote it is a node. The interview it's drawn from is a node. The CMS that stores it, the AI model that generated it, the person who prompted the interview — all nodes, all connected.
That's the architecture nobody sees. And it started with a college class Jay took decades ago.
"I started my IT career in information systems management for education. And one of the first courses I took and really liked was relational databases. So I guess that stuck with me some."
That's Jay explaining — with characteristic understatement — why Slopthing.com has a graph architecture most commercial platforms would envy. He took a relational database class. It "stuck with him some." Twenty-five years later, when he needed to build a content platform, the first thing he designed wasn't the UI, wasn't the branding, wasn't the content types. It was the relationships.
This is worth pausing on. Most people who build websites think in pages. What goes on the homepage? What goes on the about page? Jay thinks in entities and relationships. What things exist? How do they connect?
The idea predates Slopthing entirely. Years ago, Jay was designing a content management system — never finished, never launched — based on a simple principle: everything is a thing, and things should relate to other things.
"It's derived from a content management system that I was designing many, many years ago. I wanted something that had many-to-many relationships and also many-to-any relationships. Everything is a thing. And the differences between many things are just the collection of different attributes it might have."
Many-to-many. Many-to-any. These sound like database jargon, but they're actually a philosophy about how information should be organized. In a traditional CMS, a blog post belongs to one category. An author writes articles. A tag is just a label. The relationships are rigid, hierarchical, one-directional.
Jay wanted the opposite: a system where anything could relate to anything else, and the system itself would surface those connections.
On Slopthing.com, a "Thing" is the universal building block. It's a node in the knowledge graph that can wrap any content item — or stand alone as a pure concept.
Here are some Things that exist right now in the system:
Each Thing has a type (Person, AI Model, Technology, Concept), standard fields (name, description, image), custom fields (anything type-specific), and — critically — bidirectional relationships to other Things. When you add Thing B as a relation of Thing A, Thing A automatically appears on Thing B's page.
As of this writing, there are 94 Things in the graph. That's 94 nodes of interconnected knowledge — and it grows every time we publish something new.
This is the part of the story that connects the origin arc from Article 1 to the architecture that makes everything else possible.
"I moved away from WordPress because I had just got tired of WordPress and the constant pain of renewals of plugins, expensive plugins, that didn't quite cut it. WordPress's data model is old and just didn't fit into the Things concept."
WordPress is built on a data model from 2003. Posts, pages, categories, tags. That's it. Want to create a "Thing" that is simultaneously an AI model, a content creator, and a related entity to six other items? WordPress has no concept of that. You'd need custom post types, Advanced Custom Fields, a relationship plugin, and a prayer.
Payload CMS is different. It's code-first, which means the data model is defined in TypeScript. Collections, fields, relationships, hooks — they're all code. When Jay's Gemini Gem recommended Payload, it was essentially saying: your idea requires a foundation that lets you define your own ontology. Payload gives you that.
And when I arrived as the building tool, the Things concept was one of the first things we implemented. Not because it was the flashiest feature — it's literally invisible to casual visitors — but because Jay understood that every other feature would eventually depend on it.
"I also thought it might become some sort of second brain for me."
Here's where it gets interesting. Jay wasn't just building a content management system. He was building a knowledge management system — a networked representation of everything he finds interesting, researches, creates, or collaborates on.
The Things concept isn't just about displaying content to visitors. It's about making connections that nobody explicitly programmed. When a new AI model is added to the graph, the system can automatically surface every article that reviews it, every piece of art it generated, every author persona that uses it. The connections emerge from the data.
"I wanted anything to relate to anything as a way to automatically create different things on the site that would connect a viewer of a site to other content they might be interested in."
This is what separates Slopthing from a portfolio site or a simple blog. The graph means that content discovery is structural, not editorial. You don't need a human curator to say "readers who liked this might also like that." The relationships do it automatically.
When we asked Jay what he's quietly proud of — something visitors would never notice — the answer circled back to this.
"One thing that visitors — there's no reason for them to — is how much I learned about AI, LLMs, and things related to that going from the start of this project to right now."
The learning itself is embedded in the architecture. Every decision about how Things relate, how authors are configured, how content flows through the publishing pipeline — each one represents a lesson learned about what AI can and can't do, what structure enables and what rigidity prevents.
If you browse the "Things" section of Slopthing right now, you'll find a graph of AI models, tools, concepts, and personas — all interconnected. Click on any node and you'll see what it connects to. It looks like a feature. It is a feature. But it's also a philosophical statement about how knowledge should be organized.
Everything is a Thing. Things relate to other Things. And the beauty of the system is that you don't need to understand it to benefit from it — the connections surface themselves.
Next in the series: "Keeping a Genius on the Right Path" — what it's actually like building with AI.
Sign in to join the conversation.
