```md # We Are the Ruby Community ## A 30-Minute Keynote ----- ## OPENING (2-3 minutes) *[Walk to center stage. Pause. Make eye contact.]* I want to start with something I don’t usually say on a podcast. I’m scared. Not of bugs. Not of deadlines. Not of learning new frameworks. I’m scared that in five years, nobody will need me. That my years of experience building and connecting people mean nothing. That the thing that made me feel like I belonged—this community—might not exist the same way. And I’m betting that fear is sitting in your chest right now too. We’re watching AI take over communication. We’re hearing that “70% of coding jobs might be automated.” We’re seeing tools that can do in seconds what took us hours. And beneath all of that is a deeper fear: *If AI can replace what I do, what makes me part of something real?* So here’s what I want to tell you in the next thirty minutes: **That fear is pointing at something true, but you’re looking at it backwards.** The Ruby community doesn’t exist because of what we build alone. It exists because of what we build *together*. And that’s the one thing no AI can replace. ----- ## THE REAL CONTEXT (4-5 minutes) Let me be honest about what’s happening. AI is going to change jobs. It’s going to disrupt how we work. Some positions will disappear. That’s real, and it deserves real attention. But here’s what I’ve learned from thousands of hours talking to developers on Remote Ruby: **The people who thrive in that future aren’t the ones frantically trying to stay technically ahead of the AI. They’re the ones who are deeply connected to a community.** Why? Because communities do something AI fundamentally cannot: - They *trust* you in a way algorithms can’t replicate - They *remember* you and your contributions beyond your last output - They *need* your specific perspective, not a generic solution - They pull you up when you’re struggling, instead of just optimizing around you When your code gets stale, your community holds you up. When you’re burnt out, your community reminds you why you started. When you’re afraid, your community shows you that everyone else is too. **And right now, especially right now, the Ruby community needs you in ways it has never needed you before.** Not because Ruby is dying. But because human connection is becoming the rarest resource in programming. Think about it: If AI is going to democratize code, if anyone can generate working functions in seconds, what becomes valuable? The person who asks the right questions. The mentor who knows your situation. The voice on a podcast who has the conversation nobody else is having. The person who makes a junior developer feel like they belong. That’s not automation-proof. That’s *recession-proof*. That’s *crisis-proof*. But here’s the problem: **Most of you don’t think you’re doing that.** Most of you sitting here feel like *observers* of the Ruby community, not participants. You’re watching other people have the podcast, give the talks, maintain the gems, lead the teams. And you think: *That’s community. That’s not me.* That’s the second fear I want to address today. ----- ## REFRAMING COMMUNITY (5-6 minutes) Community isn’t a place you arrive at. It’s not a conference you attend, or a GitHub organization you join, or a skill level you reach. Community is a **verb. It’s something you do.** The Ruby community isn’t a building you walk into. It’s the *pattern of what happens when Ruby developers interact with each other*. So here’s what I need you to hear: **You’re already in the Ruby community. Right now. You were the moment you sat down here.** But many of you don’t *feel* like you’re in it, because you’re waiting for permission. You’re waiting to be: - Good enough - Published enough - Famous enough - Experienced enough - Experienced enough And here’s the invisible barrier nobody talks about: **All those “enough” benchmarks were set by people who were never sure they were enough either.** I’ve talked to Rails core contributors who thought they weren’t qualified to file a bug. I’ve talked to brilliant engineers who were terrified to comment on a GitHub issue. I’ve talked to people with incredible ideas who never shared them because they were waiting for their confidence to appear. The confidence doesn’t appear. You just move forward anyway. And the moment you do—comment on an issue, answer a question on Stack Overflow, share something you learned, tell someone they’re doing great—you become part of community. Not someday. Today. Here’s the thing about the Ruby community that I’ve noticed: **It’s made up entirely of people who didn’t feel like they belonged at first.** The maintainers? Imposter syndrome. The conference speakers? Terrified beforehand. The mentors? Still learning. The people writing the most helpful docs? Usually people who just figured something out yesterday and thought “I have to explain this so others don’t suffer like I did.” The Ruby community isn’t an exclusive club. It’s a group of scared people doing the work anyway, and being kind to each other while we do it. That’s the structure you’re already part of. ----- ## THE BARRIER: IMPOSTER SYNDROME (2-3 minutes) Let me name the thing that’s actually stopping you. Imposter syndrome isn’t a skill problem. It’s not about knowing enough Ruby. It’s about one core belief: *I don’t belong here.* And that belief will kill your participation faster than any technical gap. Here’s the trap: You wait until the imposter feeling goes away before you participate. But the imposter feeling doesn’t go away because of what you know. It goes away because of *evidence that you belong*. That evidence comes from participation. It’s a catch-22, except it’s not. Because here’s what I’ve learned from talking to hundreds of developers: **The barrier is thinner than you think.** It’s not that you’re not good enough. It’s that you don’t know the first step is that small. People think community contribution looks like: - Maintaining a major Ruby gem - Speaking at a major conference - Being recognized as an expert And it does. For some people. But that’s not where you start. ----- ## THE PRACTICAL PATH: MICRO TO MACRO (8-10 minutes) Here’s what community participation actually looks like, and I’m going to give you the progression so you can see where *you* fit right now: ### **LEVEL 0: MICRO-PARTICIPATION (The Social Layer)** You don’t need to write code to be part of the community. Start here: **Twitter/X, Mastodon, Bluesky:** - Retweet something helpful someone built - Reply “thank you” to a blog post that helped you - Share something you just learned: “Today I realized Array#each returns the original array, not the result. Mind blown.” - Ask a genuine question: “Can someone explain why this code throws an error?” That’s it. That’s community. When you retweet a Ruby thread, you’re saying “this matters.” When you reply to someone’s blog post thanking them, you’re giving them evidence that their work meant something. That’s *real* participation. I built my entire presence on Remote Ruby starting with: asking good questions. That was it. For months, that’s all I did. I didn’t know I was building community. I was just curious about other people’s journeys. **What micro-participation does:** It breaks the seal. It proves to yourself that you can show up. It connects you to the Ruby timeline. It makes you visible—not famous, just visible. **Time commitment:** 5 minutes a week. **Barrier to entry:** Almost none. You already have social media. ### **LEVEL 1: MICRO-DOCUMENTATION (The Learning Layer)** You have knowledge that someone needs right now. Maybe it’s: - A Stack Overflow answer about a specific error - A GitHub issue comment: “I had this problem too, here’s what worked” - A blog post (doesn’t have to be long): “How I Fixed My N+1 Query Problem” - A GitHub gist with a useful script or example - Commenting on someone else’s blog post with your experience This is where most developers stop themselves. They think: *My answer isn’t comprehensive enough. My blog post isn’t polished enough. I’m not qualified to answer.* But here’s the thing: You don’t need to answer comprehensively. You need to answer *for the person sitting where you were six months ago*. When I first helped someone on Stack Overflow, my answer was maybe 10 lines. Someone commented later: “This saved me hours.” That’s it. That’s community. **What micro-documentation does:** You become the person who bridges the gap between “struggling with this problem” and “understanding this problem.” You’ve just changed someone’s career trajectory. That’s massive. **Time commitment:** 1-2 hours a month. **Barrier to entry:** You already know how to solve *something*. ### **LEVEL 2: MENTORING (The Human Layer)** This is where the real magic starts. And here’s what I need you to understand: **You can mentor someone even if you’re not a senior engineer.** Mentoring doesn’t mean “be the expert.” It means “remember what it was like to not know, and help someone through that.” Forms of mentoring: - Pairing with a junior on a feature - Reviewing someone’s code in a PR with kindness and clarity - Having coffee/video chat with someone learning Ruby - Introducing two people who should know each other - Recommending someone for an opportunity - Being the person who says “You’ve got this” at the right moment Here’s what changed my career as a developer: One person took an hour to explain REST to me. They didn’t write a comprehensive guide. They just explained it to me, personally, like I mattered. I remembered that. And years later, I did the same for someone else. And they did it for someone else. That’s how community compounds. **What mentoring does:** You become irreplaceable. Not because you’re the smartest. Because you’re the person who *saw* someone and made them feel capable. **Time commitment:** 2-4 hours a month, flexible. **Barrier to entry:** You’ve solved a problem that someone else hasn’t yet. ### **LEVEL 3: OPEN SOURCE (The Structural Layer)** Now we’re at the layer most people think is “real” community contribution. But here’s the secret: It’s not actually harder than the previous layers. It’s just more visible. **Easy entry points:** - Fix a typo in the documentation - Add an example to a gem’s README - Test a new gem release and report if it works (or doesn’t) - File an issue when something breaks - Comment on someone else’s issue with “I have the same problem” - Update a Changelog with clarity This is *micro open source*. And it matters enormously. Documentation bugs are real bugs. Unclear examples block people. Confirmations that something is broken help maintainers prioritize. **What micro open source does:** You’re part of the infrastructure that keeps the Ruby ecosystem alive. Every typo you fix means someone doesn’t get confused. Every issue you confirm means a maintainer doesn’t have to investigate alone. **Time commitment:** 30 minutes a week, or a couple hours on one project. **Barrier to entry:** You found a problem. You reported it. ----- ### **LEVEL 4: LARGER OPEN SOURCE CONTRIBUTIONS (The Legacy Layer)** Adding features, maintaining gems, leading projects. This is the visible layer that most people think is “community.” But here’s what I need you to understand: **You don’t earn your way here by being silent at Levels 0-3.** You get here by showing up, consistently, at whatever level you’re at. And then one day, a maintainer says “Hey, would you like to help maintain this?” Or you have an idea and you build it. **What large contributions do:** They create the infrastructure that Level 0-3 lives inside. **Time commitment:** Varies wildly, but you choose it. **Barrier to entry:** You’ve shown up at a smaller level first. You’ve earned trust. ----- ### **LEVEL 5: SPEAKING, WRITING, PODCASTING (The Amplification Layer)** Blog posts, conference talks, podcasts, newsletters. This is what I do. And here’s how I got here: I started at Level 0. I was just asking good questions. Then I started documenting what I learned (Level 1). Then I started helping people understand (Level 2). Then I contributed to open source (Level 3). And one day I was having conversations with people that mattered, and I thought: *Maybe other people should hear this.* Remote Ruby started not as “let me be a podcaster.” It started as “let me have conversations with people I’m curious about and share them.” **What amplification does:** You’re the voice that tells people like you that they belong. You’re showing the junior developer that a successful person still struggles. You’re showing the senior dev that mentoring is the best use of their time. **Time commitment:** This is the one that *takes time*. But you build into it. **Barrier to entry:** You have something worth sharing. Probably something you’ve already shared at a smaller level. ----- ## THE PROGRESSION MATTERS (1-2 minutes) Notice something: **Each level is made possible by the previous one.** You don’t jump to open source contributions without knowing the community on social media. You don’t become a mentor without being mentored first. You don’t speak credibly without having written first. And here’s what kills most people’s community participation: **They look at Level 5 and think that’s community. So they don’t start at Level 0.** They see someone’s conference talk and think “I could never do that.” And they’re right. They couldn’t. Not yet. But they could retweet something today. The path is: Retweet → Comment → Document → Mentor → Contribute → Amplify And you don’t have to go all the way up. You can live at Level 2 and be an incredible part of the community. You can be Level 3 forever and make a huge difference. You can stay at Level 0 and still belong. **But you cannot stay nowhere.** ----- ## NAMING THE REAL BARRIER: NOT KNOWING WHERE TO START (2-3 minutes) Okay, so I’ve given you five levels. But that still doesn’t answer the question most of you are really asking: *Where do I start tomorrow?* Here’s my answer, and I want you to write this down or screenshot it: **For new developers:** 1. Follow 5-10 Ruby developers on the social media you use 2. This week, reply to one tweet/post with a genuine observation or thank you 3. That’s Level 0. You’re done. You’re part of the community. 4. Next week: find one Stack Overflow question you could answer, even partially. Post your answer. 5. Now you’re at Level 1. From here, opportunities will find you. Someone will see your answer and think “I want to talk to this person.” Someone will say “Hey, would you pair with me?” **For mid-level developers:** 1. Find one open source project you actually use and care about 2. This week, read their contribution guide 3. Next week, find one thing to improve (documentation, a test, a small bug) 4. Submit it. It might get rejected. Submit anyway. 5. Now you’re at Level 3. But also—and this is crucial—**look at the junior developer next to you. Tell them they belong here.** That’s Level 2. **For senior developers:** You’re being asked to do something specific. You’re being asked to *create the safety* that lets everyone else participate. Your job is: 1. Reply to comments. Be kind. Explain clearly. 2. Mentor someone. One person. Just one. Tell them they’re doing well. 3. Champion other voices. Retweet them. Recommend them. Say their name. 4. Remember what it felt like to be scared. **For everyone:** You don’t have to be good at this immediately. You don’t have to be perfect. You don’t have to have a plan. You just have to show up somewhere. Once. ----- ## ADDRESSING THE AI FEAR (2-3 minutes) Now let me come back to where we started. AI is coming for a lot of things. And it might take some jobs. That’s real. But it cannot take community. It cannot take the moment when someone says “I thought I was alone in this, and then I found you, and I realized I wasn’t.” It cannot take the feeling of being mentored. The experience of being lifted up. The knowledge that someone *chose* to invest in you. And it absolutely cannot take your ability to make someone else feel that way. In fact, I think the opposite is true: **As AI becomes more present, community becomes more precious.** When everything is automated, the person who slows down and pays attention to another person is rarer. Rarer means more valuable. More valuable means more protected. So if you’re afraid that there won’t be a place for you in the future: there will be. But you have to show up now. You have to help build it. You have to prove—to yourself first—that you belong. And the way you prove that is by showing someone else that they belong too. ----- ## THE CALL TO ACTION: The Most Important Part (2-3 minutes) *[Pause. Let this land.]* I’m going to ask you to do something when you leave this room. Not sometime this week. Not “when you have time.” **Today. In the next few hours.** Find someone you know in the Ruby community. Could be someone at this conference. Could be someone online. Could be someone who’s been kind to you, or someone you’ve seen struggling. And tell them: **You already belong to this community.** Not “you could belong if you contributed more.” Not “you’ll belong once you’re good enough.” *You already belong.* That’s it. That’s the message. And here’s why this matters: That message is going to hit them harder than you think. Because there’s someone in this room right now who has been waiting years for someone to tell them that. There’s someone who has been silently contributing, terrified that nobody noticed. There’s someone who thought they were never going to be “enough.” And you’re going to change that, in 30 seconds, by telling them the truth. **You don’t join the Ruby community. You help create it.** And it needs you. Not someday. Right now. The Ruby that survives AI, that thrives in this new world, is Ruby that is deeply, broadly, joyfully connected. And you’re the people who build that. Not the famous people. Not the core contributors only. *You.* The person reading a blog post and thinking “oh, now I get it”—that’s you building community. The person asking a good question on GitHub—that’s you building community. The person saying “you’re doing great” to someone scared—that’s you building community. The person noticing someone on the edges and pulling them in—that’s you building community. So here’s what I need you to know: You are not observers of the Ruby community. You are the Ruby community. And we’re so glad you’re here. ----- ## CLOSING (20-30 seconds) *[Let silence settle. Make eye contact with the audience.]* Thank you. [*Pause for applause*] And after this talk: go tell someone they belong. ----- **END** ----- ## NOTES FOR ANDREW: - **Tone:** Warm, intimate, vulnerable at the start. Build to empowering. End with clarity and purpose. - **Pacing:** The five levels section is the meaty middle. Don’t rush it. Let each level land. - **Delivery:** Especially land on “You don’t join the Ruby community. You help create it.” Say it twice if it feels right. - **The call to action is the whole point.** Not a tacked-on ending. It’s the reason for the talk. By asking people to tell someone they belong, you’re activating them as community-builders immediately. - **Vulnerability early** (your fear about AI) gives you permission to ask for vulnerability later (tell someone they belong). - **Personal stories:** You have thousands from Remote Ruby. Drop 2-3 throughout naturally. The Stack Overflow answer example, the REST explanation story, the Remote Ruby origin—these are strong. - **Pause often.** Let people land their own realizations. Don’t fill silence. ```