Skip to content

AI 驅動的 Idea-to-Ticket 工作流程

Version: 2026 年 10 月 18 日

呢篇係我 AI development workflow 系列嘅 第四篇文章。

閱讀次序係:

01. Multi-Agent AI Development Workflow
↓
02. Automated Multi-Agent Coding Workflow
↓
03. AI Coding Agent Role Design
↓
04. AI 驅動的 Idea-to-Ticket 工作流程 ← 本篇

閱讀次序同實際執行時嘅 workflow係刻意分開嘅。

頭三篇先建立 Multi-Agent development 嘅基本模型、將 coding pipeline 自動化,並解釋點解唔同 AI agent 會被分配唔同角色。

而呢一篇就將成個系統向 上游(upstream) 延伸,問一個唔同嘅問題:

喺一張 GitHub Issue 真正進入 coding workflow 之前,AI 可唔可以先幫我捕捉、整理、評估,甚至寫好張 ticket?

喺實際 runtime 入面,兩套 workflow 嘅關係係:

Idea / Research / Bug
↓
AI Idea-to-Ticket Workflow ← 本篇
↓
Approved GitHub Issue
↓
Automated Multi-Agent Coding Workflow
↓
Pull Request
↓
Human Review

兩邊嘅交接點就係 GitHub Issue。

至於下游 implementation pipeline,可以睇:

02. Automated Multi-Agent Coding Workflow

所以,呢一頁只集中處理 開始寫 code 之前 嘅工作:

  • 捕捉一個原始想法
  • 理解真正意圖
  • 將佢分類
  • 搜尋重複或相關工作
  • 判斷佢係 feature、bug、research task,定 experiment
  • 評估 priority
  • 產生一張結構化 ticket
  • 要求人手批准
  • 建立或更新 GitHub Issue
  • 將批准咗嘅 issue 交俾現有 coding workflow

呢篇會刻意 唔重複 前一篇已經詳細講過嘅 Codex → Claude Code → Cursor → Grok implementation pipeline。

  1. 點解要自動化 Ticket Creation?
  2. AI 唔應該一有 Idea 就即刻寫 Code
  3. 完整嘅 Intake Architecture
  4. Idea Inbox
  5. 第一步:理解個 Idea
  6. 開 Ticket 之前先分類
  7. 先檢查個 Idea 係咪已經存在
  8. 將 Research 同 Feature 分開
  9. AI 協助評估 Priority
  10. 建議嘅 Ticket 結構
  11. 使用結構化 AI Output
  12. 建立 GitHub Issue
  13. 用 GitHub Project 做工作隊列
  14. 交接去 Multi-Agent Coding Workflow
  15. Human Approval 同 Automation Boundaries
  16. 由簡單開始
  17. 建議嘅第一個 Experiment
  18. 最終目標

當一個 project 慢慢變大,developer 會由好多唔同地方收到新 idea:

  • 自己觀察到嘅問題
  • Bugs
  • User feedback
  • Research
  • Articles
  • AI conversations
  • 新 algorithms
  • Architecture ideas
  • Performance problems
  • Refactoring opportunities

真正困難嘅唔係產生 idea。

真正困難嘅係判斷:

呢個 idea 到底係乜?
之前有冇已經記錄過?
佢係一個 feature,定只係一個 research question?
我而家應唔應該做?
仲欠咩資料?
我要點樣測試佢係咪真係改善咗個 system?

如果每一個新 idea 一出現就即刻變成 code,project 好容易失去方向。

AI intake workflow 嘅作用,就係喺以下兩樣嘢中間加一層 buffer:

Thinking

同:

Building

2. AI 唔應該一有 Idea 就即刻寫 Code

Section titled “2. AI 唔應該一有 Idea 就即刻寫 Code”

其中一條最重要嘅規則係:

一個新 idea,唔代表佢自動就係一個新 feature。

例如,我喺開發 MarketLens 嘅時候,可能會發現幾種用嚟判斷整體大市趨勢嘅方法:

S&P 500 高於 50-day moving average
S&P 500 高於 200-day moving average
Market breadth
Advance / decline data
Follow-through days
VIX
Put / call ratio

如果冇一個 intake process,我好容易將以上七樣嘢全部變成七張獨立 development ticket。

但 AI 可能會發現,其實佢哋全部都只係同一個 research question 入面嘅唔同候選方法:

MarketLens 應該點樣判斷目前嘅 market regime?

與其即刻修改 production algorithm,AI 可以先開一張 research ticket:

Research:
Market Regime Detection

然後將以上唔同 signals 放入去做候選方案。

咁樣會容易管理好多。


第一個版本可以保持簡單。

IDEA / OBSERVATION
│
▼
┌─────────────────┐
│ AI Intake Agent │
└────────┬────────┘
│
▼
Understand Intent
│
▼
┌────────────────────────┐
│ Classification Agent │
└───────────┬────────────┘
│
┌──────────────────┼──────────────────┐
│ │ │
Feature Bug Research
│ │ │
└──────────────────┼──────────────────┘
│
▼
Duplicate / Context
Detection
│
▼
Priority Assessment
│
▼
Ticket Draft
│
▼
Human Review
│
┌────────┴────────┐
│ │
Approve Park
│
▼
GitHub Issue

一開始,其實可以由同一個 AI model 負責以上全部角色。

等個 workflow 真係變複雜之後,先再將唔同角色拆開。


所有 idea 最好都由同一個入口進入。

例如:

Capture MarketLens idea:
我最近研究緊用 market breadth,
再配合 S&P 500 嘅 50-day 同 200-day moving averages,
去判斷而家個整體市場環境係咪適合買入。

Developer 唔應該每一次都要自己手動決定:

應該用邊個 label?
屬於邊個 project?
Priority 應該係乜?
係邊種 ticket type?
Acceptance criteria 應該點寫?

以上嘅整理工作,可以交俾 AI intake process。

Developer 最主要只需要做一樣嘢:

將個 idea 表達出嚟。


AI 應該先將一個比較隨意、未整理嘅想法,轉化成一個清楚嘅 problem statement。

原始 input:

我諗緊係咪應該加 market breadth,
因為我見到有人用佢嚟避免喺大市弱嘅時候買股票。

AI interpretation:

Problem:
MarketLens 目前主要評估 individual stock signals,
但未有一個專門嘅 market-regime filter。
Hypothesis:
如果加入整體市場環境 filter,
可能可以減少弱市期間嘅 false-positive signals。

咁樣個 idea 已經容易評估好多。


唔係每一樣工作都屬於同一種類型。

一個簡單嘅 classification system 可以係:

FEATURE
BUG
RESEARCH
EXPERIMENT
DATA
ARCHITECTURE
REFACTOR
DOCUMENTATION

例如:

更換一個唔穩定嘅 market data source
→ DATA
加入 option strategy scanner
→ FEATURE
比較 SPY 50MA 同 market breadth
→ RESEARCH / EXPERIMENT
Ticker data 缺失時 scanner crash
→ BUG
引入 Kafka
→ ARCHITECTURE

分類好重要,因為唔同類型嘅 ticket 應該行唔同 workflow。

Bug 可能可以比較直接進入 implementation。

但一個 research idea,一般應該先測試,唔應該即刻變成 feature。


呢個係 AI 最有價值嘅工作之一。

開新 ticket 之前,workflow 應該先搜尋現有 issues。

例如,假設本身已經有:

Research: Market Regime Detection

之後我又輸入:

VIX 可能都可以幫我判斷目前市場係咪健康。

AI 唔應該再開另一張新 ticket。

反而應該回覆:

搵到相關 ticket:
Research: Market Regime Detection
建議:
將 VIX 加入現有 research ticket,
當成另一個 candidate signal。

個 workflow 就會變成:

New Idea
↓
Search Existing Issues
↓
Related Issue?
/ \
Yes No
│ │
Update Create
Existing New Ticket
Ticket

咁可以避免 backlog 最後變成幾百張非常碎片化嘅 tickets。


對 algorithmic project 嚟講,呢一點尤其重要。

假設我發現一個新嘅 stock-market indicator。

佢唔應該即刻變成:

FEATURE:
Add Indicator X

比較好嘅流程係:

RESEARCH
↓
Hypothesis
↓
Experiment
↓
Backtest
↓
Compare Against Baseline
↓
Decision

只有當個 experiment 真係有證據顯示有價值,先將佢升級成:

FEATURE

以 MarketLens 為例:

Research Ticket
Market Regime Detection
↓
Experiment
Baseline scanner
vs
Scanner + regime filter
↓
Measure
Win rate
Average return
Maximum drawdown
Signal count
↓
Decision
│
┌──┴──┐
│ │
Adopt Reject
│
▼
Feature Ticket

咁樣就可以清楚分開:

聽落幾有趣嘅 idea

同:

已經有證據證明值得加入 product 嘅功能。


AI 亦可以幫手估一個 idea 應該幾快去研究。

一個簡單 scoring model 可以包括:

Impact 1–5
Confidence 1–5
Effort 1–5
Urgency 1–5

例如:

ItemImpactConfidenceEffort建議位置
Reliable market data552Now
Market regime filter533Next
Options scanner535Later
Kafka architecture225Park
AI explanation layer334Later

個 score 唔應該自動決定最後做乜。

佢只係用嚟協助決策。

最後決定權仍然係人。


AI 應該用一個一致嘅格式去產生 tickets。

例如:

# Market Regime Detection
## Type
Research / Experiment
## Problem
目前 scanner 主要評估 individual stocks,
但未有明確將整體市場環境納入判斷。
## Hypothesis
加入 market-regime filter,
可能可以減少弱市期間質素較差嘅 signals。
## Candidate Signals
- SPY 50-day moving average
- SPY 200-day moving average
- Market breadth
- Advance / decline ratio
- Follow-through day
- VIX
## Data Required
- Daily SPY OHLCV
- Market breadth data
- Historical VIX data
## Experiment
比較:
1. Existing MarketLens baseline
2. Baseline + market-regime filter
## Metrics
- Win rate
- Average return
- Maximum drawdown
- Number of signals
- Risk-adjusted return
## Definition of Success
新 filter 應該改善 risk-adjusted performance,
同時唔應該刪走過多本來有效嘅 candidates。
## Priority
Next
## Status
Inbox

重點係:

我唔再需要每一次都自己由一個零散想法,手動整理成正式 engineering task。


當 workflow 開始自動化之後,free-form text 會比較難俾其他系統繼續處理。

所以 intake agent 可以改為輸出 structured output。

例如:

{
"title": "Research market regime detection",
"type": "research",
"project": "MarketLens",
"priority": "next",
"labels": [
"research",
"algorithm",
"market-regime"
],
"duplicate_of": null,
"problem": "The scanner does not currently include an overall market regime filter.",
"hypothesis": "A market regime filter may reduce poor-quality signals during weak markets.",
"requires_experiment": true,
"ready_for_development": false
}

之後 orchestrator 就可以根據呢啲 fields 決定下一步。


Ticket 經過 review 同批准之後,workflow 可以自動建立 issue。

概念上:

AI Ticket Draft
↓
Human Approval
↓
Structured JSON
↓
GitHub API / CLI
↓
GitHub Issue

最重要嘅 guardrail 係:

AI 可以自動幫手準備 ticket,但唔應該將每一個諗法都自動變成 development work。

建立 issue,同開始 implementation,係兩個唔同決定。


GitHub Issues 可以儲詳細內容。

GitHub Project 就可以用嚟代表整個工作 queue。

一個簡單 board 可以係:

Inbox
↓
Next
↓
Ready
↓
In Progress
↓
Testing
↓
Done

另外再加一個:

Parked

咁每一個 idea 都有地方放,而唔需要每一個 idea 都即刻打斷目前工作。

例如:

Stable Market Data
→ Ready
Market Regime Research
→ Next
Options Opportunity Scanner
→ Inbox
Kafka Migration
→ Parked

Backlog 由一堆容易令人分心嘅 idea,變成一個受控 queue。


呢度就係呢套 workflow 同我原本 automated multi-agent coding workflow 接軌嘅位置。

Ticket workflow 去到呢度就完成:

Idea
↓
AI Intake
↓
AI Triage
↓
Research / Analysis
↓
Approved GitHub Issue

而 coding workflow 就由呢度開始:

GitHub Issue
↓
AI Orchestrator
↓
Codex
↓
Claude Code
↓
Cursor
↓
Grok
↓
Pull Request

兩邊合埋:

HUMAN
│
▼
IDEA
│
▼
┌────────────────┐
│ AI Intake │
└───────┬────────┘
│
▼
Classify / Triage
│
▼
Duplicate Detection
│
▼
Priority Review
│
▼
GitHub Issue
│
─────────────┼─────────────
│
▼
┌────────────────┐
│ AI Orchestrator│
└───────┬────────┘
│
▼
Codex
│
▼
Claude Code
│
▼
Cursor
│
▼
Grok
│
┌─────┴─────┐
│ │
PASS FAIL
│ │
▼ ▼
Pull Request Fix Loop
│
▼
Human Review
│
▼
Merge

呢個做法填補咗之前 workflow 入面一個重要缺口。

以前 development workflow 係由:

Requirement

開始。

而家成個 system 可以再向前一步,幫我決定:

呢個 requirement 本身係點樣形成出嚟。


15. Human Approval 同 Automation Boundaries

Section titled “15. Human Approval 同 Automation Boundaries”

一個更自動化嘅 intake workflow,唔代表要移除 human judgment。

比較合理嘅分工係:

AI
↓
Capture
Classify
Search
Summarise
Draft
Recommend
↓
Human
↓
Approve
Reject
Park
Change Priority
Authorise Development

第一個版本入面,我會容許 intake workflow 做:

✓ 分析一個 idea
✓ 搜尋現有 tickets
✓ 建議 duplicates
✓ 將工作分類
✓ Draft ticket 內容
✓ 建議 labels
✓ 估算 effort
✓ 建議 priority
✓ 指出欠缺嘅資料
✓ 建議先 research 再 implementation

但對以下行為,我會更加保守:

✗ 自動開始 implementation
✗ 自動修改 production algorithms
✗ 刪除現有 tickets
✗ 冇證據就關閉 research questions
✗ 未經批准就改 roadmap priorities
✗ Merge code

一個實用嘅 approval boundary 可以係:

Raw Idea
↓
AI Triage
↓
Ticket Draft
↓
[Human Approval]
↓
GitHub Issue
↓
[Ready for Development?]
↓
Automated Multi-Agent Coding Workflow

Ticket system 同 coding system 應該保持分開。

咁可以避免一個一閃而過嘅 idea,立即變成 code change。


第一個版本完全唔需要再引入另一套大型 agent framework。

可以由:

Me
↓
ChatGPT
↓
Structured Ticket Draft
↓
Human Review
↓
GitHub Issue

開始。

下一步先變成:

Idea
↓
Intake Script
↓
LLM
↓
Search Existing GitHub Issues
↓
Structured JSON
↓
Human Approval
↓
Create / Update GitHub Issue

等以上 workflow 真係證明有用之後,先考慮更加 autonomous 嘅 product-management layer。

例如:

Idea
↓
AI Intake Agent
↓
Research / Classification
↓
Priority Agent
↓
GitHub Project
↓
Approved Issue
↓
Existing AI Coding Workflow

呢度同 coding workflow 一樣,都應該遵守同一個 design principle:

先由最細、真正有用嘅 automation 開始;只有當出現實際問題時,先增加複雜度。


對 MarketLens 嚟講,一個好適合嘅第一個 experiment 可以係:

Input:
「我想研究用 market breadth
同埋 S&P 500 trend
去改善 scanner。」

預期 AI output:

Type:
Research / Experiment
Related existing issue:
None
Priority:
Next
Development ready:
No
Recommended action:
Create research ticket
Required next step:
Define baseline and backtest metrics

之後個 system 應該產生一張完整 ticket draft。

但佢 唔應該 即刻修改 MarketLens algorithm。

經過 human approval 之後,先建立 GitHub Issue,再將佢放入適合嘅 project queue。

只有當張 issue 去到 Ready,先交俾 automated coding workflow。

所以,一個成功嘅第一版本,其實只需要證明以下條路行得通:

Raw Idea
↓
AI understands it
↓
AI creates a useful ticket
↓
Human approves it
↓
GitHub stores it
↓
Current work continues uninterrupted

我要解決嘅問題,唔係冇 idea。

而係:

太多 idea 會不停打斷而家已經進行緊嘅工作。

如果冇一個受控 intake process:

我有一個新 idea
↓
我停低而家做緊嘅嘢
↓
我開始寫佢
↓
又出現另一個 idea
↓
我又改方向

我想要嘅行為係:

我有一個新 idea
↓
Capture it
↓
AI 幫我整理
↓
Backlog 幫我記住
↓
目前 project 繼續
↓
到佢排到隊先再評估

完整 system 最後就會變成:

Ideas / Bugs / Research / Feedback
↓
AI Idea-to-Ticket Workflow
↓
Prioritised GitHub Issues
↓
Automated Multi-Agent Coding Workflow
↓
Pull Request
↓
Human Review
↓
Merge

所以,呢個系列嘅四篇文章其實分別處理唔同層次:

01 理解 multi-agent development
02 自動化 coding pipeline
03 理解 agent role design
04 自動化 idea intake 同 ticket pipeline

四篇合埋,就由:

用 AI 幫我寫 software

逐步變成:

設計一套 AI-assisted software development system,令一件工作由 idea、ticket、implementation,一路去到 review 都有清楚流程。

但最重要嘅 boundary 仍然係 human control。

AI 可以減少整理 idea、準備 engineering task 呢啲重複性工作,但最後仍然由我決定:

乜嘢值得做?
乜嘢值得研究?
乜嘢應該等?
乜嘢應該 reject?
一張 ticket 幾時先真正 ready for development?

呢個先係我想保留嘅角色。