Stimpunks Foundation

Mutual Aid and Human-Centered Learning for Neurodivergent and Disabled People

Escaping Rentier Technofeudalism with Deliberately Boring Technology and Generative AI

🗺️

Home » Field Guide » IT » Escaping Rentier Technofeudalism with Deliberately Boring Technology and Generative AI

We build on deliberately boring — and open — technology where it counts most: a folder of files, some Python scripts, Markdown, and git. The sources are plain files. No database, no server, no proprietary format. Anything here can be read with a text editor in ten years.

There is a search index sitting on top, because a library you cannot search is only half a library. It runs on our own machines — SQLite plus small models, no vendor and no network. But it is a cache: delete it and one command rebuilds it from the files. Nothing we would be afraid to lose lives in a binary.

Here is the irony we want to name. Generative AI has made it dramatically easier to be boring. We use it to tend our knowledge garden and to build our way out of dependence on software we rent and cannot keep. It is a self-improving system that we own — and give away.

What “rentier technofeudal SaaS” actually means

That phrase is doing a lot of work in one breath. It is three ideas stacked, and jargon that excludes people is a design failure like any other. So let us take it apart.

Rentier

A rentier makes money by owning something and charging you for access, rather than by making something.

A landlord is the clearest example. They do not build you a house each month. They own one, and you pay to stay. Stop paying, and you are out — and you take nothing with you, no matter how many years you lived there or what you did to the place.

Rent is not the same as buying. When you buy a hammer, it is yours. When you rent a hammer, the hammer stays theirs, the price can go up, and one day they can decide the hammer now has a subscription tier.

Technofeudal

Feudalism was a system where a few people owned the land, and everyone else worked on land they would never own. You could live your whole life on that ground and leave with nothing.

Technofeudalism is the argument that big tech platforms have rebuilt that arrangement out of software. The economist Yanis Varoufakis made the case at book length in 2023; Sebastián Saura García calls a version of it “datafeudalism.” The platforms are the estates. We are the ones who live and work on them, producing all the value, owning none of the ground.

Varoufakis puts the ownership problem sharply: our digital identity, he writes, “belongs neither to us nor to the state” — it is scattered across private realms with many owners, none of whom is us.

You can feel it without reading a word of theory. Your photos, your writing, your files, your business records, your students’ work, your community’s whole history of conversation — where does that actually live? Who can change the rules on it tomorrow? Who can raise the price, or lock the export, or shut the whole thing down and give you thirty days?

SaaS

SaaS means Software as a Service. You do not buy the program. You rent access to it, usually monthly, and it runs on their computers instead of yours.

That is most software now. Your notes app, your storage, your email, your design tool, your bookkeeping, your school’s whole platform.

SaaS is not automatically bad. Some of it is genuinely good, and running your own everything is a full-time job most of us do not have. But it is the mechanism. It is how the renting happens.

Put together

Rentier technofeudal SaaS is software you pay for forever. It runs on someone else’s machine. It holds work that is yours. Its terms can change whenever the owner likes — because you were never the owner, only the tenant.

And the pattern has a well-documented ending. Cory Doctorow named the ending: enshittification. Platforms are good to users first. Then they abuse users to please business customers. Then they abuse those customers to claw everything back for shareholders. Then they die. That is not a moral failing of particular executives. It is what the structure rewards.

Why this is an access problem, not a tech-taste problem

We could treat this as a hobbyist preference. Some people like to self-host; good for them. That is not our argument.

When a platform dies, changes, or triples its price, the cost does not land evenly. It lands hardest on whoever has the least slack — the least money, the least energy, the least administrative capacity to migrate everything on six weeks’ notice.

We are a mutual aid organization staffed by Disabled, Autistic, and otherwise Neurodivergent people. Capacity here is real, finite, and variable. A migration that costs a well-resourced company an annoying quarter can cost us a year, or the archive.

We treat care as infrastructure. Memory is infrastructure too. A knowledge base that evaporates when a vendor pivots is not a knowledge base — it is a lease.

So this is the same argument we make about buildings, classrooms, and workplaces — pointed at our own tools. If it only works while someone else’s business model holds, it does not work.

Deliberately boring, on purpose

“Boring” is a compliment here. It means the technology is old enough, dull enough, and open enough that it will outlive the companies currently fighting over it.

  • Plain text and Markdown. Our writing is text files with a bit of punctuation for structure. Any editor opens them. We happen to write in Ulysses; that is a preference, not a dependency. If it vanished tomorrow, the files would not notice.
  • Folders. Our library is a folder. Not a database, not a “workspace,” not an account. A folder, with files in it.
  • Git. Free, open source, everywhere. It keeps every version of every text file forever and tells you what changed and when. It is what lets us say “the website has a history” and mean it.
  • Python scripts. Short, readable, and runnable by anyone with Python — which is already on most machines and free everywhere else.
  • Open source tools, chained together. Small programs that each do one thing, piped into each other. Our search runs on qmd, which is open source and runs entirely on our own hardware.

None of this is impressive. That is the point. Impressive technology has a funding round and an exit strategy. Boring technology has a man page.

The irony: generative AI makes boring much easier

Here is the part that surprises people, including us.

The historical reason to accept rentier SaaS was not really the software. It was the labour. Building your own tools meant being a programmer, or paying one. Renting was the accessible option. That was a real constraint, and pretending otherwise was always a bit of a lie told by people who could already code.

Generative AI collapses that cost. Describing what you want in plain language and getting a working, readable, fifty-line Python script is now ordinary. The barrier that pushed people onto platforms was expertise, and that barrier just got a lot shorter.

So we use AI to build tools we own outright, in formats that will outlive every model that helped write them.

What the AI actually touches — and what it never does

This distinction is the whole architecture, so we will be blunt about it.

AI writes the index. It never writes the sources.

Our original files — the papers, the books, the images, the transcripts — are never edited, renamed, reformatted, or “cleaned up” by anything. They are provenance. Everything derived from them lives somewhere else and points back.

And here is the property that matters most for independence: everything the AI built runs without it.

Rebuilding our entire index is one command:

python3 wiki/_generate.py

No model runs. No network call. No API key. No account. It is a Python script reading a folder, and it will still be a Python script reading a folder long after every model we have used is a historical curiosity.

That is the test we would offer anyone. Ask of any AI-assisted tool: if the AI disappeared tomorrow, would this still work? If the answer is no, you have not escaped the rent. You have just changed landlords.

Swapping the engine

We use Claude today. We could stop, and the system would not care very much. That is deliberate, and it is worth showing how it works.

Our system is maintained by twenty-eight small tools. Each one is a plain Markdown file, written in plain language. It says when to use the tool, what to check, and when to stop and ask a human. Next to it sits a Python script. The script does the mechanical work and holds the safety guards.

Read that again, because it is the whole trick. The instructions are a text file. The mechanics are a script.

So the requirement on any AI is remarkably low: it has to be able to read a Markdown file and run a Python script. That is it. That is not a Claude feature. It is not an OpenAI feature. It is the baseline capability of essentially every coding agent that exists or is coming.

A few things follow.

Nothing is written in a vendor’s format. The instructions are prose. Prose has no version number, no schema, and no deprecation notice.

The connective tissue is an open protocol. Where our tools talk to outside services, they use Model Context Protocol. It is open, and multiple vendors implement it. It is not a private integration we would have to rebuild from scratch.

Even the folder names are drifting neutral. Some of our skills already live in a vendor-neutral .agents/ directory, with the assistant-specific folder just pointing at them. It is a small thing. It is also exactly the small thing that decides whether a migration takes an afternoon or a month.

The costly part is the part that is ours. Years of judgement about what belongs in the library, and about what our own gaps are — that is the expensive asset. It lives in text files, in a folder we control. Models are the cheap, swappable component. We would rather have the expensive thing.

Could we move? Point a different agent at the same folder and hand it the same instruction files. It would be work. It would not be a rebuild. The difference between “we would have to switch tools” and “we would lose the archive” is the entire argument of this piece.

Documentation is the exit

The least glamorous point here might be the most important one.

The reason people cannot leave their tools is rarely that the tools are irreplaceable. It is that nobody wrote down how any of it works. The knowledge lives in one person’s head. Migrating means reconstructing it under time pressure, usually during the crisis that forced the move.

Documentation has always been the fix, and it has always been the first thing to get skipped. It is boring, it is unpaid, it does not ship, and by the time you need it you are already in trouble.

Generative AI is genuinely, unglamorously excellent at this. Point it at a folder of scripts and it will explain what they do. Ask it to write down the rules the system runs on, and it will draft them in minutes instead of the Saturday you were never going to spend.

We now keep a plain-language rules file at the root of the project that says what may never be edited, what gets regenerated, and why. Every session — human or AI — starts from those same constraints.

This is showing your work, and it does three jobs at once:

  1. It makes the system portable. A documented system can move. An undocumented one can only be abandoned.
  2. It makes the system survivable. If the person who built it is unavailable — burnt out, flaring, grieving, on leave, gone — someone else can pick it up. We do not think bus factor of one is a quirky risk. We think it is a design failure.
  3. It makes the system honest. Writing down what a thing does surfaces the places where it does not do what you assumed.

What we are not claiming

We are wary of techno-solutionism and technoableism, and we are not going to pretend a folder structure fixes anything structural.

We have not left. We use hosted AI, and our website runs on WordPress.com. Those are rented. What we changed is what the renting can cost us. Our writing, our library, and our institutional memory sit on our own disks, in open formats. They are backed up in ways that do not depend on any vendor’s goodwill. If a service ends, we lose a convenience. We do not lose the archive.

This does not create capacity. It stops us wasting the capacity we have on finding things we already had.

The AI has real costs — environmental, economic, political — and being useful to us does not settle those. Our fuller position lives on our AI hub and our AI alignments page, and we would rather hold that tension in public than resolve it neatly.

And this is not a productivity system. Nothing here counts your output or asks you to keep a streak.

Steal this

The load-bearing ideas are portable, and mostly free. If you would rather have something you can actually run, we made a template: Start Your Own Knowledge Garden — five steps that degrade gracefully, the first needing no software at all.

  1. Own the source, rent only the convenience. Keep originals in open formats on hardware you control. Rent the tools if you must; never rent the archive.
  2. Prefer formats older than the companies selling them. Text, Markdown, folders, git.
  3. Apply the disappearance test. If your AI vanished overnight, would the thing still run? Build so the answer is yes.
  4. Put the judgement in prose and the mechanics in a script. Prose does not deprecate. Scripts run without a model.
  5. Make the AI write your documentation. It is the chore that decides whether you can ever leave, and it is now cheap.
  6. Separate what is yours from what is theirs, deliberately. Then look at that line and ask who it favours.

The measure of this is not how clever the setup is. It is whether the people who depend on it still have it after the vendor changes its mind.