> ## Documentation Index
> Fetch the complete documentation index at: https://docs.gourmand.dev/llms.txt
> Use this file to discover all available pages before exploring further.
# Building a Continuous AI Workflow with PostHog and GitHub
> Build an automated system that continuously monitors PostHog analytics, analyzes user behavior with AI, and creates GitHub issues automatically using PostHog MCP.
A fully automated workflow that uses Gobi CLI with the PostHog MCP to fetch analytics data, analyze user experience issues with AI, and automatically create GitHub
issues with the GitHub CLI.
## What You'll Learn
This cookbook teaches you to:
* Use [PostHog MCP](https://posthog.com/docs/model-context-protocol) to query [analytics](https://posthog.com/docs/web-analytics), [errors](https://posthog.com/docs/error-tracking), and [feature flags](https://posthog.com/docs/feature-flags)
* Analyze user behavior patterns with AI
* Automatically create GitHub issues using GitHub CLI
* Set up continuous monitoring with GitHub Actions
## Prerequisites
Before starting, ensure you have:
* GitHub repository where you want to create issues
* [PostHog account](https://posthog.com) with [session recordings enabled](https://posthog.com/docs/session-replay/installation) and data collecting
* Node.js 18+ installed locally
* [Gobi CLI](https://docs.gourmand.dev/guides/cli) with **active credits** (required for API usage)
* [GitHub CLI](https://cli.github.com/) installed (`gh` command)
```bash theme={null}
npm i -g @gourmanddev/cli
```
1. Visit [Gobi Organizations](https://hub.gourmand.dev/settings/organizations)
2. Sign up or log in to your Gobi account
3. Navigate to your organization settings
4. Click **"API Keys"** and then **"+ New API Key"**
5. Copy the API key immediately (you won't see it again!)
6. Login to the CLI: `cn login`
Gobi CLI will securely store your API keys as secrets that can be referenced in prompts.
Gobi CLI handles the complex API interactions - you just need to provide
the right prompts!
## Step 1: Set Up Your Credentials
First, you'll need to gather your PostHog and GitHub API credentials and add them as secrets in Gobi CLI.
You'll need a **Personal API Key** (not a Project API key) to access session recordings:
1. Go to [Personal API Keys](https://app.posthog.com/settings/user-api-keys) in PostHog
2. Click **+ Create a personal API Key**
3. Name it "Gobi CLI Session Analysis"
4. Select these scopes:
* `session_recording:read` - **Required** for accessing session data
* `feature_flag:read` - **Required** for feature flag auditing
* `insight:read`
* `query:read`
* `session_recording_playlist:read`
5. Copy the key immediately (you won't see it again!)
6. Note your **Project ID** from your PostHog project settings
7. Note your PostHog host URL (e.g., `https://us.posthog.com` or your custom domain)
8. You'll also need your POSTHOG\_AUTH\_HEADER value, which is simply `Bearer YOUR_API_KEY`
**Gobi Secrets**: The `POSTHOG_AUTH_HEADER` secret should be stored in
Gobi's secure secrets storage. This keeps your API key safe and the MCP
automatically connects to your default PostHog project.
GitHub CLI handles authentication automatically - no manual PAT needed:
1. Install GitHub CLI if not already installed
2. Run `gh auth login` and follow the prompts
3. Choose authentication method (browser or token)
4. Grant necessary permissions when prompted (`issues:write` is **required** for creating issues)
See [https://docs.gourmand.dev/hub/secrets/secret-types#secret-types](https://docs.gourmand.dev/hub/secrets/secret-types#secret-types) for adding secrets
You only need to configure the PostHog MCP credential - it automatically handles project selection. To add environment variables to your Gobi Hub account:
1. Go to the [Gobi Hub](https://hub.gourmand.dev)
2. Sign in to your account
3. Navigate to your user settings
4. Look for the "Secrets" section
5. Add your Personal API Key from PostHog (phx\_...) as POSTHOG\_AUTH\_HEADER secret with format: Bearer YOUR\_API\_KEY
## PostHog GitHub Continuous AI Workflow Options
Skip the manual setup and use our pre-built PostHog GitHub agent that includes
optimized prompts, rules, and the PostHog MCP for more consistent results.
**How PostHog MCP Works**:
* Your API key is tied to your PostHog account and
organization
* It automatically uses your default project (no project ID
needed)
* If you have multiple projects, use `mcp__posthog__switch-project` to
change
* The MCP connects via `https://mcp.posthog.com/sse` using your account context.
**Perfect for:** Immediate results with optimized prompts and built-in debugging
Visit the [PostHog GitHub Continuous AI Agent](https://hub.gourmand.dev/gobi/awesome-models-posthog-gh) on Gobi Hub and click **"Install Agent"** or run:
```bash theme={null}
cn --config gourmand/awesome-models-posthog-gh
```
This agent includes:
* **Optimized prompts** for [PostHog analysis](https://hub.gourmand.dev/gobi/posthog-analysis) and [GitHub issue creation](https://hub.gourmand.dev/gobi/posthog-github-issues)
* **[Built-in rules](https://hub.gourmand.dev/bekah-hawrot-weigel/posthog-github-continuous-ai-rules)** for consistent formatting and error handling
* **[PostHog MCP](https://hub.gourmand.dev/posthog/posthog-mcp)** for more reliable API interactions
From your project directory, run:
```bash theme={null}
cn "Give me my PostHog Session data and create GitHub issues based on the problems."
```
That's it! The agent handles everything automatically.
**Why Use the Agent?** Results are more consistent and debugging is easier thanks to the PostHog MCP integration and pre-tested prompts.
First, install the [PostHog MCP](https://hub.gourmand.dev/posthog/posthog-mcp) or run:
```bash theme={null}
npx -y mcp-remote@latest https://mcp.posthog.com/sse --header Authorization:${{ secrets.gourmand/awesome-models-posthog-gh/posthog/posthog-mcp/POSTHOG_AUTH_HEADER }}
```
In the Gobi Hub, add the [PostHog GitHub Continuous AI Rules](https://hub.gourmand.dev/bekah-hawrot-weigel/posthog-github-continuous-ai-rules) to your account for better formatting and error handling.
Use this prompt with Gobi CLI to analyze PostHog data and create GitHub issues:
```bash theme={null}
# In cn TUI mode:
"Create GitHub issues from the PostHog analysis using gh CLI:
- For each issue, run: gh issue create --title '🔍 UX Issue: [title]' --body '[details]'
- Add labels: --label 'bug,user-experience,automated'
- Set priority labels (high/medium/low)
- Include session data and technical details in the body
Execute the commands and confirm each issue was created with URL."
```
**Why GitHub CLI over GitHub MCP**: While GitHub MCP is available, it can be
token-expensive to run. The `gh` CLI is more efficient, requires no API tokens
(authenticated via `gh auth login`), and provides a cleaner command-line
experience. GitHub MCP remains an option if you prefer full MCP integration.
To use the pre-built agent, you need either:
* **Gobi CLI Pro Plan** with
the models add-on, OR
* **Your own API keys** added to Gobi Hub secrets
(same as Step 1 below) The agent will automatically detect and use your
configuration.
***
**Repository Labels Required**: Make sure your GitHub repository has these labels:
* `bug`, `enhancement`, `technical-debt`
* `high-priority`, `medium-priority`, `low-priority`
* `user-experience`, `automated`, `feature-flag`, `cleanup`
Create missing labels in your repo at: **Settings → Labels → New label**
**What Gobi CLI Does:**
* Parses your analysis results automatically
* Makes authenticated GitHub API calls using your stored token
* Creates properly formatted issues with appropriate labels
* Checks for duplicate issues to avoid spam
* Provides confirmation with issue URLs
## What You've Built
After completing this guide, you have a complete **Continuous AI system** that:
* **Monitors user experience** - Automatically fetches and analyzes PostHog session data
* **Identifies problems intelligently** - Uses AI to spot patterns and technical issues
* **Creates actionable tasks** - Generates GitHub issues with specific recommendations
* **Runs autonomously** - Operates daily without manual intervention using GitHub Actions
* **Scales with your team** - Handles growing amounts of session data automatically
Your system now operates at **[Level 2 Continuous
AI](https://blog.gourmand.dev/what-is-continuous-ai-a-developers-guide/)** -
AI handles routine analysis tasks with human oversight through GitHub issue
review and prioritization.
## Security Best Practices
**Protect Your API Keys:**
* Store all credentials as GitHub Secrets, never in
code
* Use Gobi CLI's secure secret storage
* Limit token scopes to minimum required permissions
* Rotate API keys regularly (every 90 days recommended)
* Monitor token usage for unusual activity
## Example Use Cases
Here are practical examples of what you can build with PostHog MCP and Gobi CLI:
### Session Recording Analysis (Current Implementation)
The main workflow above focuses on analyzing session recordings to identify UX issues and create GitHub issues automatically.
### Feature Flag Audit and Cleanup
Automatically audit your feature flags to identify unused, outdated, or problematic flags that need attention.
**What this workflow does:**
* Fetches all feature flags from your PostHog project
* Analyzes flag usage, rollout status, and configuration
* Identifies flags that may be candidates for removal or updates
* Creates GitHub issues for flag cleanup tasks
**Example Gobi CLI prompts:**
```bash theme={null}
# Get all feature flags and analyze them
cn "Use PostHog MCP to fetch all feature flags with mcp__posthog__feature-flag-get-all. Then analyze each flag to identify: 1) Flags that are 100% rolled out and could be removed, 2) Flags that haven't been updated in 90+ days, 3) Flags with complex targeting that might need simplification, 4) Experimental flags that should be cleaned up."
# Create cleanup issues for identified flags
cn "For each problematic feature flag identified, create a GitHub issue using gh CLI:
- Title: '🏁 Feature Flag Cleanup: [flag_name]'
- Include flag details: rollout percentage, last modified date, targeting rules
- Add labels: 'technical-debt', 'feature-flag', 'cleanup'
- Set priority based on risk level (high for 100% rollouts, medium for stale flags)
- Include specific recommendations for each flag"
# Audit flag performance impact
cn "Cross-reference feature flags with PostHog performance metrics to identify flags that may be impacting user experience or site performance. Create performance-focused GitHub issues for flags showing negative impact."
```
**Required PostHog MCP Tools:**
* `feature-flag-get-all` - Retrieve all feature flags
* `feature-flag-get-definition` - Get detailed flag configuration
* `query-run` - Run analytics queries to check flag usage
* `insights-get-all` - Get insights related to flag performance
**Sample Output:**
This workflow creates GitHub issues like:
* "🏁 Feature Flag Cleanup: dark-mode-toggle" (100% rollout, safe to remove)
* "🏁 Feature Flag Review: experimental-checkout" (unused for 120 days)
* "🏁 Feature Flag Simplify: complex-user-targeting" (overly complex rules)
### Advanced Prompts
Consider enhancing your workflow with these advanced Gobi CLI prompts:
"Analyze [PostHog performance
metrics](https://posthog.com/docs/web-analytics) alongside session
recordings to identify slow page loads affecting user experience"
"Cross-reference JavaScript console errors with user actions to identify the
root cause of UX issues"
"Use PostHog MCP to correlate feature flag rollouts with performance metrics and user behavior changes to identify flags causing issues"
"Create Slack alerts when critical UX issues are detected in PostHog
sessions or when feature flags need attention"
## Next Steps
* Consider [GitHub MCP](https://hub.gourmand.dev/github/github-mcp) as an alternative (note: can be token-expensive)
* Configure [Slack MCP](https://hub.gourmand.dev/slack/slack-mcp) for alerts
* Set up [PostHog performance monitoring](https://posthog.com/docs/web-analytics)
* Join the [Gobi Discord](https://discord.gg/gobi) for support
## Resources
* [PostHog API Documentation](https://posthog.com/docs/api)
* [PostHog MCP Documentation](https://posthog.com/docs/model-context-protocol)
* [PostHog Session Replay](https://posthog.com/docs/session-replay)
* [PostHog Feature Flags](https://posthog.com/docs/feature-flags)
* [PostHog Error Tracking](https://posthog.com/docs/error-tracking)
* [GitHub CLI Documentation](https://cli.github.com/)
* [GitHub MCP on Gobi Hub](https://hub.gourmand.dev/github/github-mcp) (alternative option)
* [Gobi CLI Guide](https://docs.gourmand.dev/guides/cli)
* [Continuous AI Best Practices](https://blog.gourmand.dev/what-is-continuous-ai-a-developers-guide/)