The last thing I wrote here ended with a claim: bring the tool method and intent, and it becomes a lever that moves real work.
That is easy to write in a manifesto. So we went and tested it.
Gume is live, and the code is open. It is a reading log: a place to record what you have read, what you are reading, and what is still waiting on the shelf. It runs on a catalogue of nearly 300,000 Portuguese-language editions. It is licensed AGPL-3.0. It was built in the open, in public, by an advertiser who is not a programmer, working in pairs with an AI agent.
And it is, by a wide margin, the most useful thing I have ever learned from.
What it is, in one screen
Brazilian readers have been stuck with a decaying Skoob for fifteen years, and the alternatives are all foreign, English-first, and built around the wrong instinct. So:
A shelf. Want to read, reading, read, abandoned. Rereads. Physical and digital in the same place. Owning a book and reading a book are different things, and here they are counted separately.
A rating that is a word. Adorei, gostei, achei ok, não gostei, não terminei. Never a number. A star is a scale, a scale becomes an average, an average becomes a scoreboard, and a scoreboard turns reading into a performance.
A chronological feed, and a room to wander. The feed is only people you chose to follow, with nothing injected between them. And there's a separate tab to explore, full of shelves belonging to people you don't follow yet, shuffled rather than ranked. Discovery exists here. It just doesn't come find you.
Files you can take with you. One click, and the file downloads: JSON and CSV, with your shelf, your reading dates, your ratings, your reviews (including the private ones), and every catalogue correction you made. No queue, no email, no "we're preparing your archive," which is friction dressed as care. And the CSV uses the Goodreads export columns, the format Skoob, StoryGraph, Oku and Fable already know how to read. An export is only an exit if another app can open it. A proprietary JSON nobody imports is a ransom note in a nice typeface.
An open book graph. The metadata is corrected by readers, and the intent is to publish it back as an open dataset. If this project dies, the data should outlive it.
The manifesto is a list of refusals
The interesting part of a product is rarely what it has. It is what it will not do, on purpose, when doing it would work.
- No likes, no follower count, no streaks. And no scoreboard. There is an honour on your profile, and there is no list of who read the most. A ranking sorted by books read is a machine for making people lie about reading.
- The honour never falls, and it never looks at the clock. No "books this month," no seasons. Stopping for a year costs nothing. An app that drops your number when life gets hard is an app that punishes the grieving, the sick, and the person with a newborn, and it makes people open a thin book they don't like just to keep what was already theirs.
- Abandoning costs nothing, and the rating doesn't count. Reading and hating is worth exactly what reading and loving is worth. If "adorei" were worth more, the app would be buying compliments. If quitting cost something, nobody would ever quit a bad book again.
- No algorithmic feed. Nothing is ranked and nothing is injected. Your feed is the people you chose, in the order it happened. And when you want strangers, there's a tab for that, shuffled rather than sorted. Discovery you walk into is a different object from discovery that walks into you.
- No affiliate links. No ads. Your reading history is never for sale.
- No engagement notifications. We'll tell you when a friend posts. We will not tell you that your shelf misses you.
Every one of those is a refusal of revenue. That is what makes it a promise instead of a preference.
And here is the one I won't dress up, because it's the honest seam in the whole thing: there is a ladder, and it counts books. Iron, Bronze, Silver, and up, for what you've read in your life. So yes, a thing that goes up when you read more exists in a product that says reading is not a performance.
What we did was strip the ladder of every part that makes a number cruel. It has no leaderboard, so there is nobody to beat. It never falls, so quitting for a year costs nothing. It never looks at the clock, so there's no month and no season. It can't be sorted, so it can't be a ranking. What's left is a slow shape of your life as a reader, visible only to you and the people who already know you.
Is that a clean win? No. A ladder that counts books can be farmed with thin books, and I know it. It's a tension we're carrying on purpose rather than pretending we solved. If you think we got the trade wrong, that argument belongs in an issue, and it will get a real answer.
And the licence is what makes the promise real. If the hosted instance ever stops honouring that list, you take the code, you take your data, and you run your own.
The exit is the point.
It is the exit that makes staying mean something.
The part the tool can't write
Here is the thing I actually came to say.
AI collapsed the cost of writing code. It did not collapse the cost of being wrong. Those are different economies, and almost everyone talking about this in 2026 is still pricing them the same.
One example from this build, and it is the one that still bothers me.
The catalogue importer read two of Open Library's three dump files and never opened the third. The third one is where the authors live. So tens of thousands of books landed in the database with nobody attached to them, and the proposed next step was to delete them as orphans. Flaubert. Tolstoy. Torto Arado. Erased from a library because a file went unread.
No error. No red build. No crash. Every test passed, and the instruction had been followed exactly. Just a confident, fast, wrong answer delivered in seconds, with a tidy cleanup plan attached to it.
It was caught because someone asked what was in the pile before agreeing to burn it.
The agent wrote thousands of lines I could not have written, and it came one question away from deleting Tolstoy.
Both of those are true, and anyone selling you only one of them is selling you something.
So the scarce resource is not code. It is the question asked before the write. It is knowing that a shared record is not yours to overwrite. It is noticing that a vendor's key is provenance, not identity, because Open Library has three different keys for Tolstoy and none of them is him.
That is judgment, and it is the one thing that did not get cheaper.
So the repo defends itself
If the maintainer is not a programmer, then no protection can depend on the maintainer reviewing a diff. I would not catch a bug reading one, and pretending otherwise would be theatre.
So the defence had to be structural. This is the method, and it transfers to every venture we run:
- The decisions are written down before the code. Every hard call lives in a decisions log, with the reasoning, in plain Portuguese. You don't relitigate one without a new argument. An agent with amnesia and a repo with a memory is a workable pair. Two amnesiacs is not.
- Authorization lives in exactly one file, and a script breaks the build if a check appears anywhere else. Not a convention. A gate.
- There are more than 700 tests, and the important ones don't test functions. They scan the codebase. One breaks the build if a screen starts speaking like a developer ("schema", "endpoint", "Phase 4"), because Gume talks to readers. One breaks if a route is born public without anyone deciding it. One breaks if a badge could ever be earned by reading, or if one badge glows brighter than another. One bans a timezone-naive date function everywhere except the file allowed to have it, because that bug once filed a book under the wrong year. And a red team attacks the system, swapping UUIDs to try to read and write another person's rows.
- The CI is the reviewer. Zero human approvals. Green means it ships. That is not blind trust, it is the opposite: it is refusing to pretend that a human rubber stamp is a control.
The lesson generalizes past reading apps. When generation is free, the whole job moves upstream, into deciding what must never be true and encoding that where it cannot be forgotten. The organizations that win this decade will not be the ones with the best prompts. They will be the ones whose constraints are executable.
What I want out of it
I'll be direct, because pretending this is pure altruism would be its own kind of theatre.
I run a studio that puts AI to work across influence, science, applied AI and film. I sell judgment about AI. You cannot sell judgment about a thing you have only briefed other people to do.
So I built the whole vertical myself, badly at first, and in public. Schema design. Authorization. A trigram search over 300,000 rows and why it was slow (I guessed debounce; I was wrong; the agent measured and it was an external call blocking the keystroke). Postgres migrations. CSP headers. CI. A design system. Community governance. Licence choice. Deploy.
The shape people call T-shaped only works if the vertical is real. Mine is advertising, positioning, taste, the read on a screen. What I was missing was the horizontal that this decade actually requires: enough fluency in the machinery to know when the machine is confidently lying to me, and enough taste in the process to structure the work so that the lie gets caught by something other than luck.
You do not learn that from a course about AI. You learn it at 2am when the substring filter is about to delete Jung.
And there is a second reason, and it's smaller and more honest: I read. I got back into reading to bring my anxiety down. It worked. The app I wanted did not exist, so the thing I built to learn on is the thing I actually use every day. That is not a coincidence. It's the only kind of project that survives the boring middle.
The invitation
Gume exists to be built by the people who use it. That is the whole premise, and right now it is short of hands.
You can contribute without writing a line of code, and today this is the most valuable help there is. The catalogue came from an open archive and it arrived incomplete: nearly 266,000 editions with no cover, thousands with no year and no publisher. That does not fix itself, and it does not need a programmer. It needs someone holding the book.
Open o que falta and start with the books on your own shelf. You are the only person on earth who can fix those right now, because all it takes is turning the book over. Every correction is recorded with your name, on the book's page, forever. And your name goes on the contributors page, in the same list, at the same size, as the people who write the code.
A cover fix is worth what a commit is worth.
If you write code: the good first issue labels are real. Each one says what it is, why it matters, which file to touch, and how to test it. None of them requires understanding the whole app.
- The smallest: ISBN-10 to ISBN-13. A pure function, a new file, a test. And it closes a real hole: every book published before 2007 currently sails past a 300,000-edition catalogue and becomes a duplicate.
- The most valuable: importers. StoryGraph, Skoob, LibraryThing, Kindle, Kobo. The bar is lossless: dates, ratings, review text, shelves, ISBN. Half-finished migrations are the single biggest reason people never leave a platform they've already outgrown.
- The hardest and most needed: book data. Matching, deduplication, covers, non-English catalogues. No glamour. It's the moat, and it decides whether the first search a stranger runs works.
You don't need to ask for an issue. Comment "peguei essa" and go. Work on a branch, open a PR, and the CI decides: zero human approvals, green means it ships. Tell us if you used an AI agent, without shame, because we do too: it just tells the tests where to look hardest.
And if you think one of the refusals is wrong, open an issue. The schema, the plan and the design system are public precisely because they are expensive to change later and cheap to argue about now.
Why this is a 4/RL venture
Gume makes no money and is not trying to. One day there will be a way to support it, and it will be optional and cosmetic: a mark on your profile, nothing more. Support never unlocks a feature. The person who pays and the person who doesn't use exactly the same Gume.
So why does a studio ship it?
Because "for real" is a standard, and the slash in our name is the line every project has to cross, from promise to proof. Open source is the harshest version of that crossing there is. You cannot claim it works when anyone can clone it and find out in two commands. You cannot claim you understand the stack when the stack is on the table. You cannot claim the product has principles when the licence hands a stranger the power to fork you the day you break one.
Everything else we build passes through a client, a contract, an NDA. This one passes through you.
Gume is the name for the edge of a blade. The part that cuts.
A blade nobody sharpens doesn't rust overnight. It loses the edge slowly, and it goes on looking exactly like a blade. You only find out when it fails to cut what it always cut.
Minds work the same way. So do studios.
The mind never
loses its edge.
Gume is maintained by 4/RL Co. and hosted at gume.club. AGPL-3.0. Fork it.