From 9a9358ad4632afa2103c7f7d111ffc39a92fbde8 Mon Sep 17 00:00:00 2001 From: adilallo <39313955+adilallo@users.noreply.github.com> Date: Thu, 12 Nov 2026 17:50:40 -0700 Subject: [PATCH] Put the four Learn guides back in reading order and split the two run-on Avoiding Burnout sentences. --- ...ing-burnout-sustainability-in-the-ruins.md | 4 +- ...gital-mediation-and-the-death-of-nuance.md | 8 +- .../blog/how-chaos-concentrates-control.md | 8 +- ...ntegrating-new-members-without-dilution.md | 8 +- ...ge-management-and-institutional-amnesia.md | 4 +- tests/unit/learnGuideCopy.test.ts | 109 ++++++++++++++++++ 6 files changed, 125 insertions(+), 16 deletions(-) create mode 100644 tests/unit/learnGuideCopy.test.ts diff --git a/content/blog/avoiding-burnout-sustainability-in-the-ruins.md b/content/blog/avoiding-burnout-sustainability-in-the-ruins.md index 6d46038..527dffb 100644 --- a/content/blog/avoiding-burnout-sustainability-in-the-ruins.md +++ b/content/blog/avoiding-burnout-sustainability-in-the-ruins.md @@ -54,13 +54,13 @@ Urgency is constant under capitalism. There will always be another crisis, anoth Rest as strategy is the hardest thing to accept because rest isn't something you earn after the work is done. The work is never done. Rest has to be structural, built into how you operate, or it won't happen. -Schedule breaks into your calendar the same way you schedule meetings. Not "take a break when you need it" no one ever needs it until they're already destroyed. Monthly week-long breaks where nothing happens. Quarterly weekend retreats that aren't about work. Built-in downtime between major projects. +Schedule breaks into your calendar the same way you schedule meetings. Not "take a break when you need it." No one ever needs it until they're already destroyed. Monthly week-long breaks where nothing happens. Quarterly weekend retreats that aren't about work. Built-in downtime between major projects. Normalize people being unavailable. If someone says they can't take something on, that's the end of the discussion. No guilt, no pressure, no subtle implications that they're not committed enough. The person who protects their capacity is more valuable than the person who destroys themselves. Building structures for sustainability isn't about being nice to ourselves. It's about building movements that can actually win. That means rotation so knowledge spreads and no one becomes indispensable. That means preserving institutional memory so learning accumulates. That means limiting scope so the work remains possible. That means treating rest as strategy, not weakness. -Rotation means no role is permanent. The person coordinating meetings, managing the budget, maintaining relationships with allied groups, running the communication channels all of it rotates on a set schedule. Six months, a year, whatever makes sense for the role and the group. +Rotation means no role is permanent. The person coordinating meetings, managing the budget, maintaining relationships with allied groups, running the communication channels. All of it rotates on a set schedule. Six months, a year, whatever makes sense for the role and the group. Preserving institutional memory becomes critical when someone burns out and leaves, because they take everything they learned with them. How to navigate specific relationships. What strategies failed before. Why certain decisions were made. The new person starts from zero, makes the same mistakes, learns the same lessons. The group never accumulates knowledge, it just cycles through individuals. diff --git a/content/blog/digital-mediation-and-the-death-of-nuance.md b/content/blog/digital-mediation-and-the-death-of-nuance.md index b6cad4f..f448e8b 100644 --- a/content/blog/digital-mediation-and-the-death-of-nuance.md +++ b/content/blog/digital-mediation-and-the-death-of-nuance.md @@ -14,6 +14,8 @@ background: color: "#FFF1D4" --- +Your organizing group lives in a Discord server. Your mutual aid network coordinates through a Facebook group. Your worker coop runs on Slack. Every conversation, every decision, every conflict gets filtered through platforms designed by corporations to maximize engagement, which is just a polite word for addiction. + This isn't neutral. The medium shapes the message, and algorithmic mediation shapes how we relate to each other in ways that actively undermine the solidarity we're trying to build. Watch what happens in a group chat when someone raises a contentious point. The conversation accelerates. People respond immediately, reacting to the last message without absorbing the whole thread. Nuance disappears. Someone misreads tone, someone else gets defensive, and within twenty minutes you've got a full-blown conflict that wouldn't have happened in a room together. @@ -56,10 +58,6 @@ Stop letting convenience dictate strategy. Yes, everyone's already on Facebook. Learn about alternatives. Research platform coops, explore democratic technology projects, understand what's possible beyond corporate platforms. Support these projects with money and labor when you can. Develop technical literacy within your group. Not everyone needs to code, but someone should understand how your tools work and what the alternatives are. -The anti-social network isn't about rejecting technology. It's about refusing to let corporate platforms mediate all human connection and political organizing. It's about building tools that serve us rather than extract from us. It's about remembering that the most important networks are the ones between actual people, in actual space, building actual power together. - -Your organizing group lives in a Discord server. Your mutual aid network coordinates through a Facebook group. Your worker coop runs on Slack. Every conversation, every decision, every conflict gets filtered through platforms designed by corporations to maximize engagement, which is just a polite word for addiction. - The cooperative model also solves the governance problem. When users control the platform, they can decide collectively what features to build, what data to collect, how to handle moderation. This is democratic technology: tools that serve their users rather than extracting value from them. Use print for things that matter: analysis that took time to develop, information the community needs, calls to action, documentation of victories and lessons. Use it to create physical artifacts of your work that persist beyond the lifespan of any platform. @@ -75,3 +73,5 @@ Technology is shaped by the social relations of its production. Capitalist techn This means investing in democratic alternatives. It means learning technical skills or supporting people who have them. It means treating digital infrastructure as seriously as physical infrastructure. It means refusing to accept that organizing must happen on terms set by corporations. Use print strategically and beautifully. Make things people want to keep and share. Use risograph, xerox, whatever you have access to. The Secret Riso Project shows that small-scale print production can be both accessible and powerful. + +The anti-social network isn't about rejecting technology. It's about refusing to let corporate platforms mediate all human connection and political organizing. It's about building tools that serve us rather than extract from us. It's about remembering that the most important networks are the ones between actual people, in actual space, building actual power together. diff --git a/content/blog/how-chaos-concentrates-control.md b/content/blog/how-chaos-concentrates-control.md index 96a161a..df61a08 100644 --- a/content/blog/how-chaos-concentrates-control.md +++ b/content/blog/how-chaos-concentrates-control.md @@ -38,6 +38,8 @@ Rotating responsibilities prevents the accumulation of informal power. Your grou Name the roles explicitly. Note-taker, treasurer, communications coordinator, whatever you need. Write down what each role does. This isn't about creating a bureaucracy, it's about making power visible so it can be shared. +Rotate them. Six months, a year, whatever makes sense. This prevents anyone from accumulating informal power through being the only person who knows how things work. It also distributes skills across the group. + When someone rotates out, they document what they did and train their replacement. Knowledge can't be hoarded. If only one person understands the finances or the website or the coalition relationships, they have structural power whether you acknowledge it or not. Keep records. Meeting notes, decisions made, rationales discussed. This isn't paranoia, it's memory. Without records, the people who were there control the narrative. @@ -64,12 +66,10 @@ When your worker coop can't make decisions, when your mutual aid network splinte The choice isn't between structure and freedom. It's between explicit structures that can be challenged and changed, and implicit structures that operate in the shadows. One enables democracy. The other prevents it. -Build structures. Make them visible. Change them when they don't work. That's not selling out, that's how you build something that lasts. - Name who can bring proposals and how they get on the agenda. Otherwise the people who are most comfortable speaking up or who talk to the right people beforehand set the agenda by default. -Rotate them. Six months, a year, whatever makes sense. This prevents anyone from accumulating informal power through being the only person who knows how things work. It also distributes skills across the group. - Information access is crucial because hidden information is hidden power. If discussions happen in private chats, if decisions get made in informal hangouts, if context lives in the heads of a few long-timers, you have an invisible hierarchy. Make information accessible. Use shared documents, public channels, whatever works. The point is that anyone in the group can access what they need to participate fully. + +Build structures. Make them visible. Change them when they don't work. That's not selling out, that's how you build something that lasts. diff --git a/content/blog/integrating-new-members-without-dilution.md b/content/blog/integrating-new-members-without-dilution.md index 6237221..fa7c06d 100644 --- a/content/blog/integrating-new-members-without-dilution.md +++ b/content/blog/integrating-new-members-without-dilution.md @@ -34,10 +34,6 @@ This requires the original core to accept that different groups will operate dif Growth means change, and you can't add people without things changing. New people bring new perspectives and energy. If your group can't absorb that, the problem isn't them. -These practices make change manageable. They create structures so integration doesn't depend on heroes working themselves to death. The alternative is slow collapse: your best people burn out, new people drift away, eventually no one's left. - -You need more people. You need them to actually become part of what you're building. This is how. - Staged responsibility means not giving new people important roles immediately. Map which tasks need deep organizational knowledge and which just need someone willing. Coalition negotiations? That needs context. Social media? Less so. Note-taking? Anyone can do it. Month one: observe and take simple tasks. Show up, help with setup, take notes. Month two: join working groups, contribute to discussions, take on contained tasks. Month three onward: more autonomy as understanding deepens. @@ -51,3 +47,7 @@ Document processes, but recognize documentation misses most of what matters. Mee Every few months, talk through key moments: actions that worked, conflicts resolved, important decisions. Make sure newer members hear it. The informal spaces matter too. Pre-meeting chat, post-action talk, group messages. This is where people learn what actually gets valued. Split into smaller working groups with real autonomy. Five to ten people, focused on specific work. They coordinate through assemblies but operate independently. A new person joining a six-person group can be effectively integrated. A new person joining a forty-person meeting just gets lost. + +These practices make change manageable. They create structures so integration doesn't depend on heroes working themselves to death. The alternative is slow collapse: your best people burn out, new people drift away, eventually no one's left. + +You need more people. You need them to actually become part of what you're building. This is how. diff --git a/content/blog/knowledge-management-and-institutional-amnesia.md b/content/blog/knowledge-management-and-institutional-amnesia.md index 3ae1894..11c1f3f 100644 --- a/content/blog/knowledge-management-and-institutional-amnesia.md +++ b/content/blog/knowledge-management-and-institutional-amnesia.md @@ -50,8 +50,6 @@ The point isn't specific tools, it's the principle: use encrypted ephemeral chan Stop treating institutional memory as a luxury you'll get to when things calm down. Things won't calm down. The crisis is permanent under capitalism. Either you build systems that preserve knowledge despite constant turbulence, or you accept endless cycles of reinvention that exhaust everyone involved. -Documentation isn't about bureaucracy. It's about refusing to let hard-won knowledge disappear when it could help the next person trying to do the work. It's about building organizations that can outlast any individual member. It's about sustainability in the ruins. - The critical distinction: these repositories contain procedures, not personal data. Document the how of your work without including identifying information. How to verify requests, how to coordinate pickups, how to handle disputes. The process, not the people. Build redundancy into your system. Multiple members should have access to documentation repositories. Critical information should exist in at least two forms. If the wiki goes down or someone loses the password, you need backup. Consider quarterly reviews where coordinators check that documentation remains current and accessible. @@ -61,3 +59,5 @@ Not everything needs the same security level. Public-facing resources like volun Case-specific details stay in Signal. Personal information stays in Signal. Real-time sensitive coordination stays in Signal. General procedures, lessons learned, organizational structures can move to documentation. The line is whether the information could identify or harm specific people. If yes, it stays ephemeral. If no, it gets preserved. The open source model offers useful parallels here. Successful projects separate community discussion, which happens in ephemeral channels, from documentation, which lives in wikis and readme files. They have contribution guidelines, architecture decisions, and troubleshooting guides that persist. The knowledge exists independently of any individual contributor. When someone leaves, their specific conversations may disappear, but their contributions to understanding how the system works remain. + +Documentation isn't about bureaucracy. It's about refusing to let hard-won knowledge disappear when it could help the next person trying to do the work. It's about building organizations that can outlast any individual member. It's about sustainability in the ruins. diff --git a/tests/unit/learnGuideCopy.test.ts b/tests/unit/learnGuideCopy.test.ts new file mode 100644 index 0000000..0cf3143 --- /dev/null +++ b/tests/unit/learnGuideCopy.test.ts @@ -0,0 +1,109 @@ +import { readFileSync } from "node:fs"; +import path from "node:path"; +import { describe, expect, it } from "vitest"; + +const BLOG_DIR = path.join(process.cwd(), "content/blog"); + +function readGuide(slug: string): string { + return readFileSync(path.join(BLOG_DIR, `${slug}.md`), "utf8"); +} + +function bodyAfterFrontmatter(markdown: string): string { + return markdown.replace(/^---[\s\S]*?---\n*/, "").trim(); +} + +function lastParagraph(markdown: string): string { + const body = bodyAfterFrontmatter(markdown); + const paragraphs = body.split(/\n\n+/).map((paragraph) => paragraph.trim()); + return paragraphs[paragraphs.length - 1] ?? ""; +} + +describe("Learn guide copy", () => { + it("splits the two broken Avoiding Burnout sentences", () => { + const body = bodyAfterFrontmatter( + readGuide("avoiding-burnout-sustainability-in-the-ruins"), + ); + + expect(body).toContain( + `Not "take a break when you need it." No one ever needs it`, + ); + expect(body).not.toContain( + `Not "take a break when you need it" no one ever needs it`, + ); + expect(body).toContain( + "running the communication channels. All of it rotates", + ); + expect(body).not.toContain( + "running the communication channels all of it rotates", + ); + }); + + it("ends How Chaos Concentrates Control on its closing line and keeps Rotate them after the named roles", () => { + const body = bodyAfterFrontmatter(readGuide("how-chaos-concentrates-control")); + const roles = + "Name the roles explicitly. Note-taker, treasurer, communications coordinator, whatever you need."; + const rotateThem = "Rotate them. Six months, a year, whatever makes sense."; + const closing = + "Build structures. Make them visible. Change them when they don't work. That's not selling out, that's how you build something that lasts."; + + expect(body.indexOf(roles)).toBeGreaterThan(-1); + expect(body.indexOf(rotateThem)).toBeGreaterThan(body.indexOf(roles)); + expect(body.indexOf(closing)).toBeGreaterThan(body.indexOf(rotateThem)); + expect(lastParagraph(body)).toBe(closing); + expect(body.indexOf("Name who can bring proposals")).toBeLessThan( + body.indexOf(closing), + ); + expect(body.indexOf("Make information accessible")).toBeLessThan( + body.indexOf(closing), + ); + }); + + it("opens Digital Mediation on the setup and ends on its closing line", () => { + const body = bodyAfterFrontmatter( + readGuide("digital-mediation-and-the-death-of-nuance"), + ); + const setup = "Your organizing group lives in a Discord server."; + const thesis = "This isn't neutral."; + const closing = + "The anti-social network isn't about rejecting technology. It's about refusing to let corporate platforms mediate all human connection and political organizing. It's about building tools that serve us rather than extract from us. It's about remembering that the most important networks are the ones between actual people, in actual space, building actual power together."; + + expect(body.startsWith(setup)).toBe(true); + expect(body.indexOf(thesis)).toBeGreaterThan(body.indexOf(setup)); + expect(lastParagraph(body)).toBe(closing); + }); + + it("ends Knowledge Management on its closing line after the five restored paragraphs", () => { + const body = bodyAfterFrontmatter( + readGuide("knowledge-management-and-institutional-amnesia"), + ); + const firstRestored = + "The critical distinction: these repositories contain procedures, not personal data."; + const lastRestored = + "The open source model offers useful parallels here."; + const closing = + "Documentation isn't about bureaucracy. It's about refusing to let hard-won knowledge disappear when it could help the next person trying to do the work. It's about building organizations that can outlast any individual member. It's about sustainability in the ruins."; + + expect(body.indexOf(firstRestored)).toBeGreaterThan(-1); + expect(body.indexOf(lastRestored)).toBeGreaterThan(body.indexOf(firstRestored)); + expect(body.indexOf(closing)).toBeGreaterThan(body.indexOf(lastRestored)); + expect(lastParagraph(body)).toBe(closing); + }); + + it("moves the Integrating New Members wrap-up after the three sections that followed it", () => { + const body = bodyAfterFrontmatter( + readGuide("integrating-new-members-without-dilution"), + ); + const staged = "Staged responsibility means not giving new people important roles immediately."; + const redundant = "Making knowledge redundant matters because if one person holds crucial knowledge"; + const split = "Split into smaller working groups with real autonomy."; + const wrapUp = "These practices make change manageable."; + const closing = + "You need more people. You need them to actually become part of what you're building. This is how."; + + expect(body.indexOf(staged)).toBeGreaterThan(-1); + expect(body.indexOf(redundant)).toBeGreaterThan(body.indexOf(staged)); + expect(body.indexOf(split)).toBeGreaterThan(body.indexOf(redundant)); + expect(body.indexOf(wrapUp)).toBeGreaterThan(body.indexOf(split)); + expect(lastParagraph(body)).toBe(closing); + }); +});