How GitHub Models can help open source maintainers focus on what matters

Open source runs on passion and persistence. Maintainers are the volunteers who show up to triage issues, review contributions, manage duplicates, and do the quiet work that keeps projects going.

Most don’t plan on becoming community managers. But they built something useful, shared it, and stayed when people started depending on it. That’s how creators become stewards.

But as your project grows, your time to build shrinks. Instead, you’re writing the same “this looks like a duplicate of #1234” comment, asking for missing reproduction steps, and manually labeling issues. It’s necessary work. But it’s not what sparked your love for the project or open source.

That’s why we built GitHub Models: to help you automate the repetitive parts of project management using AI, right where your code lives and in your workflows, so you can focus on what brought you here in the first place. 

What maintainers told us

We surveyed over 500 maintainers of leading open source projects about their AI needs. Here’s what they reported:

• 60% want help with issue triage — labeling, categorizing, and managing the flow
• 30% need duplicate detection — finding and linking similar issues automatically
• 10% want spam protection — filtering out low quality contributions
• 5% need slop detection — identifying low quality pull requests that add noise

Folks surveyed indicated that they wanted AI to serve as a second pair of eyes and to not intervene unless asked. They also said triaging issues, finding similar issues, helping write minimal reproductions were top of mind. Clustering issues based on topic or feature was also possibly the most important concern to some.

How GitHub Models + GitHub Actions = Continuous maintainer support

We’re calling this pattern Continuous AI using automated AI workflows to enhance collaboration, just like CI/CD transformed testing and deployment. With GitHub Models and GitHub Actions, you can start applying it today. 

Here’s how Continuous AI can help maintainers (you!) manage their projects

The following examples are designed for you to easily copy and paste into your project. Make sure GitHub Models is enabled for your repository or organization, and then just copy the YAML into your repo’s .github/workflows directory. Customize these code blocks as needed for your project.

Add permissions: models: read to your workflow YAML, and your action will be able to call models using the built-in GITHUB_TOKEN. No special setup or external keys are required for most projects. 

Automatic issue deduplication

Problem: You wake up to three new issues, two of them are describing the same bug. You copy and paste links, close duplicates, and move on… until it happens again tomorrow.

Solution: Implement GitHub Models and a workflow to automatically check if a new issue is similar to existing ones and post a comment with links.

name: Detect duplicate issues

on:
  issues:
    types: [opened, reopened]

permissions:
  models: read
  issues: write

concurrency:
  group: ${{ github.workflow }}-${{ github.event.issue.number }}
  cancel-in-progress: true

jobs:
  continuous-triage-dedup:
    if: ${{ github.event.issue.user.type != 'Bot' }}
    runs-on: ubuntu-latest
    steps:
      - uses: pelikhan/action-genai-issue-dedup@v0
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          # Optional tuning:
          # labels: "auto"          # compare within matching labels, or "bug,api"
          # count: "20"             # how many recent issues to check
          # since: "90d"            # look back window, supports d/w/m

This keeps your issues organized, reduces triage work, and helps contributors find answers faster. You can adjust labels, count, and since to fine tune what it compares against.

Issue completeness

Problem: A bug report lands in your repo with no version number, no reproduction steps, and no expected versus actual behavior. You need that information before you can help.

Solution: Automatically detect incomplete issues and ask for the missing details.

name: Issue Completeness Check

on:
  issues:
    types: [opened]

permissions:
  issues: write
  models: read

jobs:
  check-completeness:
    runs-on: ubuntu-latest
    steps:
      - name: Check issue completeness
        uses: actions/ai-inference@v1
        id: ai
        with:
          prompt: |
            Analyze this GitHub issue for completeness. If missing reproduction steps, version info, or expected/actual behavior, respond with a friendly request for the missing info. If complete, say so.
            
            Title: ${{ github.event.issue.title }}
            Body: ${{ github.event.issue.body }}
          system-prompt: You are a helpful assistant that helps analyze GitHub issues for completeness.
          model: openai/gpt-4o-mini
          temperature: 0.2

      - name: Comment on issue
        if: steps.ai.outputs.response != ''
        uses: actions/github-script@v7
        with:
          script: |
            github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: ${{ github.event.issue.number }},
              body: `${{ steps.ai.outputs.response }}`
            })

The bot could respond: “Hi! Thanks for reporting this. To help us investigate, could you please provide: 1) Your Node.js version, 2) Steps to reproduce the issue, 3) What you expected to happen versus what actually happened?”

Or you can take it a step further and ensure the issue is following your contributing guidelines, like ben-balter/ai-community-moderator (MIT License).

Spam and “slop” detection

Problem: You check notifications and find multiple spam pull requests or low effort “fix typo” issues.

Solution: Use AI to flag suspicious or low quality contributions as they come in.

name: Contribution Quality Check

on:
  pull_request:
    types: [opened]
  issues:
    types: [opened]

permissions:
  pull-requests: write
  issues: write
  models: read

jobs:
  quality-check:
    runs-on: ubuntu-latest
    steps:
      - name: Detect spam or low-quality content
        uses: actions/ai-inference@v1
        id: ai
        with:
          prompt: |
            Is this GitHub ${{ github.event_name == 'issues' && 'issue' || 'pull request' }} spam, AI-generated slop, or low quality?
            
            Title: ${{ github.event.issue.title || github.event.pull_request.title }}
            Body: ${{ github.event.issue.body || github.event.pull_request.body }}
            
            Respond with one of: spam, ai-generated, needs-review, or ok
          system-prompt: You detect spam and low-quality contributions. Be conservative - only flag obvious spam or AI slop.
          model: openai/gpt-4o-mini
          temperature: 0.1

      - name: Apply label if needed
        if: steps.ai.outputs.response != 'ok'
        uses: actions/github-script@v7
        with:
          script: |
            const label = `${{ steps.ai.outputs.response }}`;
            const number = ${{ github.event.issue.number || github.event.pull_request.number }};
            
            if (label && label !== 'ok') {
              await github.rest.issues.addLabels({
                owner: context.repo.owner,
                repo: context.repo.repo,
                issue_number: number,
                labels: [label]
              });
            }

This workflow auto-screens new issues and new pull requests for spam/slop/low-quality, and auto labels them based on an LLM’s judgment.

Tip: If the repo doesn’t already have spam or needs-review labels, addLabels will create them with default styling. If you want custom colors or descriptions, pre-create them.

You can also check out these related projects: github/ai-assessment-comment-labeler (MIT license) and github/ai-moderator (MIT license).

Continuous resolver

Problem: Your repo has hundreds of open issues, many of them already fixed or outdated. Closing them manually would take hours.

Solution: Run a scheduled workflow that identifies resolved or no-longer-relevant issues and pull requests, and either comments with context or closes them.

name: Continuous AI Resolver


on:
  schedule:
    - cron: '0 0 * * 0' # Runs every Sunday at midnight UTC
  workflow_dispatch:


permissions:
  issues: write
  pull-requests: write


jobs:
  resolver:
    runs-on: ubuntu-latest
    steps:
      - name: Run resolver
        uses: ashleywolf/continuous-ai-resolver@main
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}

Note: The above code references an existing action in ashleywolf/continuous-ai-resolver (MIT license).

This makes it easier for contributors to find active, relevant work. By automatically identifying and addressing stale issues, you prevent the dreaded “issue pileup” that discourages new contributors and makes it harder to spot actual problems that need attention.

New contributor onboarding

Problem: A first time contributor opens a pull request, but they’ve missed key steps from your CONTRIBUTING.md.

Solution: Send them a friendly, AI-generated welcome message with links to guidelines and any helpful suggestions.

name: Welcome New Contributors

on:
  pull_request:
    types: [opened]

permissions:
  pull-requests: write
  models: read

jobs:
  welcome:
    runs-on: ubuntu-latest
    if: github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR'
    steps:
      - name: Generate welcome message
        uses: actions/ai-inference@v1
        id: ai
        with:
          prompt: |
            Write a friendly welcome message for a first-time contributor. Include:
            1. Thank them for their first PR
            2. Mention checking CONTRIBUTING.md
            3. Offer to help if they have questions
            
            Keep it brief and encouraging.
          model: openai/gpt-4o-mini
          temperature: 0.7

      - name: Post welcome comment
        uses: actions/github-script@v7
        with:
          script: |
            const message = `${{ steps.ai.outputs.response }}`;
            await github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: ${{ github.event.pull_request.number }},
              body: message
            });

This makes contributors feel welcome while setting them up for success by reducing rework and improving merge times.

Why these?

These examples hit the biggest pain points we hear from maintainers: triage, deduplication, spam handling, backlog cleanup, and onboarding. They’re quick to try, safe to run, and easy to tweak. Even one can save you hours per month.

Best practices 

• Start with one workflow and expand from there
• Keep maintainers in the loop until you trust the automation
• Customize prompts so the AI matches your project’s tone and style
• Monitor results and tweak as needed
• Avoid one size fits all automation, unreviewed changes, or anything that spams your contributors

Get started today

If you’re ready to experiment with AI:

1. Enable GitHub Models in your repository settings
2. Start with the playground to test prompts and models
3. Save working prompts as .prompt.yml files in your repo
4. Build your first action using the examples above
5. Share with the community — we’re all learning together!

The more we share what works, the better these tools will get. If you build something useful, add it to the Continuous AI Awesome List.

Written by

Ashley Wolf

@ashleywolf