Official agent skill

Checking Member Access

by PostHog in PostHog/posthog-foss

Explains what a member or a role can do in a PostHog project, using the access control MCP tools.

OfficialMITAuto-check passedBackend & APIs

Install Checking Member Access

skills CLI
$ npx skills add PostHog/posthog-foss --skill checking-member-access -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install PostHog/posthog-foss checking-member-access --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/PostHog/posthog-foss.git skills-src && mkdir -p .claude/skills && cp -r skills-src/products/access_control/skills/checking-member-access .claude/skills/checking-member-access && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
checking-member-access
GitHub stars
721
Token cost
~3.2k tokens
SKILL.md length
1,476 words
Files
1
Skills in repo
213
Repo updated
First seen
Licence
MIT

At a glance

Explains what a member or a role can do in a PostHog project, using the access control MCP tools.

  • Works in 6 steps: Find the subject id. member_id is the… → Tool-level questions need one call. "Can… → Explain the level from inherited_access.… → …
  • The user asks what someone can see
  • SKILL.md covers When to use this skill, Plan availability, How access resolves and Available tools, plus 3 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Checking Member Access is an agent skill from PostHog/posthog-foss, published by the product's own GitHub organization. Explains what a member or a role can do in a PostHog project, using the access control MCP tools. Use when the user asks what someone can see or edit, who can edit dashboards or feature flags, why a member can or cannot open a dashboard, notebook or table, what a role grants, which properties are hidden from someone, or how the project's default access is set. Covers what each level means, how the stored rule, the enforced level and the inherited access relate, what the null values mean, which tool answers which…

Its SKILL.md is about 3.2k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Backend & APIs, covering Authorization and RBAC. It works with PostHog. The repository describes itself as: PostHog FOSS is a read-only mirror of PostHog, with all proprietary code removed. NOTE: This repo is synced automatically from the main PostHog repo. Please raise any issues and… The licence is MIT.

When your agent uses it

  • The user asks what someone can see
  • Who can edit dashboards
  • Why a member can
  • Cannot open a dashboard

Example prompts

  • “Use the checking-member-access skill to explain what a member or a role can do in a PostHog project, using the access control MCP tools”
  • “/checking-member-access”

Workflow steps

6 steps, taken from the first numbered list in SKILL.md.

  1. Find the subject id. member_id is the organization membership id: the id from
  2. Tool-level questions need one call. "Can this member view dashboards?" or "What access to feature
  3. Explain the level from inherited_access. See the table below. Only mention the stored
  4. Object questions need the object and its rules. "Can this member open dashboard 42?" cannot be
  5. Several rules on one object. When the member, a role and the default each set a level on the
  6. "Who can ..." questions are members-list without member_id, filtered on

What it can do on your machine

Read from SKILL.md and the folder at commit 2c48221. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • posthog.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Checking Member Access loads about 3.2k tokens when it runs. Until then it costs about 149 tokens; SKILL.md has 1,476 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~149
When it runs · the whole SKILL.md, loaded when a task matches
~3.2k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from PostHog/posthog-foss at commit 2c48221, republished under its MIT licence (© PostHog). 1,476 words, ~3,215 tokens.

Download SKILL.mdSave it as .claude/skills/checking-member-access/SKILL.md (or your agent's skills folder).
name
checking-member-access
description
Explains what a member or a role can do in a PostHog project, using the access control MCP tools. Use when the user asks what someone can see or edit, who can edit dashboards or feature flags, why a member can or cannot open a dashboard, notebook or table, what a role grants, which properties are hidden from someone, or how the project's default access is set. Covers what each level means, how the stored rule, the enforced level and the inherited access relate, what the null values mean, which tool answers which question, and when the answer needs the role tools too.

Checking member access

Use this skill to answer "what can this person do here?" from the access control tools. The tools return the enforced level and where it comes from. This skill is for reading them correctly.

When to use this skill

  • "What can this member do in this project?" / "Can this member edit feature flags?"
  • "Who can edit dashboards?" / "Who has no access to experiments?"
  • "Why can't this member open this dashboard?" / "Which tables is this role restricted from?"
  • "Which properties are hidden from the support role?"
  • "What does the analyst role grant?" / "What is the default access in this project?"

Not for changing rules. The read tools cannot write, and the settings page is where rules are edited.

Plan availability

  • Free and pay-as-you-go plans have no access control, and the access control tools are not offered to them. If the tools are missing from the catalog, say that the plan does not include access control and suggest upgrading to the Boost plan. Link the plan comparison: https://posthog.com/platform-packages.
  • Boost and Scale include the default levels and rules for single members on the project, on tools, on objects and on properties.
  • Roles exist on every plan, but role rules are an Enterprise feature: they can be set and are enforced only there, and the three role access tools are offered only there. If the tools are missing, say that role-based access control needs the Enterprise plan, with the same link. On other plans a member's roles never change the enforced level.
  • The tools do not say which plan the organization is on. A source_subject of role anywhere in a members-list result proves that role rules are enforced. Without that, ask the user whether the organization is on Enterprise before walking roles in step 4 of the workflow.

How access resolves

  • Scopes. The project itself, then each tool (dashboard, insight, feature_flag, notebook, experiment, warehouse_objects, and so on), then single objects inside a tool, then person and event properties. The tool names are the keys of resources in a members-list entry.
  • Project levels. member can view and edit the resources their other rules permit. admin can also edit project settings, manage the project's access rules, and delete the project.
  • Tool and object levels. none cannot view. viewer can view but not change. editor can view and change. manager can also manage the access rules of the tool or object. Order: none < viewer < editor < manager.
  • Property levels. none hides the property. read shows it. read_write also allows edits. Every property is read_write unless a rule exists.
  • Bounds. minimum and maximum per tool, on defaults-get, are the levels a rule can set. A tool with minimum viewer can never be set to none.
  • Subjects. A rule belongs to one member, one role, or everyone in the project (the default).
  • Organization admins and owners have full access to everything in every project. No rule applies to them. organization_level is a number: 1 member, 8 admin, 15 owner.
  • Creators have full access to the objects they created, and only those. A member with viewer on dashboards can still edit the dashboard they created, and cannot edit the others.
  • Two resolution modes. Organizations resolve rules either most-specific-first (member rule, then role rules, then default, and object rule before tool rule) or legacy (the highest of the member's own rule and role rules wins). The tools do not say which mode applies. The server already applied it. So trust effective_access_level and never recompute it from the stored rules. If the user asks why, explain from inherited_access, not from your own precedence.

Available tools

ToolReturns
posthog:access-control-members-listEvery member's enforced access to the project and to each tool. member_id narrows to a member.
posthog:access-control-roles-listThe same per role. role_id narrows to a role.
posthog:access-control-defaults-getThe project baseline, and which tools accept rules on single objects.
posthog:access-control-member-objects-listThe object rules set for a member: every object with a rule for that member.
posthog:access-control-member-properties-listThe property rules set for a member.
posthog:access-control-role-objects-listThe object rules set for a role.
posthog:access-control-role-properties-listThe property rules set for a role.
posthog:access-control-default-objects-listThe object rules that apply to everyone in the project.
posthog:access-control-default-properties-listThe property rules that apply to everyone in the project.
posthog:org-members-listMembership ids, names and organization levels. No project access details.
posthog:roles-list, posthog:role-members-listRole names by id, and who is in a role.

All access control tools take an optional project id and default to the active project.

Show full SKILL.md (740 more words)Show less

Workflow

  1. Find the subject id. member_id is the organization membership id: the id from org-members-list, or organization_membership_id from members-list. It is not the user id and not the user uuid. role_id is the id from roles-list.
  2. Tool-level questions need one call. "Can this member view dashboards?" or "What access to feature flags does this member have?" is members-list with member_id. effective_access_level for that tool is the complete answer. It already includes the member's roles, the project default and the bypasses.
  3. Explain the level from inherited_access. See the table below. Only mention the stored access_level when it differs from the enforced level.
  4. Object questions need the object and its rules. "Can this member open dashboard 42?" cannot be answered from the tool level alone. Check in this order, and stop at the first hit:
    1. organization_level is 8 or 15 on the member's entry: full access, no rule applies.
    2. The member created the object: full access, no rule applies. The rule tools do not say who created an object, so fetch it with its own get tool, for example dashboard-get or insight-get, and compare created_by.uuid with user.uuid on the member's entry.
    3. A rule on that object. The member tools return only the rules set for that member, so collect member-objects-list, role-objects-list for each id in the member's role_ids, and default-objects-list, and pick out the rows for this object. Tell the user how many roles you would walk and ask before doing it for a member in many roles.
    4. No rule on the object: the tool-level answer from step 2 applies.
  5. Several rules on one object. When the member, a role and the default each set a level on the same object, the server picks one by the organization's resolution mode, and no tool returns that pick for another member. Report every rule you found with its subject, say the enforced one depends on the mode, and do not guess. Property questions work like step 4 with the properties tools, minus the creator check, since properties have no creator.
  6. "Who can ..." questions are members-list without member_id, filtered on resources.<tool>.effective_access_level. The response is every member times every tool and has no pagination. For a large organization, ask which people the user cares about first, or answer per member.

Reading one entry

FieldMeaning
access_levelThe subject's own stored rule for this scope. null means no rule of its own.
effective_access_levelWhat is enforced. null means nothing resolves for this scope. It is not "no access".
inherited_accessThe level the subject falls back to without a rule of its own, and where it comes from. null when nothing supplies one.
inherited_access.sourceresource or parent_resource for a tool rule, object or parent_object for an object rule, system_default for the PostHog default. org_admin and creator are the bypasses described above. org_membership appears only when the object is the organization itself.
inherited_access.source_subjectmember, role or default: whose rule supplied it. null when a bypass or the PostHog default did.

How to phrase the answer:

  • source is org_admin: "This member is an organization admin and has full access to everything." The stored rules do not apply to them.
  • access_level is set and equals effective_access_level: "This member has an explicit rule: editor."
  • access_level is null and source_subject is role: "This member has editor access, based on a role." The role's name is not in the entry; roles-list has it if the user wants it.
  • access_level is null and source_subject is default: "This member has viewer access, based on the project default."
  • source is system_default: "No rule is set anywhere, so the PostHog default applies."
  • effective_access_level is null: "Nothing resolves for this tool here." Do not read it as no access.

Gotchas

  • An empty object or property list means no rules of that kind, not no access. The tool-level entry still applies.
  • A member missing from members-list is not proof of no access. A caller who is not an organization admin, in an organization where members cannot see each other, only sees members with project-scoped access.
  • can_edit on the members and roles lists describes the caller, not the subject: whether the person running the tool may change rules.
  • available_project_levels and available_resource_levels are the vocabulary, lowest first. Use them to compare levels instead of assuming an order.
  • object_rule_resources on defaults-get lists the tools that accept rules on single objects. A tool not in that list has no object rules to look for.

© PostHog, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in products/access_control/skills/checking-member-access of PostHog/posthog-foss.

Open the folder on GitHubat commit 2c48221

Compare with similar skills

Checking Member Access next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Checking Member Access compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Checking Member Access this skillPostHog/posthog-foss721—~3.2kAutomated safety check: PassMIT
Configuring Horizoncoollabsio/coolify63k4 repos~898Automated safety check: PassMIT
K8s Security PoliciesCybereason-Public/owLSM28011 repos~2kAutomated safety check: PassGPL-2.0
Payloadpayloadcms/payload45k5 repos~6.2kAutomated safety check: PassMIT
Convex Setup Authspokvulcan/poker-planning1148 repos~1.8kAutomated safety check: PassMIT
UI Auditbagofwords1/bagofwords458—~2.9kAutomated safety check: PassCustom licence

Similar skills

  • Configuring Horizon

    coollabsio/coolify

    A skill your agent uses whenever the user mentions Horizon by name in a Laravel context.

    63k GitHub starsUsed in 4 repos~898 tokens
    Backend & APIsAuto-check passed
  • K8s Security Policies

    Cybereason-Public/owLSM

    Comprehensive guide for implementing NetworkPolicy, PodSecurityPolicy, RBAC, and Pod Security Standards in Kubernetes.

    280 GitHub starsUsed in 11 repos~2k tokens
    Backend & APIsAuto-check passed
  • Payload

    payloadcms/payload

    A skill your agent uses when working with Payload projects (payload.config.ts, collections, fields, hooks, access control, Payload API).

    45k GitHub starsUsed in 5 repos~6.2k tokens
    Backend & APIsAuto-check passed
  • Convex Setup Auth

    spokvulcan/poker-planning

    Sets up Convex auth, identity mapping, and access control. An agent skill from spokvulcan/poker-planning.

    114 GitHub starsUsed in 8 repos~1.8k tokens
    Backend & APIsAuto-check passed
  • UI Audit

    bagofwords1/bagofwords

    Exhaustively audit the UI control by control and role by role — enumerate every button, link, and input on a set of pages, write down what each is supposed to do (derived from the handler code and…

    458 GitHub stars~2.9k tokensUpdated yesterday
    Backend & APIsAuto-check passed
  • Ccb Diagnose

    SeemSeam/claude_codex_bridge

    Diagnose a named CCB agent by combining authoritative runtime and job lineage with deep read-only pane inspection, apply bounded recovery when evidence supports it, verify the result, and request…

    3.5k GitHub stars~2.1k tokensUpdated yesterday
    Backend & APIsAuto-check passed

More from PostHog/posthog-foss

All 213 skills in this repo
  • Authoring Log Alerts

    PostHog/posthog-foss

    Official

    Author useful, low-noise log alerts on services in a PostHog project.

    721 GitHub stars~3k tokensUpdated today
    Auto-check passed
  • Autoresolving PR Conflicts

    PostHog/posthog-foss

    Official

    Operating procedure for the conflict-autoresolver agent: sweep open PostHog/posthog PRs that conflict with master, resolve the trivial conflicts (generated artifacts deterministically, source…

    721 GitHub stars~4.2k tokensUpdated today
    Auto-check passed
  • Official

    Help users debug PostHog Error Tracking stack-trace symbolication for any supported platform — JavaScript/TypeScript web, React Native (Hermes), Android (Proguard / R8), or iOS / macOS (dSYM).

    721 GitHub stars~2.2k tokensUpdated today
    Auto-check passed
  • Exploring Apm Traces

    PostHog/posthog-foss

    Official

    Investigates distributed application performance using PostHog APM (OpenTelemetry span) data via MCP.

    721 GitHub stars~3.5k tokensUpdated today
    Auto-check passed
  • Exploring LLM Traces

    PostHog/posthog-foss

    Official

    Debug and inspect LLM/AI agent traces using PostHog's MCP tools.

    721 GitHub stars~4.4k tokensUpdated today
    Auto-check passed
  • Investigate Metric

    PostHog/posthog-foss

    Official

    Diagnose why a product metric changed (dropped, spiked, or plateaued) by orchestrating breakdowns, actors, paths, lifecycle, retention, and annotations queries.

    721 GitHub stars~1.9k tokensUpdated today
    Auto-check passed

Works with

Categories

Questions about Checking Member Access

What does Checking Member Access do?

Explains what a member or a role can do in a PostHog project, using the access control MCP tools. Checking Member Access is an agent skill from PostHog/posthog-foss, published by the product's own GitHub organization. Explains what a member or a role can do in a PostHog project, using the access control MCP tools.

When should I use Checking Member Access?

Checking Member Access fits situations like: the user asks what someone can see; who can edit dashboards; why a member can; cannot open a dashboard.

How do I install Checking Member Access in Claude Code?

Run `npx skills add PostHog/posthog-foss --skill checking-member-access -a claude-code`. Or copy the skill folder (products/access_control/skills/checking-member-access in PostHog/posthog-foss) into .claude/skills/checking-member-access in your project. Claude Code loads it when a task matches its description.

How do I install Checking Member Access in Codex?

Run `npx skills add PostHog/posthog-foss --skill checking-member-access -a codex`. Or copy the skill folder (products/access_control/skills/checking-member-access in PostHog/posthog-foss) into .agents/skills/checking-member-access in your project. Codex loads it when a task matches its description.

Can I use Checking Member Access in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add PostHog/posthog-foss --skill checking-member-access -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/checking-member-access, .gemini/skills/checking-member-access, .github/skills/checking-member-access and .opencode/skills/checking-member-access in your project.

What does Checking Member Access need to run?

SKILL.md names no scripts, command-line tools or credentials: Checking Member Access is instructions for the agent only.

Does Checking Member Access access the network?

SKILL.md names 1 domain. As links in the text: posthog.com. This is read from the text; nothing was executed.

Is Checking Member Access safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Checking Member Access use?

Checking Member Access is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Checking Member Access use?

About 3.2k tokens (SKILL.md is roughly 13k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Checking Member Access?

Skills that share tags, products or a category with Checking Member Access: Configuring Horizon (coollabsio/coolify, 63k stars), K8s Security Policies (Cybereason-Public/owLSM, 280 stars), Payload (payloadcms/payload, 45k stars) and Convex Setup Auth (spokvulcan/poker-planning, 114 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Checking Member Access?

PostHog (a GitHub organization, an official publisher) maintains it in PostHog/posthog-foss, which has 721 GitHub stars. The repository holds 213 skills in this directory. The repository was last updated on October 7, 2026.

Source: PostHog/posthog-foss on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.