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:
- https://github.com/facebook/react/issues/29900
- https://github.com/vercel/next.js/issues/54157
- https://github.com/microsoft/vscode/issues/204095
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.
Top comments (0)