Building DevTriage: An AI-Powered GitHub Issue Triage Assistant with Dify and EdgeOne

Bnguyen003 — Wed, 27 May 2026 16:43:10 +0000

Building DevTriage: An AI-Powered GitHub Issue Triage Assistant with Dify and EdgeOne

Open-source maintainers spend a surprising amount of time reviewing GitHub issues manually.

Reading bug reports, understanding issue context, assigning labels, estimating severity, and identifying possible root causes can quickly become repetitive and time-consuming — especially for fast-growing repositories.

I wanted to explore whether AI workflows could simplify this process while also experimenting with edge-native deployment infrastructure.

So I built DevTriage — an AI-powered GitHub issue triage assistant using Dify and EdgeOne.

The workflow is simple:

Paste a GitHub issue URL → instantly receive structured AI-powered analysis.

This project was created for the Dify × EdgeOne Best Practices Contest.

What is DevTriage?

DevTriage is a lightweight AI developer tool that analyzes public GitHub issues and generates:

AI-powered issue summaries
Severity estimation
Suggested labels
Root cause hints

Instead of manually reading through long issue threads, developers can quickly understand the problem and prioritize faster.

The goal was not to build another generic chatbot.

I wanted to build a focused developer productivity tool with:

Lightweight architecture
Fast interaction flow
Practical use case
Real-world developer workflow

Why I Built This

Most AI demos today focus heavily on chat interfaces.

I wanted to create something more practical and developer-oriented:

A tool maintainers could actually use
Minimal frontend complexity
Edge-native deployment
Fast AI workflow iteration

GitHub issue triage felt like a perfect use case because:

It is repetitive
It consumes developer time
It benefits from structured summarization
It works well with LLM reasoning

Tech Stack

DevTriage uses a very lightweight stack:

Dify Workflow
EdgeOne Pages
EdgeOne Edge Functions
HTML / CSS / JavaScript

I intentionally avoided large frontend frameworks because the interaction flow itself is simple and speed-focused.

System Architecture

The overall architecture is intentionally minimal:
flowchart TD
A[Frontend HTML/CSS/JS] --> B[EdgeOne Edge Functions]
B --> C[Dify Workflow API]
C --> D[AI GitHub Issue Analysis]
The frontend sends the GitHub issue URL to an Edge Function.

The Edge Function securely communicates with the Dify Workflow API while keeping the API key hidden from the client.

The Dify workflow processes the issue and returns structured AI analysis results.

Architecture

Building the AI Workflow with Dify

The Dify workflow receives a GitHub issue URL and performs several reasoning steps:

Extracting issue context
Understanding bug descriptions
Detecting severity indicators
Suggesting GitHub labels
Identifying possible root causes
Generating concise summaries

One thing I particularly liked about Dify was how quickly workflows could be tested and refined.

Instead of constantly rebuilding backend logic, I could directly iterate prompts and workflow steps inside the Dify editor.

This made experimentation extremely fast.

Dify Workflow

Example GitHub Issues for Testing

Here are several public GitHub issues that work well with DevTriage:

These examples contain enough technical detail for the AI workflow to generate meaningful analysis.

Frontend Design Decisions

I intentionally kept the UI minimal and developer-oriented.

The interface includes:

A single issue input field
Example issue shortcuts
Loading states
Markdown-rendered AI responses
Lightweight dark-mode styling

The goal was to make the experience feel more like a focused developer utility rather than a generic AI chatbot.

I wanted users to:

Paste a link
Click Analyze
Get immediate value

without unnecessary complexity.

Live Application

Deploying with EdgeOne

One of the most interesting parts of this project was deployment.

I deployed DevTriage using:

EdgeOne Pages
EdgeOne Edge Functions

The deployment flow looks like this:
flowchart LR
A[GitHub Repository] --> B[EdgeOne Pages]
B --> C[Edge Functions]
C --> D[Global Production Deployment]
Deployment was surprisingly straightforward:

Push the project to GitHub
Import the repository into EdgeOne Pages
Configure deployment settings
Add environment variables
Deploy globally

The application was online within minutes.

EdgeOne Deployment

Edge Functions and API Security

One important architectural decision was keeping the Dify API key secure.

Instead of exposing the API key in the frontend:

Frontend requests are sent to Edge Functions
Edge Functions securely call Dify
API keys remain protected server-side

This architecture also creates a cleaner separation between frontend logic and AI workflow orchestration.

Runtime Challenges During Deployment

During deployment, I encountered an issue related to environment variables inside Edge Functions.

Initially, I used:process.env.DIFY_API_KEY
However, Edge runtimes behave differently from traditional Node.js environments.
The correct implementation was:context.env.DIFY_API_KEY
After updating the runtime handling, the deployment worked correctly.
This was a useful reminder that edge-native runtimes and traditional server runtimes are not always interchangeable.

Why Dify + EdgeOne Worked Well Together

One thing I appreciated during development was how naturally Dify and EdgeOne complemented each other.

Dify made AI workflow iteration extremely fast:

Prompt tuning
Workflow experimentation
Structured AI outputs
Rapid testing

Meanwhile, EdgeOne simplified deployment and edge execution:

GitHub integration
Global deployment
Edge Functions
Lightweight infrastructure management

This combination allowed me to move from idea to production deployment very quickly without managing traditional backend infrastructure.

For lightweight AI-native tools, this workflow felt surprisingly efficient.

Example User Flow

User pastes a GitHub issue URL
Frontend sends request to Edge Function
Edge Function securely calls Dify Workflow API
AI workflow analyzes the issue
Structured results are returned instantly

The entire experience feels lightweight and responsive.

Live Demo

Demo URL

https://devtriage-dify.edgeone.dev

GitHub Repository

https://github.com/Bnguyen003/devtriage-dify

What I Learned

This project reinforced several ideas for me:

AI workflows can become practical products very quickly
Edge deployment significantly simplifies infrastructure
Lightweight architectures are often enough for AI-native tools
Developer-focused AI tools do not require overly complex interfaces

I also realized how effective Dify is for rapidly prototyping production-ready AI workflows.

Future Improvements

Some features I would like to explore next:

GitHub OAuth integration
Automatic issue labeling
Repository-wide analytics
Multi-language support
Team collaboration workflows
Historical issue trend analysis

Final Thoughts

Building DevTriage with Dify and EdgeOne was a genuinely smooth experience.

Dify made workflow iteration fast and flexible, while EdgeOne simplified deployment and edge execution.

For developers interested in building lightweight AI-native tools, this combination is definitely worth exploring.

This project also reminded me that practical AI applications do not always require massive complexity.

Sometimes a focused workflow and a clean deployment pipeline are enough to create something genuinely useful.

Thanks for reading.

DEV Community: Bnguyen003

Building DevTriage: An AI-Powered GitHub Issue Triage Assistant with Dify and EdgeOne

Building DevTriage: An AI-Powered GitHub Issue Triage Assistant with Dify and EdgeOne

What is DevTriage?

Why I Built This

Tech Stack

System Architecture

Architecture

Building the AI Workflow with Dify

Dify Workflow

Example GitHub Issues for Testing

Frontend Design Decisions

Live Application

Deploying with EdgeOne

EdgeOne Deployment

Edge Functions and API Security

Runtime Challenges During Deployment

Why Dify + EdgeOne Worked Well Together

Example User Flow

Live Demo

Demo URL

GitHub Repository

What I Learned

Future Improvements

Final Thoughts