diff --git a/.github/workflows/community-check.yml b/.github/workflows/community-check.yml
new file mode 100644
index 0000000..dde7ef0
--- /dev/null
+++ b/.github/workflows/community-check.yml
@@ -0,0 +1,53 @@
+name: Community Entry Check
+
+# Lightweight, non-executing gate for community showcase entries.
+# It does NOT run contributor code. It validates entry structure, scans for
+# committed secrets, and confirms hosted entries use Opik. Secrets-free, so it
+# runs on forks. The showcase index (community/README.md) is regenerated
+# separately on merge by community-index.yml — contributors run nothing.
+#
+# Community entries are intentionally exempt from the verified-bucket workflows
+# (compliance / pr-test / test-notebooks / scheduled), which are path-scoped to
+# examples|integrations|scripts|use-cases|guides and never match community/**.
+
+on:
+  pull_request:
+    paths:
+      - "community/**"
+
+permissions:
+  contents: read
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: astral-sh/setup-uv@v7
+        with:
+          version: "latest"
+          enable-cache: true
+          python-version: "3.12"
+
+      - name: Install tooling
+        run: |
+          cd community/_ci
+          uv sync
+
+      - name: Unit-test the check tooling
+        run: |
+          cd community/_ci
+          uv run pytest -q
+
+      - name: Lint the check tooling
+        run: |
+          cd community/_ci
+          uv run ruff check .
+          uv run ruff format --check .
+
+      - name: Validate all community entries
+        run: |
+          cd community/_ci
+          uv run python check_entry.py
diff --git a/.github/workflows/community-index.yml b/.github/workflows/community-index.yml
new file mode 100644
index 0000000..bb46f7c
--- /dev/null
+++ b/.github/workflows/community-index.yml
@@ -0,0 +1,56 @@
+name: Community Index
+
+# Regenerates the community showcase index (community/README.md) from every
+# entry's meta.yaml after changes land on main. This keeps the index current
+# with zero manual action — contributors never run the generator, and no one
+# hand-edits community/README.md.
+#
+# It runs build_index.py (which only parses YAML — it never executes contributor
+# code) and commits the result back to main only if it changed. The path filter
+# excludes community/README.md so this workflow's own index commit does not
+# re-trigger it.
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - "community/**"
+      - "!community/README.md"
+
+permissions:
+  contents: write
+
+concurrency:
+  group: community-index
+  cancel-in-progress: false
+
+jobs:
+  regenerate:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v7
+
+      - uses: astral-sh/setup-uv@v7
+        with:
+          version: "latest"
+          enable-cache: true
+          python-version: "3.12"
+
+      - name: Regenerate showcase index
+        run: |
+          cd community/_ci
+          uv sync
+          uv run python build_index.py
+
+      - name: Commit index if it changed
+        run: |
+          if [[ -n "$(git status --porcelain community/README.md)" ]]; then
+            git config user.name "github-actions[bot]"
+            git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+            git add community/README.md
+            git commit -m "chore: regenerate community showcase index"
+            git push
+          else
+            echo "Showcase index already up to date."
+          fi
diff --git a/.gitignore b/.gitignore
index d260914..69140a8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -26,3 +26,6 @@ poetry.lock
 
 # Local planning/process artifacts (superpowers brainstorm specs & implementation plans) — kept local, never committed
 docs/superpowers/
+
+# Community proof screenshots are intentionally committed (overrides the global *.png rule above)
+!community/**/*.png
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index b04c193..70d1f83 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,6 +2,12 @@
 
 Thank you for contributing. This repo is a reference library for Opik users — the goal is examples that are easy to find, easy to run, and easy to adapt.
 
+> **Contributing community showcase work instead of a verified example?** The
+> `community/` folder has its own, lighter-weight contract — see
+> [community/CONTRIBUTING.md](community/CONTRIBUTING.md). The rules below apply
+> to the verified `integrations/`, `guides/`, `use-cases/`, and `scripts/`
+> buckets.
+
 ## Recommended workflow
 
 This is the loop we follow for non-trivial contributions. The slash-commands in brackets come from Claude Code plugins (see below) and are optional but recommended. **Start every contribution with `/brainstorming`** to agree on scope, and **finish by reviewing your own PR with `/review`** before asking a human.
diff --git a/README.md b/README.md
index ce144e3..15dd3e7 100644
--- a/README.md
+++ b/README.md
@@ -56,6 +56,16 @@ Standalone scripts for automating and managing Opik resources.
 | [scripts/usage_stats](scripts/usage_stats/) | Fetch trace and span counts per project and visualise trends |
 | [scripts/leaderboard_dashboard](scripts/leaderboard_dashboard/) | Create an Experiment Leaderboard dashboard via the REST API |
 
+## Community
+
+Work built with Opik by the open-source community. Unlike the buckets above,
+these entries are **community-contributed and not maintainer-verified** — they
+showcase what people are building. Standout real-world projects get hosted
+in-repo and spotlighted in our community forums.
+
+Browse them in [community/](community/), or add your own via
+[community/CONTRIBUTING.md](community/CONTRIBUTING.md).
+
 ## Contributing
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) for the contribution guide and example template.
diff --git a/community/CONTRIBUTING.md b/community/CONTRIBUTING.md
new file mode 100644
index 0000000..e593fcb
--- /dev/null
+++ b/community/CONTRIBUTING.md
@@ -0,0 +1,48 @@
+# Contributing to the Community folder
+
+This folder showcases work the open-source community has built with Opik. It is
+deliberately **lighter-weight than the main repo contract** — the strict
+`run.sh` / dry-run / litellm / CI rules in the root
+[CONTRIBUTING.md](../CONTRIBUTING.md) do **not** apply here. Community entries
+are not executed by CI; a maintainer reviews (and, for hosted entries, runs)
+them by hand.
+
+There is one thing we always require: **proof you actually logged with Opik** —
+either Comet cloud or the self-hosted open-source platform.
+
+## Two kinds of entry
+
+- **Listed** (default): a folder describing your work with links out to your own
+  repo/blog/notebook. No code needs to live here.
+- **Hosted**: standout, real-world projects we promote into this repo with their
+  code included. You submit as *listed*; a maintainer sets `hosted: true` and
+  moves your code in when promoting. We also spotlight promoted work in our
+  community forums.
+
+## Add your entry
+
+1. Copy `templates/entry-template/` to `community/<your-handle>_<project>/`
+   (lowercase, underscores, e.g. `jane_support_agent`).
+2. Fill in `meta.yaml` (all fields) and `README.md` (all four sections).
+3. Replace `opik-proof.png` with a real screenshot of your Opik traces or
+   dashboard.
+4. If you want it considered for hosting, include your code in the folder — it
+   must genuinely use Opik (`import opik`, `@opik.track`, ...).
+5. Open a PR. A maintainer reviews it.
+
+That's it — you don't need to run anything. The showcase index
+(`community/README.md`) is regenerated automatically when your entry merges, so
+your project appears there without any manual step on your part.
+
+## What the automated check enforces
+
+`community/_ci/check_entry.py` runs on your PR (a hard gate). It does **not**
+run your code. It checks:
+
+- `meta.yaml` has all required fields, at least one link, and a valid
+  `opik_platform`.
+- `README.md` has all four sections filled in (no leftover `TODO`).
+- `opik-proof.png` exists and is referenced from your README.
+- No `.env` file or hardcoded API keys are committed.
+- Hosted entries contain code that uses Opik.
+- The folder name is `lowercase_with_underscores`.
diff --git a/community/README.md b/community/README.md
new file mode 100644
index 0000000..8aa9b74
--- /dev/null
+++ b/community/README.md
@@ -0,0 +1,12 @@
+# Community
+
+<!-- This file is generated by community/_ci/build_index.py. Do not edit by hand. -->
+
+Work built with Opik by the open-source community. These entries are
+**community-contributed and not maintainer-verified** — they are showcased here
+to help people discover what others are building. Standout, real-world projects
+are hosted in-repo (see the Hosted column).
+
+To add your own, see [CONTRIBUTING.md](CONTRIBUTING.md).
+
+_No community contributions yet — be the first!_
diff --git a/community/_ci/build_index.py b/community/_ci/build_index.py
new file mode 100644
index 0000000..6ebbc4b
--- /dev/null
+++ b/community/_ci/build_index.py
@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from check_entry import COMMUNITY_DIR, discover_entries
+from entry_rules import load_meta
+
+_HEADER = """\
+# Community
+
+<!-- This file is generated by community/_ci/build_index.py. Do not edit by hand. -->
+
+Work built with Opik by the open-source community. These entries are
+**community-contributed and not maintainer-verified** — they are showcased here
+to help people discover what others are building. Standout, real-world projects
+are hosted in-repo (see the Hosted column).
+
+To add your own, see [CONTRIBUTING.md](CONTRIBUTING.md).
+"""
+
+_TABLE_HEADER = (
+    "| Project | Author | Description | Platform | Links | Hosted | Tags |\n"
+    "|---|---|---|---|---|---|---|"
+)
+
+
+def load_entries(community_dir: Path) -> list[dict]:
+    entries: list[dict] = []
+    for entry in discover_entries(community_dir):
+        data, errors = load_meta(entry)
+        if errors:
+            continue
+        entries.append(
+            {
+                "slug": entry.name,
+                "title": str(data.get("title", entry.name)),
+                "description": str(data.get("description", "")),
+                "author": str(data.get("author", "")),
+                "links": data.get("links") or {},
+                "opik_platform": str(data.get("opik_platform", "")),
+                "tags": data.get("tags") or [],
+                "hosted": bool(data.get("hosted", False)),
+            }
+        )
+    entries.sort(key=lambda e: e["title"].casefold())
+    return entries
+
+
+def _escape_pipes(value: str) -> str:
+    return value.replace("|", "\\|")
+
+
+def _links_cell(links: dict) -> str:
+    parts = [
+        f"[{_escape_pipes(str(label))}]({_escape_pipes(str(url))})"
+        for label, url in links.items()
+        if str(url).startswith("http")
+    ]
+    return "<br>".join(parts) if parts else ""
+
+
+def _row(entry: dict) -> str:
+    project = f"[{_escape_pipes(entry['title'])}]({entry['slug']}/)"
+    author = (
+        f"[@{_escape_pipes(entry['author'])}](https://github.com/{_escape_pipes(entry['author'])})"
+        if entry["author"]
+        else ""
+    )
+    tags = _escape_pipes(", ".join(str(t) for t in entry["tags"]))
+    hosted = "hosted" if entry["hosted"] else ""
+    cells = [
+        project,
+        author,
+        _escape_pipes(entry["description"]),
+        _escape_pipes(entry["opik_platform"]),
+        _links_cell(entry["links"]),
+        hosted,
+        tags,
+    ]
+    return "| " + " | ".join(cells) + " |"
+
+
+def render_index(entries: list[dict]) -> str:
+    lines = [_HEADER]
+    if not entries:
+        lines.append("_No community contributions yet — be the first!_\n")
+    else:
+        lines.append(_TABLE_HEADER)
+        lines.extend(_row(e) for e in entries)
+        lines.append("")
+    return "\n".join(lines).rstrip("\n") + "\n"
+
+
+def write_index(community_dir: Path) -> None:
+    (community_dir / "README.md").write_text(
+        render_index(load_entries(community_dir)), encoding="utf-8"
+    )
+
+
+def check_index(community_dir: Path) -> bool:
+    readme = community_dir / "README.md"
+    current = readme.read_text(encoding="utf-8") if readme.is_file() else ""
+    return current == render_index(load_entries(community_dir))
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = sys.argv[1:] if argv is None else argv
+    if "--check" in args:
+        if check_index(COMMUNITY_DIR):
+            print("community/README.md is up to date.")
+            return 0
+        print("community/README.md is stale. Run: python build_index.py")
+        return 1
+    write_index(COMMUNITY_DIR)
+    print("Wrote community/README.md")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/community/_ci/check_entry.py b/community/_ci/check_entry.py
new file mode 100644
index 0000000..042960c
--- /dev/null
+++ b/community/_ci/check_entry.py
@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from entry_rules import (
+    validate_code_uses_opik,
+    validate_folder_name,
+    validate_meta,
+    validate_no_secrets,
+    validate_proof,
+    validate_readme,
+)
+
+COMMUNITY_DIR = Path(__file__).resolve().parent.parent
+RESERVED_DIRS = {"_ci", "templates"}
+
+
+def discover_entries(community_dir: Path) -> list[Path]:
+    return [
+        child
+        for child in sorted(community_dir.iterdir())
+        if child.is_dir() and child.name not in RESERVED_DIRS
+    ]
+
+
+def check_entry(entry: Path) -> list[str]:
+    errors: list[str] = []
+    errors += validate_folder_name(entry)
+    errors += validate_meta(entry)
+    errors += validate_readme(entry)
+    errors += validate_proof(entry)
+    errors += validate_no_secrets(entry)
+    errors += validate_code_uses_opik(entry)
+    return errors
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = sys.argv[1:] if argv is None else argv
+    if args:
+        entries = [Path(a) for a in args]
+    else:
+        entries = discover_entries(COMMUNITY_DIR)
+
+    if not entries:
+        print("No community entries to check.")
+        return 0
+
+    all_errors: list[str] = []
+    for entry in entries:
+        entry_errors = check_entry(entry)
+        if entry_errors:
+            all_errors.extend(entry_errors)
+        else:
+            print(f"OK  {entry.name}")
+
+    if all_errors:
+        print("\nCommunity entry check failed:")
+        for error in all_errors:
+            print(f"  - {error}")
+        return 1
+
+    print("\nAll community entries passed.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/community/_ci/entry_rules.py b/community/_ci/entry_rules.py
new file mode 100644
index 0000000..4930390
--- /dev/null
+++ b/community/_ci/entry_rules.py
@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import yaml
+
+REQUIRED_SECTIONS = [
+    "What I built",
+    "Problem it solves",
+    "What I learned",
+    "How I used Opik",
+]
+PLACEHOLDER_TOKENS = ["TODO", "FILL ME IN", "<!-- replace"]
+VALID_PLATFORMS = {"cloud", "self-hosted"}
+
+_REQUIRED_STRING_FIELDS = ["title", "description", "author"]
+
+
+def load_meta(entry: Path) -> tuple[dict, list[str]]:
+    meta_path = entry / "meta.yaml"
+    if not meta_path.is_file():
+        return {}, [f"{entry.name}: missing meta.yaml"]
+    try:
+        data = yaml.safe_load(meta_path.read_text(encoding="utf-8"))
+    except yaml.YAMLError as exc:
+        return {}, [f"{entry.name}: meta.yaml is not valid YAML ({exc})"]
+    if not isinstance(data, dict):
+        return {}, [f"{entry.name}: meta.yaml must be a mapping"]
+    return data, []
+
+
+def _nonempty_str(value: object) -> bool:
+    return isinstance(value, str) and value.strip() != ""
+
+
+def validate_meta(entry: Path) -> list[str]:
+    data, errors = load_meta(entry)
+    if errors:
+        return errors
+
+    name = entry.name
+
+    for field in _REQUIRED_STRING_FIELDS:
+        if not _nonempty_str(data.get(field)):
+            errors.append(
+                f"{name}: meta.yaml field '{field}' is required and must be a non-empty string"
+            )
+
+    links = data.get("links")
+    if not isinstance(links, dict) or not any(
+        _nonempty_str(v) and str(v).startswith("http") for v in links.values()
+    ):
+        errors.append(f"{name}: meta.yaml 'links' must contain at least one http(s) link")
+
+    platform = data.get("opik_platform")
+    if platform not in VALID_PLATFORMS:
+        errors.append(f"{name}: meta.yaml 'opik_platform' must be one of {sorted(VALID_PLATFORMS)}")
+
+    if not isinstance(data.get("tags"), list):
+        errors.append(f"{name}: meta.yaml 'tags' must be a list (may be empty)")
+
+    if not isinstance(data.get("hosted"), bool):
+        errors.append(f"{name}: meta.yaml 'hosted' must be a boolean (true/false)")
+
+    return errors
+
+
+def _section_bodies(markdown: str) -> dict[str, str]:
+    bodies: dict[str, str] = {}
+    current: str | None = None
+    buffer: list[str] = []
+    for line in markdown.splitlines():
+        heading = re.match(r"^##\s+(.*?)\s*$", line)
+        if heading:
+            if current is not None:
+                bodies[current] = "\n".join(buffer).strip()
+            current = heading.group(1).strip()
+            buffer = []
+        elif current is not None:
+            buffer.append(line)
+    if current is not None:
+        bodies[current] = "\n".join(buffer).strip()
+    return bodies
+
+
+def _looks_like_placeholder(body: str) -> bool:
+    lowered = body.lower()
+    return body == "" or any(token.lower() in lowered for token in PLACEHOLDER_TOKENS)
+
+
+def validate_readme(entry: Path) -> list[str]:
+    readme_path = entry / "README.md"
+    if not readme_path.is_file():
+        return [f"{entry.name}: missing README.md"]
+
+    bodies = _section_bodies(readme_path.read_text(encoding="utf-8"))
+    errors: list[str] = []
+    for section in REQUIRED_SECTIONS:
+        if section not in bodies:
+            errors.append(f"{entry.name}: README.md missing required section '## {section}'")
+        elif _looks_like_placeholder(bodies[section]):
+            errors.append(
+                f"{entry.name}: README.md section '## {section}' is empty or still a placeholder"
+            )
+    return errors
+
+
+def validate_proof(entry: Path) -> list[str]:
+    errors: list[str] = []
+    if not (entry / "opik-proof.png").is_file():
+        errors.append(f"{entry.name}: missing opik-proof.png (screenshot of your Opik traces)")
+        return errors
+    readme_path = entry / "README.md"
+    text = readme_path.read_text(encoding="utf-8") if readme_path.is_file() else ""
+    if "opik-proof.png" not in text:
+        errors.append(f"{entry.name}: opik-proof.png must be referenced from README.md")
+    return errors
+
+
+_FOLDER_NAME_RE = re.compile(r"^[a-z0-9]+(?:_[a-z0-9]+)+$")
+_SECRET_PATTERNS = [
+    re.compile(r"sk-ant-[A-Za-z0-9_-]{20,}"),
+    re.compile(r"sk-(?:proj|svcacct)-[A-Za-z0-9_-]{20,}"),
+    re.compile(r"sk-[A-Za-z0-9]{20,}"),
+    re.compile(r"""OPIK_API_KEY\s*[=:]\s*["'][^"']+["']"""),
+]
+_TEXT_SUFFIXES = {".py", ".ipynb", ".md", ".txt", ".yaml", ".yml", ".toml", ".sh", ".json"}
+_OPIK_MARKERS = ["import opik", "from opik", "@opik.track", "opik.Opik(", "OPIK_"]
+
+
+def validate_folder_name(entry: Path) -> list[str]:
+    if not _FOLDER_NAME_RE.match(entry.name):
+        return [
+            f"{entry.name}: folder name must be lowercase '<author>_<project>' "
+            f"(letters/digits/underscores, at least one underscore)"
+        ]
+    return []
+
+
+def _iter_text_files(entry: Path):
+    for path in entry.rglob("*"):
+        if path.is_file() and path.suffix.lower() in _TEXT_SUFFIXES:
+            yield path
+
+
+def validate_no_secrets(entry: Path) -> list[str]:
+    errors: list[str] = []
+    for path in entry.rglob(".env"):
+        if path.is_file() and path.name == ".env":
+            errors.append(
+                f"{entry.name}: committed .env file at {path.relative_to(entry)} — remove it"
+            )
+
+    for path in _iter_text_files(entry):
+        try:
+            text = path.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            continue
+        for pattern in _SECRET_PATTERNS:
+            if pattern.search(text):
+                errors.append(
+                    f"{entry.name}: possible hardcoded secret/key in {path.relative_to(entry)} "
+                    f"— load credentials from environment variables instead"
+                )
+                break
+    return errors
+
+
+def validate_code_uses_opik(entry: Path) -> list[str]:
+    data, load_errors = load_meta(entry)
+    if load_errors:
+        return []  # meta problems are reported by validate_meta; don't double-report
+    if data.get("hosted") is not True:
+        return []
+
+    for path in entry.rglob("*"):
+        if path.is_file() and path.suffix.lower() in {".py", ".ipynb"}:
+            text = path.read_text(encoding="utf-8", errors="ignore")
+            if any(marker in text for marker in _OPIK_MARKERS):
+                return []
+    return [
+        f"{entry.name}: hosted entry has no code that uses Opik "
+        f"(expected one of: import opik, @opik.track, opik.Opik(, OPIK_)"
+    ]
diff --git a/community/_ci/pyproject.toml b/community/_ci/pyproject.toml
new file mode 100644
index 0000000..9d32ab8
--- /dev/null
+++ b/community/_ci/pyproject.toml
@@ -0,0 +1,20 @@
+[project]
+name = "opik-community-scripts"
+version = "0.1.0"
+description = "Validation and index tooling for the Opik community folder"
+requires-python = ">=3.12"
+dependencies = [
+    "pyyaml>=6.0",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+    "ruff>=0.6",
+]
+
+[tool.ruff]
+line-length = 100
+
+[tool.pytest.ini_options]
+pythonpath = ["."]
diff --git a/community/_ci/tests/conftest.py b/community/_ci/tests/conftest.py
new file mode 100644
index 0000000..26071ca
--- /dev/null
+++ b/community/_ci/tests/conftest.py
@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import base64
+from pathlib import Path
+
+import yaml
+
+# Smallest valid PNG (1x1 transparent), base64-encoded.
+_PNG_1X1 = base64.b64decode(
+    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=="
+)
+
+_DEFAULT_META = {
+    "title": "Real-time support agent with Opik tracing",
+    "description": "A support agent traced end-to-end with an LLM-judge eval loop.",
+    "author": "jane-doe",
+    "links": {"repo": "https://github.com/jane-doe/support-agent"},
+    "opik_platform": "cloud",
+    "tags": ["agent", "rag"],
+    "hosted": False,
+}
+
+_DEFAULT_README = """\
+# Real-time support agent with Opik tracing
+
+## What I built
+A support agent that answers billing questions over a RAG index.
+
+## Problem it solves
+Support reps spent hours triaging repeat billing questions.
+
+## What I learned
+Opik's span metadata made it obvious which retrieval step was dropping context.
+
+## How I used Opik
+Traced each agent turn with `@opik.track`, logged retrieval context in span
+metadata, and ran an LLM-judge eval over 40 real tickets. See the screenshot:
+
+![Opik traces](opik-proof.png)
+"""
+
+
+def write_entry(
+    base: Path,
+    slug: str = "jane_agent",
+    *,
+    meta: dict | None = None,
+    readme: str | None = None,
+    include_png: bool = True,
+    code: dict[str, str] | None = None,
+) -> Path:
+    entry = base / slug
+    entry.mkdir(parents=True, exist_ok=True)
+
+    merged = dict(_DEFAULT_META)
+    if meta:
+        for key, value in meta.items():
+            if value is None:
+                merged.pop(key, None)
+            else:
+                merged[key] = value
+    (entry / "meta.yaml").write_text(yaml.safe_dump(merged, sort_keys=False))
+
+    (entry / "README.md").write_text(_DEFAULT_README if readme is None else readme)
+
+    if include_png:
+        (entry / "opik-proof.png").write_bytes(_PNG_1X1)
+
+    for name, contents in (code or {}).items():
+        target = entry / name
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(contents)
+
+    return entry
diff --git a/community/_ci/tests/test_build_index.py b/community/_ci/tests/test_build_index.py
new file mode 100644
index 0000000..d78b166
--- /dev/null
+++ b/community/_ci/tests/test_build_index.py
@@ -0,0 +1,76 @@
+import re
+from pathlib import Path
+
+from conftest import write_entry
+
+from build_index import check_index, load_entries, render_index, write_index
+
+
+def _unescaped_pipe_count(row: str) -> int:
+    return len(re.findall(r"(?<!\\)\|", row))
+
+
+def test_load_entries_reads_meta(tmp_path: Path):
+    write_entry(tmp_path, slug="jane_agent")
+    entries = load_entries(tmp_path)
+    assert len(entries) == 1
+    assert entries[0]["slug"] == "jane_agent"
+    assert entries[0]["title"]
+
+
+def test_render_index_lists_entry_and_links_to_folder(tmp_path: Path):
+    write_entry(tmp_path, slug="jane_agent")
+    out = render_index(load_entries(tmp_path))
+    assert "jane_agent" in out
+    assert "community-contributed" in out.lower()
+
+
+def test_render_index_hosted_badge_is_text_not_emoji(tmp_path: Path):
+    write_entry(tmp_path, slug="jane_agent", meta={"hosted": True})
+    out = render_index(load_entries(tmp_path))
+    assert "hosted" in out.lower()
+
+
+def test_render_index_empty_has_no_entries_note(tmp_path: Path):
+    out = render_index([])
+    assert "no community contributions yet" in out.lower()
+
+
+def test_write_then_check_roundtrips(tmp_path: Path):
+    write_entry(tmp_path, slug="jane_agent")
+    write_index(tmp_path)
+    assert (tmp_path / "README.md").is_file()
+    assert check_index(tmp_path) is True
+
+
+def test_check_index_detects_stale(tmp_path: Path):
+    write_entry(tmp_path, slug="jane_agent")
+    (tmp_path / "README.md").write_text("# stale\n")
+    assert check_index(tmp_path) is False
+
+
+def test_pipe_in_description_is_escaped_in_table_row(tmp_path: Path):
+    write_entry(
+        tmp_path,
+        slug="jane_agent",
+        meta={"description": "Handles A | B and C | D cases"},
+    )
+    out = render_index(load_entries(tmp_path))
+    table_line = next(line for line in out.splitlines() if line.startswith("| [Real"))
+    assert "A \\| B and C \\| D" in table_line
+    # 7 columns means 8 unescaped pipe delimiters (leading + trailing +
+    # 6 separators); escaped pipes must not be miscounted as separators.
+    assert _unescaped_pipe_count(table_line) == 8
+
+
+def test_pipe_in_author_is_escaped_and_column_count_is_preserved(tmp_path: Path):
+    write_entry(
+        tmp_path,
+        slug="jane_agent",
+        meta={"author": "jane|doe"},
+    )
+    out = render_index(load_entries(tmp_path))
+    table_line = next(line for line in out.splitlines() if line.startswith("| [Real"))
+    assert "jane\\|doe" in table_line
+    assert "https://github.com/jane\\|doe" in table_line
+    assert _unescaped_pipe_count(table_line) == 8
diff --git a/community/_ci/tests/test_check_entry.py b/community/_ci/tests/test_check_entry.py
new file mode 100644
index 0000000..ba9bcab
--- /dev/null
+++ b/community/_ci/tests/test_check_entry.py
@@ -0,0 +1,61 @@
+from pathlib import Path
+
+from conftest import write_entry
+
+from check_entry import check_entry, discover_entries, main
+
+
+def test_valid_entry_passes(tmp_path: Path):
+    entry = write_entry(tmp_path)
+    assert check_entry(entry) == []
+
+
+def test_check_entry_aggregates_multiple_failures(tmp_path: Path):
+    entry = write_entry(tmp_path, slug="BadName", meta={"title": None}, include_png=False)
+    errors = check_entry(entry)
+    assert any("title" in e for e in errors)
+    assert any("opik-proof.png" in e for e in errors)
+    assert any("folder name" in e.lower() for e in errors)
+
+
+def test_discover_skips_reserved_dirs(tmp_path: Path):
+    write_entry(tmp_path, slug="jane_agent")
+    (tmp_path / "_ci").mkdir()
+    (tmp_path / "_ci" / "meta.yaml").write_text("title: x\n")
+    (tmp_path / "templates").mkdir()
+    (tmp_path / "templates" / "meta.yaml").write_text("title: x\n")
+    found = {p.name for p in discover_entries(tmp_path)}
+    assert found == {"jane_agent"}
+
+
+def test_discover_includes_dir_without_meta_yaml(tmp_path: Path):
+    entry = write_entry(tmp_path, slug="no_meta_here")
+    (entry / "meta.yaml").unlink()
+    found = {p.name for p in discover_entries(tmp_path)}
+    assert "no_meta_here" in found
+
+
+def test_check_entry_flags_missing_meta_yaml(tmp_path: Path):
+    entry = write_entry(tmp_path, slug="no_meta_here")
+    (entry / "meta.yaml").unlink()
+    errors = check_entry(entry)
+    assert any("missing meta.yaml" in e for e in errors)
+
+
+def test_main_no_args_returns_one_when_entry_missing_meta_yaml(tmp_path: Path, monkeypatch):
+    entry = write_entry(tmp_path, slug="no_meta_here")
+    (entry / "meta.yaml").unlink()
+    import check_entry as check_entry_module
+
+    monkeypatch.setattr(check_entry_module, "COMMUNITY_DIR", tmp_path)
+    assert main([]) == 1
+
+
+def test_main_returns_zero_for_valid_entry(tmp_path: Path):
+    entry = write_entry(tmp_path)
+    assert main([str(entry)]) == 0
+
+
+def test_main_returns_one_for_invalid_entry(tmp_path: Path):
+    entry = write_entry(tmp_path, include_png=False)
+    assert main([str(entry)]) == 1
diff --git a/community/_ci/tests/test_entry_rules.py b/community/_ci/tests/test_entry_rules.py
new file mode 100644
index 0000000..a276aa1
--- /dev/null
+++ b/community/_ci/tests/test_entry_rules.py
@@ -0,0 +1,214 @@
+from pathlib import Path
+
+from conftest import write_entry
+
+from entry_rules import (
+    validate_code_uses_opik,
+    validate_folder_name,
+    validate_meta,
+    validate_no_secrets,
+    validate_proof,
+    validate_readme,
+)
+
+
+def test_valid_meta_has_no_errors(tmp_path: Path):
+    entry = write_entry(tmp_path)
+    assert validate_meta(entry) == []
+
+
+def test_missing_meta_file_is_error(tmp_path: Path):
+    entry = tmp_path / "no_meta"
+    entry.mkdir()
+    errors = validate_meta(entry)
+    assert any("meta.yaml" in e for e in errors)
+
+
+def test_missing_required_field_is_error(tmp_path: Path):
+    entry = write_entry(tmp_path, meta={"title": None})
+    assert any("title" in e for e in validate_meta(entry))
+
+
+def test_empty_required_field_is_error(tmp_path: Path):
+    entry = write_entry(tmp_path, meta={"description": "  "})
+    assert any("description" in e for e in validate_meta(entry))
+
+
+def test_links_must_have_one_http_value(tmp_path: Path):
+    entry = write_entry(tmp_path, meta={"links": {"repo": "not-a-url"}})
+    assert any("link" in e.lower() for e in validate_meta(entry))
+
+
+def test_invalid_platform_is_error(tmp_path: Path):
+    entry = write_entry(tmp_path, meta={"opik_platform": "on-prem"})
+    assert any("opik_platform" in e for e in validate_meta(entry))
+
+
+def test_hosted_must_be_bool(tmp_path: Path):
+    entry = write_entry(tmp_path, meta={"hosted": "yes"})
+    assert any("hosted" in e for e in validate_meta(entry))
+
+
+def test_tags_must_be_list(tmp_path: Path):
+    entry = write_entry(tmp_path, meta={"tags": "agent"})
+    assert any("tags" in e for e in validate_meta(entry))
+
+
+def test_malformed_yaml_is_reported(tmp_path: Path):
+    entry = tmp_path / "bad_yaml"
+    entry.mkdir()
+    (entry / "meta.yaml").write_text("title: [unclosed\n")
+    errors = validate_meta(entry)
+    assert any("meta.yaml" in e for e in errors)
+
+
+def test_valid_readme_has_no_errors(tmp_path: Path):
+    entry = write_entry(tmp_path)
+    assert validate_readme(entry) == []
+
+
+def test_missing_readme_is_error(tmp_path: Path):
+    entry = tmp_path / "no_readme"
+    entry.mkdir()
+    assert any("README.md" in e for e in validate_readme(entry))
+
+
+def test_missing_section_is_error(tmp_path: Path):
+    readme = "# Title\n\n## What I built\nStuff.\n\n## Problem it solves\nX.\n"
+    entry = write_entry(tmp_path, readme=readme)
+    errors = validate_readme(entry)
+    assert any("What I learned" in e for e in errors)
+    assert any("How I used Opik" in e for e in errors)
+
+
+def test_placeholder_body_is_error(tmp_path: Path):
+    readme = (
+        "# T\n\n## What I built\nTODO\n\n## Problem it solves\nX.\n\n"
+        "## What I learned\nY.\n\n## How I used Opik\nZ.\n"
+    )
+    entry = write_entry(tmp_path, readme=readme)
+    assert any("What I built" in e for e in validate_readme(entry))
+
+
+def test_empty_section_body_is_error(tmp_path: Path):
+    readme = (
+        "# T\n\n## What I built\n\n## Problem it solves\nX.\n\n"
+        "## What I learned\nY.\n\n## How I used Opik\nZ.\n"
+    )
+    entry = write_entry(tmp_path, readme=readme)
+    assert any("What I built" in e for e in validate_readme(entry))
+
+
+def test_valid_proof_has_no_errors(tmp_path: Path):
+    entry = write_entry(tmp_path)
+    assert validate_proof(entry) == []
+
+
+def test_missing_png_is_error(tmp_path: Path):
+    entry = write_entry(tmp_path, include_png=False)
+    assert any("opik-proof.png" in e for e in validate_proof(entry))
+
+
+def test_png_not_referenced_is_error(tmp_path: Path):
+    readme = (
+        "# T\n\n## What I built\nA.\n\n## Problem it solves\nB.\n\n"
+        "## What I learned\nC.\n\n## How I used Opik\nNo image here.\n"
+    )
+    entry = write_entry(tmp_path, readme=readme)
+    assert any("referenced" in e.lower() for e in validate_proof(entry))
+
+
+def test_valid_folder_name_ok(tmp_path: Path):
+    entry = write_entry(tmp_path, slug="jane_agent")
+    assert validate_folder_name(entry) == []
+
+
+def test_bad_folder_name_is_error(tmp_path: Path):
+    entry = write_entry(tmp_path, slug="JaneAgent")
+    assert any("folder name" in e.lower() for e in validate_folder_name(entry))
+
+
+def test_folder_name_without_underscore_is_error(tmp_path: Path):
+    entry = write_entry(tmp_path, slug="janeagent")
+    assert any("folder name" in e.lower() for e in validate_folder_name(entry))
+
+
+def test_clean_entry_has_no_secret_findings(tmp_path: Path):
+    entry = write_entry(tmp_path)
+    assert validate_no_secrets(entry) == []
+
+
+def test_dotenv_file_is_flagged(tmp_path: Path):
+    entry = write_entry(tmp_path)
+    (entry / ".env").write_text("OPIK_API_KEY=abc\n")
+    assert any(".env" in e for e in validate_no_secrets(entry))
+
+
+def test_dotenv_example_is_not_flagged(tmp_path: Path):
+    entry = write_entry(tmp_path)
+    (entry / ".env.example").write_text("OPIK_API_KEY=\n")
+    assert validate_no_secrets(entry) == []
+
+
+def test_hardcoded_key_is_flagged(tmp_path: Path):
+    entry = write_entry(
+        tmp_path,
+        code={"app.py": 'client = OpenAI(api_key="sk-abcdefghijklmnopqrstuvwxyz123456")\n'},
+    )
+    assert any("hardcoded" in e.lower() or "key" in e.lower() for e in validate_no_secrets(entry))
+
+
+def test_sk_proj_key_is_flagged(tmp_path: Path):
+    entry = write_entry(
+        tmp_path,
+        code={"app.py": 'client = OpenAI(api_key="sk-proj-abcdefghijklmnopqrstuvwxyz012345")\n'},
+    )
+    assert any("hardcoded" in e.lower() or "key" in e.lower() for e in validate_no_secrets(entry))
+
+
+def test_hosted_without_opik_usage_is_error(tmp_path: Path):
+    entry = write_entry(
+        tmp_path,
+        meta={"hosted": True},
+        code={"app.py": "def run():\n    return 1\n"},
+    )
+    assert any("opik" in e.lower() for e in validate_code_uses_opik(entry))
+
+
+def test_hosted_with_opik_usage_ok(tmp_path: Path):
+    entry = write_entry(
+        tmp_path,
+        meta={"hosted": True},
+        code={"app.py": "import opik\n\n@opik.track\ndef run():\n    return 1\n"},
+    )
+    assert validate_code_uses_opik(entry) == []
+
+
+def test_listed_entry_skips_code_check(tmp_path: Path):
+    entry = write_entry(tmp_path, meta={"hosted": False})
+    assert validate_code_uses_opik(entry) == []
+
+
+def test_non_ascii_readme_and_meta_are_read_as_utf8(tmp_path: Path):
+    readme = (
+        "# 支持代理 — Real-time support agent’s Opik tracing\n\n"
+        "## What I built\n"
+        "一个通过 RAG 索引回答账单问题的支持代理 — built with love.\n\n"
+        "## Problem it solves\n"
+        "客服代表花费数小时处理重复的账单问题。\n\n"
+        "## What I learned\n"
+        "Opik’s span metadata made it obvious which retrieval step was dropping context.\n\n"
+        "## How I used Opik\n"
+        "Traced each agent turn with `@opik.track` — see the screenshot:\n\n"
+        "![Opik traces](opik-proof.png)\n"
+    )
+    entry = write_entry(
+        tmp_path,
+        readme=readme,
+        meta={
+            "title": "支持代理 — Real-time support agent",
+            "description": "客服支持代理 — traced end-to-end with an LLM-judge eval loop’s help.",
+        },
+    )
+    assert validate_readme(entry) == []
+    assert validate_meta(entry) == []
diff --git a/community/_ci/tests/test_smoke.py b/community/_ci/tests/test_smoke.py
new file mode 100644
index 0000000..529c5d7
--- /dev/null
+++ b/community/_ci/tests/test_smoke.py
@@ -0,0 +1,18 @@
+from pathlib import Path
+
+from conftest import write_entry
+
+
+def test_write_entry_creates_valid_layout(tmp_path: Path):
+    entry = write_entry(tmp_path)
+    assert (entry / "meta.yaml").is_file()
+    assert (entry / "README.md").is_file()
+    assert (entry / "opik-proof.png").is_file()
+
+
+def test_write_entry_can_delete_a_meta_key(tmp_path: Path):
+    import yaml
+
+    entry = write_entry(tmp_path, meta={"title": None})
+    data = yaml.safe_load((entry / "meta.yaml").read_text())
+    assert "title" not in data
diff --git a/community/templates/entry-template/README.md b/community/templates/entry-template/README.md
new file mode 100644
index 0000000..2ce0eb4
--- /dev/null
+++ b/community/templates/entry-template/README.md
@@ -0,0 +1,16 @@
+# Your project title
+
+## What I built
+TODO: one short paragraph on what the project is.
+
+## Problem it solves
+TODO: the real-world problem this addresses.
+
+## What I learned
+TODO: what using Opik taught you — what surprised you, what you changed.
+
+## How I used Opik
+TODO: which spans/traces you logged, what you evaluated, any scores. Then show
+your screenshot below.
+
+![Opik traces](opik-proof.png)
diff --git a/community/templates/entry-template/meta.yaml b/community/templates/entry-template/meta.yaml
new file mode 100644
index 0000000..205d839
--- /dev/null
+++ b/community/templates/entry-template/meta.yaml
@@ -0,0 +1,10 @@
+# Copy this whole folder to community/<your-github-handle>_<project>/ and fill it in.
+title: Short project title
+description: One line describing what you built (shows in the showcase index).
+author: your-github-handle
+links:
+  repo: https://github.com/your-handle/your-project   # at least one http(s) link required
+  # blog: https://...                                 # optional extra links
+opik_platform: cloud        # cloud | self-hosted
+tags: [agent, rag]          # free-form; may be empty []
+hosted: false               # leave false; a maintainer sets this true when promoting
diff --git a/community/templates/entry-template/opik-proof.png b/community/templates/entry-template/opik-proof.png
new file mode 100644
index 0000000..097ca54
Binary files /dev/null and b/community/templates/entry-template/opik-proof.png differ