Find your next open-source project

Search by name, purpose, or keyword — or paste a GitHub repository URL
All skills

PostHog/posthog

Guides for working inside the PostHog codebase, covering how to add features, run tests, and ship changes safely.

  • 200 skills
  • 41k stars

The 5 most installed

Ordered by installs on skills.sh
  • react-doctor511 installs

    Diagnoses and fixes React codebase health issues, including performance problems, security gaps and code quality.

  • hogli267 installs

    Explains the PostHog developer CLI and repo tooling for running, building, testing, and linting.

  • Writes and modifies ClickHouse database migrations following project rules.

  • survey-sdk-audit255 installs

    Audits survey SDK features and version requirements, then implements survey changes across backend, UI, and SDKs.

  • django-migrations252 installs

    Guides safe Django and Postgres migration work, including non-blocking schema changes, backfills and model deletions.

The other 195 skills
  • setup-web-tests252 installs

    Sets up a Python test environment in Claude Code for web when the usual sync command fails.

  • Explains the ingestion pipeline architecture and points to the right doctor agent for a given concern.

  • playwright-test225 installs

    Writes a Playwright test, makes sure it runs, and checks that it is not flaky.

  • Exposes a PostHog API endpoint as an MCP tool, from serializer through generated TypeScript handler.

  • Reviews and improves Django REST Framework endpoints and serializers, covering field typing, schema annotations, and OpenAPI quality.

  • writing-skills205 installs

    Guides writing PostHog agent skills that teach agents how to use MCP tools to reach a goal.

  • Adds or extends data warehouse import sources, including datasets, incremental sync, pagination, credentials, and tests.

  • Plans and executes product isolation migrations toward a facade plus contract layer with a low-conflict PR strategy.

  • qa-team191 installs

    Runs a multi-agent code review of your branch, with specialists covering security, database, performance, frontend and copy.

  • Migrates frontend code from hand-written API calls and types to generated API functions.

  • Guides safe changes to PostHog's event and property picker, covering search, ordering, recents and performance.

  • Shows how to send real-time in-app notifications from backend code, including target type and priority.

  • Adds interactive MCP UI views that render tool results inside clients like Claude Desktop.

  • security-audit171 installs

    Builds a threat model from a diff or PR and checks the code for access control, injection, and data leaks.

  • Investigates failing GitHub Actions CI runs and answers questions about overall CI and master branch health.

  • Checks the health of PostHog's capture service in production, covering latency, event loss and Kafka backpressure.

  • Diagnoses PostHog's ingestion workers in production, covering event lag, drops, pipeline errors and downstream health.

  • Adds a new gRPC endpoint to the personhog service, including proto, clients and Rust code.

  • writing-tests153 installs

    Decides whether a new test is worth adding and keeps pytest, Jest and Playwright tests cheap and meaningful.

  • scene-menu-bar149 installs

    Explains how to add or edit the menu bar above a PostHog scene, including feature flags and rich inputs.

  • Lets an API endpoint accept project secret API keys for programmatic, user-less access.

  • fixing-flaky-tests148 installs

    Reproduces, root-causes, fixes, and validates intermittently failing Jest, pytest, or Playwright tests.

  • Speeds up slow ClickHouse and HogQL queries and explains how to fix timeouts or memory limits.

  • run-posthog147 installs

    Starts, inspects, and drives the local PostHog dev stack to check health or verify a UI change.

  • Decides whether a code comment should exist and keeps only ones that explain why, not what.

  • Creates and updates GitHub Actions secrets for PostHog workflows, including CI tokens, registry credentials, and deploy keys.

  • setting-up-devbox146 installs

    Starts, connects to, and troubleshoots a remote PostHog devbox workspace through command-line tools.

  • Shows how to register timers and event listeners in kea logic so they are cleaned up automatically.

  • Guides writing fast ClickHouse queries, choosing workloads, table design, materialized columns and indexes.

  • Sets up Depot-managed GitHub Actions runners, including sizes, labels and ARM or Windows runners.

  • Guides shipping a new dashboard widget type or updating a shipped one, including config, queries, layout, and RBAC.

  • writing-kea-logics145 installs

    Guides writing and reviewing kea logic files, including actions, reducers, selectors, listeners and React wiring.

  • Builds Docker images with Depot, including multi-platform builds and layer caching fixes.

  • Keeps heavy imports off the Django startup path so every process starts faster.

  • Produces slow-query performance reports for production ClickHouse, covering cost, timeouts, and memory regressions.

  • Helps choose the right chart for before/after and period-over-period comparisons when building UI with @posthog/quill-charts.

  • Writes or updates the user-facing documentation page for a data warehouse import source.

  • Finds which team owns a file or code path, or lists everything a given team owns.

  • Adds or edits GitHub Actions workflows that push images or trigger production deploys, with the required gate.

  • Runs read-only SQL against the local Postgres database to inspect tables, debug data and analyze query plans.

  • Runs local preflight checks to catch formatting, lint, lockfile, and migration failures before pushing.

  • Wires a PostHog frontend surface into the PostHog AI agent with scene context, instructions, tool reactions, and tool cards.

  • Sets the voice and word choices for any text users read in PostHog, from buttons to error messages and docs.

  • Adds a new warning type to the event ingestion pipeline with the right category and severity.

  • Pulls production experiment query-performance data and explains slow or failing experiment queries.

  • qa-frontend24 installs

    Runs browser-based QA on PostHog frontend changes and can record a feature demo reel.

  • querying-tophog24 installs

    Queries the ingestion pipeline's ClickHouse store to find which teams or users are causing lag or high cost.

  • Shapes a pull request description so reviewers quickly understand the problem and the change.

  • Connects a data warehouse table as a source of actionable items for the Self-driving Inbox.

  • Writes and edits GitHub Actions workflows and CI jobs following PostHog's conventions.

  • Adds first-run setup empty states to product screens using the shared component.

  • stacking-prs23 installs

    Creates and manages GitHub stacked pull requests with the gh stack tool, including rebasing and landing.

  • Adds a third-party MCP server to the PostHog MCP store catalog and verifies it works.

  • Adds alerting to a PostHog product or extends the shared alerts platform.

  • Helps read logs and diagnose stuck, failed or silent local task agent runs.

  • Adds regression scenarios, chaos events, and invariants to the personhog end-to-end test harness.

  • Records counters, gauges, and histograms into PostHog's own metrics product from PostHog code.

  • writing-evals22 installs

    Teaches how to write and run eval suites, cases, scorers and seeders on the PostHog AI eval harness.

  • Analyzes insights and dashboards across all teams by querying the synced dogfood warehouse.

  • Adds support for a new vendor API version to an existing data warehouse source, or deprecates an old one.

  • Finds vendor API endpoints and tables a data warehouse source never wired up, and ranks what to add next.

  • Sorts web analytics support tickets into known problem types, runs the matching playbook and drafts replies or fixes.

  • merging-prs18 installs

    Merges a PR through the Trunk merge queue and watches it until it lands or gets kicked out.

  • posthog-desktop17 installs

    Scopes work to the PostHog desktop Electron app and its separate workspace, packages and agent framework.

  • Runs a thorough two-pass review of personhog coordination-protocol changes covering leases, fencing, handoffs and failure budgets.

  • Guides adding Redis-backed rate limits with burst capacity, refills and refunds for requests that did no work.

  • Compares the two LLM gateways and updates the parity record from current implementation evidence.

  • Ranks callers that could safely move from the old LLM gateway to the new one, with evidence.

  • Guides dashboard platform and scene changes, including layouts, sharing, embeds, filters, refresh behavior, and performance.

  • Migrates an LLM caller from the old gateway to PostHog ai-gateway, updating clients, URLs, headers, and tests.

  • Decides which frontend folder a product file belongs in and explains the reasoning behind the split.

  • Splits a very large Python module into smaller per-concern modules without changing behavior.

  • Checks the real sync state of a customer's warehouse table in production to debug stale, empty or failing imports.

  • Investigates a table access denied error to tell whether it is a real bug or expected behavior.

  • Adds, reviews, or debugs PostHog Hobby end-to-end smoke tests and their CI workflow.

  • Applies house rules for Python dataclasses: when to use one, naming, construction and keeping secrets out of repr.

  • Sets structure and abstraction rules for React components and frontend files, including file layout and shared components.

  • Runs an eval-backed campaign that measures MCP tool quality, fixes the highest-impact problem, and keeps changes only if scores improve.

  • Decides whether a behavior-changing fix needs an in-app notice and builds one for affected users only.

  • Traces why session recordings don't show up in the local dev environment and points to the broken step.

  • Maintains existing pytest and Django test suites, reducing runtime and stale tests without weakening correctness.

  • Traces the signals pipeline locally to find why a signal never reaches the inbox.

  • Explains why a pull request was kicked from the merge queue and tells you whether to wait, fix, requeue or escalate.

  • Adds or fixes the audit trail that records who changed a Django model and when.

  • Checks the experiment precompute canary for divergences and pinpoints the affected team, experiment and metric.

  • Debugs missing or wrong MCP analytics data and helps build on the MCP analytics SDKs.

  • depot-ci10 installs

    Sets up and manages Depot CI, including migrating GitHub Actions workflows and debugging runs.

  • Decides whether a rule belongs in AGENTS.md or CLAUDE.md and writes it so it is followed.

  • Explains where files for the conversations product belong when adding, moving or reviewing them.

  • Profiles slow PostHog API endpoints whose cost sits in Postgres or Python, and plans fixes with production evidence.

  • Queries production databases through PostHog's internal Metabase for query plans, index checks and shareable links.

  • Does nothing, because CodeRabbit is retired on this repository in favor of PostHog Review.

  • Connects a real Slack workspace to local PostHog Conversations so Slack messages become support tickets.

  • Sets up local data and API keys to test staff-only managed migrations MCP tools end to end.

  • Guides chart selection, data, themes, sizing and composition when building charts with @posthog/quill-charts.

  • Adds an endpoint that receives webhooks from a third-party service and processes them safely.

  • Connects a new or changed service to ClickHouse using rotating service-account tokens instead of static passwords.

  • Guides changes to PostHog subscriptions, covering schedules, delivery, retries, permissions and related UI.

  • Routes new third-party HTTP calls through the right PostHog egress domain and lists the tests that catch mistakes.

  • Decides when an endpoint, setting, or page should require recent re-authentication and wires it up.

  • Explains how products and pages appear in the sidebar, including category, icon, and color choices.

  • Adds a new API scope so personal keys, OAuth tokens and MCP clients can access an endpoint.

  • Inspects a pasted LLM trace or session to show what the agent did, which tools it used, and what it cost.

  • Compares session replays across experiment variants to show how user behavior differs.

  • Finds unused or fully rolled-out feature flags and removes the code that checks them.

  • Sets up exposure events and metrics for a PostHog experiment and explains how to read results.

  • Sets the variant split and rollout percentage for a PostHog experiment.

  • Walks through setting up a new A/B test, from hypothesis and rollout to metrics and run time.

  • Checks which PostHog SDKs in a project are out of date and how to upgrade them.

  • Investigates AI traffic clusters, compares their behavior, and drills into individual traces.

  • Finds, inspects, and runs AI evaluations, then reports on their results and failure modes.

  • Sets up an LLM-judge evaluation that extracts real use cases for a feature and streams them to Slack.

  • Turns a loose description of an experiment into the exact experiment ID, asking when several match.

  • Guides experiment state transitions like launching, pausing, ending, shipping variants, archiving, duplicating, and migrating legacy experiments.

  • Sets up low-noise log alerts on services, with thresholds tested before saving.

  • Copies a feature flag to other PostHog projects, remapping cohorts and handling encrypted payloads.

  • Breaks down LLM spending by model, provider, user, or feature and explains cost spikes.

  • Audits a project's endpoints for staleness, failed materialisations and unused versions, then reports what to clean up.

  • Finds failed, unused or stale materialized views that waste storage and compute in a project.

  • Sets up error tracking alerts that notify Slack, webhook, or Linear when issues appear or spike.

  • Wires a PostHog endpoint into an app by generating a typed client and handling auth and errors.

  • Creates a PostHog endpoint that exposes a query as an API with the right shape.

  • Creates continuously running evaluations that automatically score new AI responses and traces for known failures.

  • Uses engineering analytics tools to find slow CI workflows, stuck pull requests and costly failing tests.

  • Explains why a single PostHog endpoint is slow or costly and proposes a concrete fix.

  • Helps fix error stack traces that stay minified after symbols are uploaded, across web, mobile and desktop.

  • Finds where an AI feature is failing in production and groups the failure patterns from real traces.

  • Reads a PostHog endpoint's execution logs to explain errors, failed runs, cache misses, and slow runs.

  • Finds feature flags deleted in the active project recently, including who deleted them and when.

  • Merges error tracking issues that are the same error under different fingerprints, or adds a lasting grouping rule.

  • Investigates one error tracking issue end-to-end, covering affected users, triggers, timing, correlations, and next steps.

  • Previews drafts, rolls back, updates settings, or deactivates specific endpoint versions and explains current limitations.

  • Creates error tracking suppression rules to drop high-volume, low-value errors at ingestion.

  • Triages error tracking issues into a prioritized list, ranking by users affected and pointing at linked replays.

  • Adds a new highlight rule that surfaces a product's facts on the Today home page.

  • Syncs warehouse table columns onto person or group properties for flags, cohorts and filters.

  • Answers whether AI answer engines cite your site, which topics get cited least, and who gets cited instead.

  • Finds the users driving the most AI observability cost and explains what makes them expensive.

  • Compares offline AI evaluation runs and diagnoses why individual cases regressed.

  • Adds and runs data quality checks on warehouse tables and saved-query views to catch nulls, duplicates, and stale data.

  • Creates alerts on trends, SQL, or funnel insights when a metric crosses a threshold or looks anomalous.

  • Creates a new dashboard or updates an existing one by assembling insights into one page.

  • Builds or edits a PostHog freeform canvas app such as a data board, form, or small tool.

  • Builds PostHog canvases using plain HTML, CSS, and browser APIs for documents and graphics.

  • Guides sending events to PostHog's capture v1 batch intake API and changing its schema.

  • Builds PostHog canvases with React and the Quill design system so they look native.

  • Builds, watches, and tests the PostHog toolbar and its browser extension.

  • Explains what a member or role can view or edit in a PostHog project.

  • Adds, moves, resizes, or removes widgets on PostHog grid and home canvases.

  • Keeps the context wiki coherent by working through a lint report queue.

  • Synthesizes recent organizational activity into a durable context wiki.

  • Reviews the context wiki for contradictions, stale priorities, and duplicate subjects.

  • Copies or duplicates a PostHog endpoint into another project or under a new name.

  • Adds or changes widgets, tiles and tabs on the customer analytics account detail page.

  • Diagnoses why a customer's A/B test results look wrong, such as uneven exposures or mismatched numbers.

  • Finds why a data quality check failed, shows the failing rows and recommends a fix.

  • Guides changes to PostHog's two command line tools, keeping the Rust and TypeScript versions in step.

  • Runs a health check on one experiment, covering exposures, sample ratio mismatch, significance traps and mid-run edits.

  • Exports PostHog events, persons, sessions or query results and downloads the resulting files.

  • Runs large audits, investigations, and triage as many isolated agents coordinated by a JavaScript workflow.

  • Adds panels, staff actions, and cross-team reports to the PostHog Admin staff console.

  • Builds and validates Slack Block Kit messages, modals, and App Home layouts.

  • Investigates a CI failure to a verdict: whose fault, which commit, who wrote it, and whether a fix landed.

  • Links an error occurrence or session to OpenTelemetry traces, same-trace logs, and Session Replay.

  • Creates, versions, releases, and fetches LLM prompts with PostHog prompt management and SDK code.

  • Installs, configures, authenticates, and troubleshoots MCP servers, including OAuth login and mcp.json setup.

  • Builds reusable activation models, including an activation-rate metric and a per-user activated flag, on warehouse views or dbt.

  • Builds reusable conversion models such as funnel rates, drop-off, and time-to-convert on warehouse views or dbt.

  • Builds reusable dimension and lookup tables for a star schema, like country, timezone, currency, date, and plan.

  • Builds reusable product-usage models for retention, stickiness, and lifecycle on warehouse views or dbt.

  • Builds reusable revenue models like MRR, ARR, churn, ARPU, LTV, and per-customer revenue on warehouse views or dbt.

  • Sets up reusable data models in PostHog's warehouse or a dbt project before you build business models.

  • Shows how to pull PostHog insights and queries into a canvas correctly, including date ranges and live third-party data.

  • Runs read-only queries against PostHog's production ClickHouse and Postgres in the US and EU regions.

  • Edits the @posthog/quill design system locally and tests the change in the desktop app before publishing.

  • Records a captioned, branded walkthrough video of a feature running on the local PostHog stack.

  • Re-creates a reviewed pull request from a fork on a PostHog branch so it can pass checks and merge.

  • Decides whether a mobile app change ships as an over-the-air update or needs a native store release, then files the request.

  • Diagnoses ingestion warnings such as missing events, failed merges, oversized payloads and empty heatmaps.

  • Runs the mobile app's demo smoke flows on a local iOS simulator and reports their results.

  • Sets up a Replay Vision scanner that watches an experiment's sessions and compares results across variants.

  • Sets up AI citation tracking for a project, choosing answer engines, competitors, and prompts to monitor.

  • Populates a project's data catalog with canonical metrics, trust marks, and reviewed table relationships.

  • Maps warehouse table columns to person or group properties usable in flags, cohorts, and insights.

  • Watches AI answer engine citation rates and files a report when a domain's rate shifts or the checker fails.

  • Writes Storybook stories for UI components, covering provider setup and data-fetching pitfalls.

  • Decides when to delegate codebase exploration, planning, or code changes to subagents with separate context.

  • Drives the running PostHog desktop app over CDP to test changes against a live local backend.

  • Turns PR and CI data into saved PostHog insights, dashboards and scheduled reports, with SQL examples.

  • Explains what is driving PostHog usage and spend, and how to reduce it.

  • Syncs the forked Claude agent adapter with a newer upstream release while keeping local changes.

  • Validates and publishes a canvas project safely, handling version conflicts and capacity limits.

  • Picks the cheapest check that confirms a change works and says when a slower one is needed.

  • Trains agent-driven models that predict who will churn, convert or adopt a feature, then scores people daily.

  • Runs, writes and debugs Storybook stories and their visual review snapshots.