GitHub Intelligence: Code, Issues, PRs, and Commits in Dev Mode

Code tells you what. Discussions tell you why.

Your GitHub repositories have the implementation—thousands of commits, hundreds of PRs, detailed code. But the reasoning lives elsewhere: Slack discussions, Notion specs, meeting recordings where architecture was debated.

GitHub's native search finds code and issues within a single repo. But it can't answer:

• "Why did we choose this approach?"
• "What were the concerns about this PR?"
• "Who knows about the payment service?"
• "Show me all auth-related changes across 10 repos"

Zine's GitHub Intelligence (Dev Mode) connects code to context. Search across repos, link PRs to Slack threads, visualize contributor networks—all in one interface designed for developers.

Table of Contents

1. The GitHub Context Problem
2. Dev Mode: GitHub Intelligence in Zine
3. Four GitHub Connectors
4. Setup: Connecting GitHub to Zine
5. Searching GitHub in Zine
6. Cross-Tool Queries: Code + Discussions
7. Graph View: Contributor Networks
8. Timeline View: Feature Implementation Stories
9. MCP Integration: GitHub in Your IDE
10. Use Cases for Developers

The GitHub Context Problem

Problem 1: Context is Scattered

Where knowledge lives:

• Code: GitHub repos (what was implemented)
• Discussions: GitHub issues, PR comments (some context)
• Decisions: Slack #engineering (why this approach was chosen)
• Specs: Notion, Google Docs (requirements and architecture)
• Reviews: Meeting recordings (architecture review, design review)

To understand a feature, you must check 5 tools manually.

Example: Understanding the auth system

1. Search GitHub for auth-service repo
2. Read code
3. Check issues labeled "authentication"
4. Search Slack for "auth" or "authentication"
5. Check Notion for "Auth Architecture" spec
6. Ask senior engineer if docs are outdated

Time cost: 1-2 hours

Problem 2: GitHub Search is Repo-Scoped

GitHub's search limitations:

• Search one repo at a time (can't easily search across 50 repos)
• Code search is keyword-based (not semantic)
• Can't search "Show me all changes related to authentication across all repos"
• No way to connect issues to related Slack discussions

Problem 3: Onboarding is Slow

New developers need:

• Which repos matter
• How systems connect
• Past architectural decisions
• Common pitfalls (discussed in Slack, not documented)

With GitHub alone: Takes weeks to explore, senior engineer guidance required

With Zine Dev Mode: Ask "How does our payment system work?" → Get repos + issues + Slack discussions + specs

Dev Mode: GitHub Intelligence in Zine

Dev Mode is Zine's developer-focused interface that unifies:

• GitHub repos (code, file structure)
• GitHub issues (bugs, features, discussions)
• GitHub PRs (code reviews, implementations)
• GitHub commits (change history, author graphs)
• Slack (engineering discussions)
• Notion/Docs (specs, architecture decisions)
• Meeting recordings (architecture reviews)

Split View Layout:

• Left pane: Code browser, file explorer
• Right pane: Related issues, PRs, discussions

Graph View:

• Visual network of repos, contributors, topics

Timeline View:

• Chronological feed of commits, issues, PRs, discussions

Four GitHub Connectors

Zine offers four GitHub connector types for different needs:

1. GitHub Code

What it ingests: Repository contents (files, directories, branches)

Use cases:

• Search code syntax ("Find all occurrences of createUser")
• Explore file structure
• Analyze codebase architecture

Setup:

• Select repos to ingest
• Choose branches (main, develop, release/*)
• Zine clones and indexes code

Sync: Hourly checks for new commits, ingests changes

2. GitHub Issues

What it ingests: Issues with comments, labels, milestones, assignees

Use cases:

• Search bugs, feature requests, discussions
• Track issue resolution history
• Find related Slack discussions

Setup:

• Select repos
• Filter by labels (e.g., only "bug", "feature-request")
• Zine syncs all issues + comments

Sync: Hourly for new/updated issues

3. GitHub Pull Requests

What it ingests: PRs with descriptions, review comments, diffs, merge status

Use cases:

• Search past implementations
• Find code review patterns
• Understand change history

Setup:

• Select repos
• Filter by state (open, closed, merged, all)
• Zine syncs PRs + review threads

Sync: Hourly for new/updated PRs

4. GitHub Commits

What it ingests: Commit history with messages, authors, diffs, timestamps

Use cases:

• Track who changed what when
• Analyze contribution patterns
• Find specific changes by commit message

Setup:

• Select repos
• Choose branches
• Zine syncs commit history

Sync: Hourly for new commits

Pro tip: Use all four for complete GitHub intelligence. Each provides different lens on your codebase.

Setup: Connecting GitHub to Zine

Step 1: Add GitHub Connector

1. Log in to Zine
2. Go to Data Sources → Add Source
3. Select GitHub (choose type: Code, Issues, PRs, or Commits)

Step 2: Authorize with OAuth

For Private Repos:

1. Click Connect with OAuth
2. GitHub prompts for permissions:
   • Read access to code (for Code connector)
   • Read access to issues (for Issues connector)
   • Read access to pull requests (for PR connector)
   • Read repository metadata
3. Authorize Zine

For Public Repos:

• Enter repo URL (e.g., https://github.com/facebook/react)
• No OAuth needed

Security: Zine uses GitHub OAuth—we never see your GitHub password.

Step 3: Select Repositories

Choose which repos to ingest:

• Option 1: All repos in your org (e.g., acme-corp/*)
• Option 2: Specific repos (e.g., acme-corp/api, acme-corp/frontend)
• Option 3: Public repos by URL

Pro tip: Start with 5-10 core repos. Add more later as needed.

Step 4: Configure Filters (Optional)

For Issues:

• Only "open" issues
• Only issues with labels: "bug", "feature-request"

For PRs:

• Only "merged" PRs (ignore closed-without-merge)
• PRs from last 12 months

For Commits:

• Only commits from specific branches (main, develop)
• Commits from last 6 months

Reason: Reduces noise, focuses on relevant content.

Step 5: Initial Sync

Zine begins ingesting:

• Small repo (1K commits): ~5 minutes
• Medium repo (10K commits): ~30 minutes
• Large repo (100K+ commits): ~2-3 hours

Progress indicator shows:

• Repos processed
• Issues/PRs/commits ingested
• ETA for completion

Step 6: Continuous Sync

After initial sync:

• Frequency: Every hour (configurable)
• Incremental: Only new/changed content
• Webhooks (Professional plan): Real-time updates when commits/PRs/issues are created

You never manually re-sync. GitHub stays current automatically.

Searching GitHub in Zine

Code Search

Find code patterns:

createUser function

Returns: All files containing createUser function across all connected repos.

Semantic code search:

authentication implementation

Returns: Files related to auth (even if they don't contain exact phrase).

Issue Search

Find bugs:

checkout API timeout

Returns: Issues mentioning checkout, API, timeout (ranked by relevance).

Filter by label:

label:bug redis

PR Search

Find implementations:

OAuth implementation

Returns: PRs with "OAuth" in title, description, or comments.

Find reviews by person:

reviewed-by:alice

Commit Search

Find specific changes:

fix redis timeout

Returns: Commits with "fix", "redis", "timeout" in commit message.

Find changes by author:

author:bob caching

Cross-Tool Search (Most Powerful)

Query: "Redis caching implementation"

Zine returns (unified):

1. GitHub Code: cache-service/redis.js (implementation)
2. GitHub Issue #234: "Implement Redis cache" (requirements)
3. GitHub PR #567: "Add Redis cache with LRU eviction" (implementation + review comments)
4. Slack #engineering: Discussion about eviction policy (reasoning)
5. Notion: "Caching Strategy" spec (architecture decision)

All in one search. All with citations.

Cross-Tool Queries: Code + Discussions

Example 1: Feature Implementation Trail

Query: "OAuth implementation"

Returns:

1. Notion spec (March): "Auth Architecture v2 - OAuth2 + PKCE"
2. Slack #engineering (April): "OAuth implementation concerns" (JWT vs sessions debate)
3. GitHub Issue #234 (April): "Implement OAuth2" (requirements, discussion)
4. GitHub PR #567 (May): "Add OAuth2 authentication" (implementation)
5. Slack #engineering (May): "OAuth PR review feedback" (security concerns)
6. Meeting recording (May): Architecture review (timestamp: 14:32 - OAuth approved)
7. GitHub commits (May): 5 commits by Bob implementing OAuth

Result: Complete story from decision → discussion → implementation → review.

Example 2: Bug Investigation

Query: "Checkout API timeout error"

Returns:

1. Slack #incidents (today): "Checkout timeouts spiking 400%"
2. GitHub Issue #789: "Checkout API timing out" (opened 2 hours ago)
3. GitHub PR #801 (yesterday): "Improve Redis cache" (merged, might be cause)
4. Slack #engineering (yesterday): "Concerns about Redis eviction policy"
5. GitHub commits: PR #801's commits changing cache logic

Hypothesis identified in 2 minutes: Recent Redis change caused timeouts.

Example 3: Contributor Expertise

Query: "Who worked on authentication?"

Returns:

• Alice: 15 GitHub commits (auth-service), 10 Slack messages, 2 PR reviews
• Bob: 25 GitHub commits, 5 Slack threads, authored main OAuth PR
• Sarah: Authored Notion spec, led meeting review

Graph View shows:

• Contribution patterns
• Collaboration relationships
• Expertise areas

Graph View: Contributor Networks

Visualizing Code Relationships

Graph nodes:

• Repos (circles) - connected by shared contributors
• People (squares) - connected by collaboration
• Topics (triangles) - connected by co-occurrence

Example Graph: "Authentication system"

Shows:

• Repos: auth-service, api-gateway, user-service (connected)
• People: Alice, Bob, Sarah (collaborated)
• Topics: "OAuth", "JWT", "Sessions", "Security"
• Connections: Alice+Bob worked on auth-service, Sarah reviewed specs

Discovery Queries

"Who knows about the payment system?"

• Graph shows 5 contributors + their repos + related topics

"What repos is Alice active in?"

• Graph shows Alice's repos, commits, PR reviews

"How does 'authentication' relate to 'user management'?"

• Graph shows shared code, issues linking these topics

Timeline View: Feature Implementation Stories

Timeline reconstructs feature development chronologically.

Example: "API rate limiting feature"

Timeline shows:

Jan 5 - Slack #product: Customer requests rate limiting
Jan 8 - Notion: "API Rate Limiting Spec" (Sarah authors)
Jan 10 - GitHub Issue #345: "Implement rate limiting" (created)
Jan 12 - Slack #engineering: Implementation approach discussion (15 messages)
Jan 15 - GitHub PR #456: "Add rate limiting middleware" (Bob creates)
Jan 16 - Slack #engineering: PR review feedback
Jan 17 - GitHub PR #456: Bob addresses review comments (3 commits)
Jan 18 - GitHub PR #456: Merged (Alice approves)
Jan 20 - Slack #product: "Rate limiting shipped!"
Jan 22 - GitHub Issue #345: Closed

Result: See how feature evolved from customer request → spec → implementation → deployment.

MCP Integration: GitHub in Your IDE

Use Zine GitHub in Cursor

With Zine MCP configured in Cursor (see MCP Integration guide):

Query in Cursor:

Search Zine for authentication implementation

Cursor gets from Zine:

• GitHub code: auth-service/ files
• GitHub PRs: Past auth implementations
• Slack: Discussions about auth choices
• Notion: Auth architecture spec

Your coding agent now has:

• The implementation (GitHub code)
• The reasoning (Slack discussions)
• The requirements (Notion spec)

Example workflow:

1. In Cursor: "Implement password reset flow"
2. Cursor queries Zine: "How did we implement email verification?" (similar flow)
3. Zine returns: GitHub PR #234, Slack security discussion, Notion guidelines
4. Cursor implements following your team's established patterns

Use Cases for Developers

Use Case 1: New Developer Onboarding

Challenge: New engineer needs to understand codebase

Without Zine:

• Clone 20 repos (which ones matter?)
• Read code (what's the architecture?)
• Ask senior engineers (takes their time)
• Read outdated docs (what's current?)

With Zine Dev Mode:

1. Search: "How does our architecture work?"
   • Returns: Notion spec + GitHub repos + Slack discussions
2. Graph View: Visualize repo relationships, find entry points
3. Ask: "Who can I talk to about the payment system?"
   • Returns: Top 3 contributors with expertise
4. Timeline: "Show me how the payment system evolved"
   • Returns: Chronological feature development

Onboarding time: 2 months → 2 weeks

Use Case 2: Feature Development

Task: Implement new API endpoint

Step 1: Research Patterns

Search Zine: similar API endpoints

Returns: Past PRs for similar endpoints + review comments

Step 2: Check Requirements

Search Zine: API security requirements

Returns: Notion spec + Slack discussion + past PR security feedback

Step 3: Implement

• Write code following discovered patterns
• Reference security guidelines from search

Step 4: Pre-Review Check

Search Zine: common API PR feedback

Returns: Past review comments on similar PRs

Time saved: 30-60 minutes per feature

Use Case 3: Bug Investigation

Error: Checkout API 500 errors

Step 1: Find Recent Changes

Search Zine: checkout API changes last 7 days

Returns: GitHub commits, PRs merged in last week

Step 2: Check Discussions

Search Zine: checkout API OR payment processing

Returns: Slack #engineering threads, GitHub issue discussions

Step 3: Find Similar Issues

Search Zine: checkout timeout OR 500 error

Returns: Past incidents from Slack #incidents, resolved issues

Time saved: 15-30 minutes of manual investigation

Use Case 4: Code Review

PR to review: New payment processing logic

Step 1: Understand Current Approach

Search Zine: payment processing implementation

Returns: Current code + past PRs + Slack discussions about payment system

Step 2: Check Security Guidelines

Search Zine: payment security requirements

Returns: Notion checklist + past PR security feedback + compliance discussions

Step 3: Review PR

• Compare against team patterns
• Check security requirements met
• Reference past feedback for similar code

Review quality: Improved (you have full context)

Use Case 5: Architecture Evolution

Question: "How has our auth system evolved?"

Timeline View:

2023 Q1 - Initial auth-service repo (basic JWT)
2023 Q2 - PR #45: "Add OAuth support" (customer request)
2023 Q4 - Slack discussion: Security audit concerns
2024 Q1 - PR #123: "Refactor auth to use sessions" (major change)
2024 Q3 - PR #234: "Add SSO support" (enterprise feature)
2025 Q1 - Issue #567: "Deprecate JWT endpoints" (cleanup)

Result: See evolution, understand why changes were made (linked Slack discussions).

Best Practices

1. Connect All Four GitHub Types

Don't just connect Code—connect Issues, PRs, Commits too:

• Code: What's implemented now
• Issues: Requirements, bugs, discussions
• PRs: Implementation history, review comments
• Commits: Granular change history

Result: Complete GitHub intelligence.

2. Include Archived Repos

Don't forget old repos:

• Legacy systems
• Deprecated services
• Archived projects

Why: Often contain valuable context for current systems (how things used to work, migration rationale).

3. Combine with Slack and Notion

Always connect Slack #engineering and Notion specs alongside GitHub:

• GitHub: What and how
• Slack: Why and concerns
• Notion: Requirements and architecture

Result: Code + context in every search.

4. Use Dev Mode Split View

Layout:

• Left: Code browser
• Right: Related issues, PRs, discussions

Workflow: Exploring code? See related issues/PRs automatically.

5. Create Saved Views for Common Queries

Examples:

• "Open Bugs": label:bug state:open
• "My PRs": author:your-github-username state:open
• "Security Issues": label:security
• "Recent Changes": after:7-days-ago

Time saved: One-click access to common queries.

Next Steps

Now that GitHub is connected:

1. ✅ Explore Dev Mode: Switch to Dev Mode, explore split view and graph
2. ✅ Test Cross-Tool Search: Search "authentication" across GitHub + Slack + Notion
3. ✅ Create Saved Views: For bugs, your PRs, security issues
4. ✅ Connect Slack: Add #engineering, #devops for full developer context
5. ✅ Set Up MCP: Use GitHub context in Cursor, VS Code

Related Guides:

• MCP Integration - Use GitHub context in your IDE
• Slack Knowledge Base - Connect engineering discussions
• AI Coding Agent Setup - Complete developer workflow
• Data Connectors - Connect 30+ other sources

Learn More:

• Try Zine - Free tier available
• Watch: Zine Dev Mode
• Schedule a demo - Get help setting up GitHub intelligence

Code is what. Context is why. Search both.