Community Guidelines Examples & Free Template

This is an independent guide. Not affiliated with or endorsed by Reddit, Discord, GitHub, or Mozilla.

You wrote your community guidelines once, pinned them, and never looked at them again. Then a member posted something ugly, three people quit, and you realized your "rules" were a wall of text nobody had read. Sound familiar?

Good community guidelines examples aren't legal documents. They're the shortest possible answer to one question every member is silently asking: what happens here, and what happens if I break the vibe? Most sets of rules fail for the same reason. They read like a contract, so nobody reads them, so the culture drifts, so the loudest person wins. The fix isn't more rules. It's clearer, shorter, better-enforced ones.

This guide gives you 10 real, annotated examples worth copying, a free copy-paste template, the 5 building blocks every set of community rules needs, and the part almost nobody covers: how to actually enforce them. You'll also get a school-and-student version, a plain answer to how many rules a community should have, and the difference between guidelines, rules, and regulations that trips up half the people who write these.

Here's what you'll get, in order: a plain-English definition, the annotated examples, the building blocks, the template you can steal today, and a section on giving your rules teeth. Skim to the part you need. Steal freely.

What are community guidelines? (with real examples)

Community guidelines are the social contract of your space. They answer three things fast: what this community is for, how members treat each other, and what happens when someone crosses a line. That's it. Everything else is detail.

People confuse three words, so let's split them:

• Guidelines set the tone and values. "Be kind. Assume good intent." They're aspirational.
• Community rules are the hard lines. "No hate speech. No spam. No sharing other members' private info." They're enforceable.
• Standards are the bar your moderators hold. They're the consistency that makes rules mean something.

You need all three, but you write them as one document. Reddit's content policy is a rulebook. Discord's "be respectful" line is a guideline. A ban for doxxing is a standard being enforced. When people ask for good community guidelines examples, what they really want is a set that blends all three without reading like terms of service.

People also mix up "community rules" and "community rules and regulations." For an online community, the difference is small but useful. Rules are the behaviors you set and enforce yourself, like no spam and no personal attacks. Regulations are the outside constraints you have to honor no matter what, like a platform's terms of service, age limits, or local law. Your guidelines wrap both: the house rules you chose, plus a short line pointing to the platform terms everyone already agreed to.

One test settles most arguments about length: could a new member read your guidelines in 60 seconds and know what would get them removed? If not, they're too long. The best sets we'll look at fit on one screen, and they earn that space by cutting anything a reasonable person already assumes.

10 community guidelines examples worth copying (annotated)

The fastest way to write good rules is to study communities that already got it right. Below are 10 community rules examples from real platforms, each with the clause, why it works, and how to adapt it for your own space. Steal the structure, not the wording.

1. Reddit: "Remember the human"

Reddit's first rule of conduct is a single sentence: remember the human on the other side of the screen. It works because it reframes every interaction before you list a single prohibition. You're not arguing with a username, you're talking to a person. That reframing does quiet work. A member about to fire off an insult reads it and hesitates, which is the whole point. Reddit also runs a dual system: sitewide rules plus per-subreddit rules set by volunteer moderators, which lets huge communities self-govern. A cooking subreddit and a coding subreddit share the same floor but write their own house rules on top. Read the full Reddit content policy for the sitewide layer. Adapt it: open your guidelines with one human-centered line, then let sub-groups add their own house rules.

2. Discord: two-tier server rules in plain language

Well-run Discord servers keep rules short and split them into two tiers: platform-wide terms everyone agreed to, and 5-10 house rules the server owner sets. The best ones use plain language a 12-year-old could follow: "No spam. No DM advertising. English in main channels." No legalese. If you run a chat community, our guide on how to set up a Discord server walks through the structure, and this one on keeping a Discord community safe covers the moderation side. Adapt it: cap your house rules at 10 lines. If you need 30, your community is too broad.

3. GitHub: a code of conduct with an appeals path

GitHub's community guidelines lean on a values-based code of conduct, and the detail that makes it work is the appeals path. Members who are moderated can respond. That single mechanism turns "the mods are tyrants" into "there's a process." People accept a decision they disagree with far more easily when they got a chance to state their case first. An appeals line also protects you, because it catches the times a moderator actually got it wrong before the story spreads. See GitHub's community guidelines for the full version. Adapt it: add one line telling members how to appeal a removal or ban. It costs you nothing and defuses half your future drama.

4. Mozilla: values first, reporting pathway second

Mozilla's Community Participation Guidelines open with what the project stands for, then give a concrete reporting pathway: who to contact, what happens next. Read the Mozilla Community Participation Guidelines to see how they pair values with a real process. Values without a report button are decoration. Adapt it: every set of guidelines needs a named way to report a problem. An email, a form, a "message a mod" button.

5. Duolingo: kindness as a learning-community rule

Learning communities live or die on psychological safety. Duolingo's forums built rules around one idea: nobody gets mocked for a wrong answer. When the rule protects the beginner, beginners keep posting, and an active beginner base is the whole game. Picture a new learner named Priya posting a shaky first sentence in a language forum. If the first reply corrects her kindly, she posts again tomorrow. If the first reply mocks her, she never posts again, and every silent lurker learns the same lesson. One rule decides which forum you're running. Adapt it: if your community teaches anything, write a rule that explicitly protects people from feeling stupid.

6. Women in Tech SEO: "there's no stupid question"

Professional communities often struggle with gatekeeping. The clause that fixes it is simple: no question is too basic. It signals that senior members don't get to sneer at juniors. That one line changes who feels welcome to post. Adapt it: name the specific bad behavior you want to prevent (gatekeeping, humble-bragging, cold-selling) rather than a vague "be professional."

7. Peloton: give members the tools to self-moderate

Peloton's member community pairs written rules with mute, block, and report tools members control themselves. Rules tell people what's not allowed; self-moderation tools let members act before a moderator arrives. Adapt it: don't make every problem a mod ticket. Give members a block button and tell them, in the guidelines, that using it is fine.

8. Dribbble: rules built for a visual, credit-sensitive community

Dribbble is a designer community, so its rules zero in on the thing that hurts designers: plagiarism and uncredited work. Generic "be nice" rules would miss it entirely. Adapt it: write at least one rule that only makes sense for your specific community. A recipe forum bans reposting without credit; a trading community bans pump-and-dump calls.

9. Stack Overflow: cite your sources, no misinformation

Stack Overflow's guidelines push a norm most communities skip: back up claims. Answers that cite sources rank; unsourced hot takes get flagged. In any community where accuracy matters, "show your work" is a rule, not a suggestion. Adapt it: if bad information can hurt your members, add a sourcing rule and give mods permission to remove confident nonsense.

10. Discourse: a "Be Cool" TL;DR at the top

Discourse forums often open with a friendly two-word summary, "Be Cool," before the detailed civility guidelines below. The TL;DR gets read; the fine print gets referenced. Putting the human version first and the detailed version second respects that nobody reads walls of text. Adapt it: write a one-line summary of your entire rulebook and put it at the very top. If you can't summarize your rules in a sentence, they're too complicated.

Notice the pattern across all 10: short, specific, human, and paired with a way to enforce them. That's the whole recipe.

Free community guidelines template (copy and paste)

Here's a full community guidelines template you can copy, paste, and fill in today. Replace the brackets, cut anything that doesn't fit, and put the one-line summary at the very top. This is the community rules examples format that works across chat servers, forums, and live spaces.

[COMMUNITY NAME] Community Guidelines

TL;DR: Be kind, stay on topic, and don't be a jerk.

Why we're here
[One sentence: what this community is for and who it's for.]

What we expect from you
- Treat every member like a real person.
- [Expected behavior 2, e.g. "Give feedback that helps, not feedback that hurts."]
- [Expected behavior 3, specific to your community.]
- Assume good intent before you assume the worst.

What's not allowed
- No harassment, hate speech, or personal attacks.
- No spam, self-promotion, or unsolicited DMs.
- No sharing anyone's private information (doxxing).
- [Prohibited behavior specific to your community.]

What happens if you break the rules
- First time: a friendly warning and the post is removed.
- Second time: a temporary mute or timeout.
- Third time: removal from the community.
Serious violations (threats, doxxing, illegal content) skip straight to removal.

How to report a problem
[Report button / form link / "message any moderator" / email address.]
We review every report and follow up within [timeframe].

How to appeal
If you think a moderator got it wrong, [reply to the notice / email us here].

Copy that, spend 20 minutes making it yours, and you'll have a stronger set of rules than most communities ten times your size.

10 rules for a community: a starter set you can adapt

If you want a ready starter set, here are 10 rules for a community that cover the behaviors most spaces need. Treat this as a menu, not a mandate. Pick the ones that fit, cut the rest, and reword them in your own voice so they sound like your community and not a policy PDF.

1. Treat every member like a real person, even when you disagree.
2. Stay on topic in the main channels; take side chatter to the right room.
3. No harassment, hate speech, or personal attacks. Ever.
4. No spam, cold self-promotion, or unsolicited DMs.
5. Don't share anyone's private information without their consent.
6. Credit people's work; don't repost or claim it as your own.
7. Give feedback that helps someone improve, not feedback that just stings.
8. Report problems instead of fighting them in the thread.
9. Follow the platform's own terms; our rules sit on top of them, not around them.
10. When a moderator makes a call, take it up in DMs or the appeals line, not in public.

Notice this list still passes the 60-second test. Ten short lines is near the ceiling. If you find yourself wanting rules 11 through 20, that's usually a sign your community should split into focused sub-groups, each with a shorter house list of its own.

Community guidelines examples for schools and students

Community guidelines examples for schools and students follow the same building blocks, but the wording and the consequences change. Younger members read shorter, take things more literally, and respond to rules they can actually recite. A five-line list beats a five-paragraph policy every time, because a rule a student can repeat from memory is a rule they can follow in the moment.

Lead with privacy. In a classroom group or student club, the biggest risk isn't spam, it's one student sharing another student's photo, full name, or home details. Write a plain line for it: "Don't share anyone's private stuff, and don't take screenshots of each other." Then name bullying directly instead of hiding it behind "be respectful." Kids know exactly what name-calling and leaving someone out looks like, so call those out by name.

Swap the consequence tiers for age-appropriate steps: a first reminder, then a talk with a teacher, then a parent contact. Skip the corporate word "ban" and use language a student understands, like "you'll take a break from the group." A short version for a student community might read: be kind, protect each other's privacy, no bullying, ask before you post about someone, and tell an adult if something feels wrong. That's the whole thing, and every student can remember it.

Give your guidelines teeth: enforcement that actually works

A rule you can't enforce is a suggestion. This is the part most guides skip, and it's the part that decides whether your community rules mean anything. Writing the rules is step one. Wiring them to a control is what makes members believe you.

The trick is to map each common rule to a concrete mechanic, not a vibe. "Be respectful" enforced by "we'll keep an eye on it" is theater. "No hate speech" enforced by a ban-by-email button is a rule with consequences. In a live or spatial community, where people are talking and moving in real time, enforcement has to be immediate: mute the mic, revoke build access, remove the person from the space. You can't ask a heckler to please stop while forty people wait for a moderator to wake up.

This is where live communities differ from forums. In a comment thread, you have minutes to react. In a room where people talk over each other and edit the shared space, you have seconds. The rules you can back with a one-click control are the rules that hold. The ones you can only back with good intentions fall apart the first time someone tests them.

Here's how the rules in your template map to actual controls in a real-time community platform like flat.social.

The lesson: before you publish your rules, decide which control backs each one. A rule with a mechanic behind it survives contact with a bad actor. A rule with only good intentions behind it does not.

How to roll out and enforce your guidelines consistently

Publishing the rules is the easy part. Enforcing them the same way every time is what earns trust. Members watch how you handle the first violation, and they calibrate their own behavior to it.

Start at the door. Put the one-line summary where every new member sees it: a welcome message, a pinned post, or a splash screen when they enter the space. Don't bury the full version three clicks deep. Then remind people as the community grows, because the culture that felt obvious at 20 members needs re-stating at 200. New members don't inherit the norms you set on day one; they copy whatever behavior they see when they arrive.

Train whoever moderates. Give them the consequence tiers as a script so two mods handle the same offense the same way. Inconsistency is the fastest way to lose people. Picture a common failure: one moderator bans a regular for a joke that another mod had waved through a dozen times. Members notice, and trust drains fast, not because of the joke, but because the rules clearly mean different things depending on who is online. The rules were fine. The enforcement wasn't.

Here's the flip side. A networking host named Marcus ran a weekly virtual event where one guest kept talking over the speakers. Because Marcus had already published his tiers and wired a mute control to his moderator role, he warned the guest once, muted them the second time, and removed them the third, all in front of the room. Nobody complained, because everyone had read the same rules and watched them apply evenly. Consistent enforcement didn't make him the villain. It made him the reason people came back.

Review the whole thing quarterly. Communities change, new problems appear, and a rule that made sense in month one can be dead weight by month six. Fifteen minutes every three months keeps your guidelines alive instead of fossilized.

Community guidelines examples: your next steps

You don't need a legal team to write great community guidelines. You need a clear mission, a short list of hard lines, and the nerve to enforce them the same way every time. The best community guidelines examples we looked at all share those traits: they're short, human, specific, and backed by a real control.

Here's what to do this week:

• Steal the template above and fill it in. Twenty minutes gets you a working draft.
• Write your one-line TL;DR and put it where every new member lands.
• Define your first, second, and third-offense tiers before you need them, not during a crisis.
• Pick the enforcement control behind each rule so no rule is just a wish.
• Put a report button and an appeals line in front of members, so problems reach you and moderation feels fair.

Do those five things and you'll have community rules that hold up when a real person tests them, which they will.

Reddit, Discord, GitHub, and Mozilla are trademarks of their respective owners. This site is not affiliated with, endorsed by, or sponsored by any of them. Platform names are used descriptively to illustrate real community guidelines examples.

Hey! While you're here, check out flat.social

You just wrote the rules. flat.social is where a real-time community actually lives, and where those rules get enforced with real controls: role-based permissions, ban-by-email, closed spaces, and domain allowlists. If your community meets live, it's worth a look. It also pairs well with running an online community platform, building virtual community spaces, or learning how to run a virtual community center.