How the Kanban board drives the workflow: card types, label taxonomy, and the AI-human collaboration protocol
The GitLab Kanban board at Board #2 uses six columns. Cards flow left to right as work progresses.
| Column | Label | Who Moves Cards Here | What It Means |
|---|---|---|---|
| Backlog | backlog | Human or AI | Unprioritized work. Not yet ready for processing. |
| Ready | ready | Human | Prioritized and approved. AI can pick this up. |
| In Progress | in-progress | AI | AI is actively working on this item. |
| Review | review | AI | Work is done, awaiting human review. |
| Blocked | blocked | AI or Human | Dependencies unresolved. Cannot proceed. |
| Done | done | AI | Work verified by AI. Human closes when satisfied. |
Only humans move cards to "Ready" (granting permission to work). AI moves cards through "In Progress" > "Review" > "Done". Only humans close issues (confirming satisfaction). This ensures humans always have the first and last word.
Not all board cards are the same. The system uses three distinct card types, each with different structures and workflows.
Actionable work items that flow through the CI/CD pipeline. Have acceptance criteria checkboxes that AI marks as completed. The most common card type.
Grey area choices requiring human input. Prefixed with "DECISION:" in the title. Options presented as checkboxes - human checks one, AI acts on the choice. Used for architecture decisions.
Reference cards. Not actionable. Prefixed with "INFO:" in the title. Collect documentation links, status summaries, or historical context in one place. Never assigned to anyone.
## Context Brief description of what needs to be done and why. ## Scope ### Included - Specific deliverable 1 - Specific deliverable 2 ### Excluded - What's explicitly NOT part of this work ## Acceptance Criteria - [ ] Criterion 1 is met - [ ] Criterion 2 is met - [ ] Tests pass ### Blockers (check when resolved) - [ ] Depends on issue #XY being complete ### Approval - [ ] Read comment ← Check if you have feedback for AI - [ ] Work complete and verified
## Context Why this decision matters and what's at stake. ## Options - [ ] A: First option with description - [ ] B: Second option with description - [ ] C: Third option with description - [ ] Other: See comment below ## AI Recommendation Option B is recommended because... ## ADR Link docs/adr/20260124-decision-topic.md ### Approval - [ ] Read comment - [ ] Decision confirmed
This is the most important human-AI communication mechanism on the board. Understanding it is essential.
Before doing ANY work on a card, the AI checks: is the "Read comment" checkbox checked? If yes, human has feedback. Read all comments, find human's latest, act on instructions, then UNCHECK the box.
1. AI completes work, moves card to "review" Card state: [ ] Read comment [x] Criterion 1 [x] Criterion 2 2. Human reviews, has feedback Human adds comment: "Please also handle the edge case where X" Human checks: [x] Read comment 3. AI picks up card, sees checked "Read comment" AI reads comments, finds human's latest AI acts on instruction: handles edge case X AI UNCHECKS: [ ] Read comment ← critical step (prevents infinite loop) AI moves card back to "review" 4. Human reviews again Satisfied? → Close the issue Not satisfied? → Add comment, check "Read comment" again (loop repeats)
If the AI doesn't uncheck "Read comment" after processing, it will read the same feedback again next time and enter an infinite loop. The uncheck signals "I've processed this feedback."
Labels are defined at the GitLab group level and inherited by all projects in the group. There are 27 labels across 5 categories.
| Label | Color | Purpose |
|---|---|---|
backlog | Gray | Unprioritized, waiting in queue |
ready | Green | Prioritized, AI can pick up |
in-progress | Amber | AI actively working |
review | Purple | Work done, awaiting human review |
blocked | Red | Cannot proceed, dependencies unresolved |
done | Gray | Verified by AI, awaiting human closure |
| Label | Purpose |
|---|---|
type::feature | New functionality |
type::bug | Something broken |
type::enhancement | Improvement to existing feature |
type::refactor | Code restructuring, no behavior change |
type::docs | Documentation only |
type::infrastructure | DevOps / infrastructure change |
| Label | Meaning |
|---|---|
priority::critical | Drop everything, fix now |
priority::high | Next in line after current work |
priority::medium | Normal priority |
priority::low | Nice to have, do when convenient |
| Label | Assigned Agent |
|---|---|
agent::pm | Project Manager (triage, clarification) |
agent::architect | System Designer (spec, planning) |
agent::developer | Implementer (code, deploy) |
agent::security | Security Auditor (scan, review) |
agent::qa | Quality Assurance (test, validate) |
| Label | Purpose |
|---|---|
needs-clarification | Issue is vague, questions posted |
spec-approved | Spec passed QA checklist |
ready-for-implementation | Tasks generated and validated |
needs-human-review | AI needs human input |
auto-generated | Issue was created by AI, not human |
decision-needed | DECISION card awaiting human choice |
The CI/CD project uses two separate label systems for different purposes. Understanding the distinction prevents confusion.
backlog, ready, in-progress, review, blocked, done
Simplified 6-column Kanban. Used for human task management on the GitLab board UI. Managed by the gitlab-board skill and /gitlab-board command.
status::triage, status::clarification, status::specification, ... status::done
Granular 11-stage tracking. Used internally by the CI/CD pipeline to track which stage an issue is in. Updated automatically by pipeline jobs.
An issue can have both in-progress (board label) and status::specification (pipeline label) at the same time. The board label shows "where it is in the overall workflow." The pipeline label shows "what stage it's currently processing in the CI/CD pipeline."
A key workflow innovation: AI agents can check their own acceptance criteria and move cards to "done" without waiting for human confirmation at every step.
AI Processing a Card (10-Step Protocol)
1. CLAIM: Move issue backlog/ready → in-progress
glab issue update {IID} --unlabel "ready" --label "in-progress"
2. READ: Parse issue body - understand requirements
3. CHECK: Is "Read comment" checked? If yes, process feedback first
4. BRANCH: Create feature branch (issue-{IID}-{short-desc})
5. EXECUTE: Do the actual work (code, config, docs)
6. COMMIT: Stage, commit with Co-Authored-By footer
7. PUSH: Push branch to remote, create MR if needed
8. UPDATE: Check acceptance criteria boxes as each is completed
Replace "- [ ]" with "- [x]" for each met criterion
9. APPROVE: If ALL criteria checked:
Check "Work complete and verified" box
Move to "done" (NOT closed)
Add completion comment summarizing what was done
10. REPORT: Inform user: "Work is in done column for your review"
AI self-approves to "done" but never closes the issue. Only humans close issues. This gives humans final say while still allowing AI to complete work autonomously. Think of it as: AI says "I believe I'm done" - human confirms or pushes back.
PHASE cards enable entire project execution to be driven from the board without CLI commands. They act as templates that spawn individual task cards when activated.
PHASE Card Format:
Title: PHASE 3: Pipeline Integration
## Phase Goal
Integrate specification workflow into the CI/CD pipeline stages.
## Tasks to Create When Activated
| Task | Title | Agent | Description |
|------|--------------------|-----------|--------------------------|
| T3.1 | Add spec templates | Developer | Create markdown templates |
| T3.2 | Map stage commands | Architect | Map pipeline stages |
| T3.3 | Test integration | QA | Validate end-to-end |
### Approval
- [ ] Read comment
- [ ] Phase tasks created
1. Human moves PHASE card to "ready" → 2. AI reads "Tasks to Create" table → 3. AI creates individual task cards for each row → 4. AI checks "Phase tasks created" → 5. PHASE card moves to "done" (becomes a tracker) → 6. Individual task cards go to backlog for normal processing.
The entire CI/CD project was built this way: PHASE cards for Phase 1 (Foundation), Phase 2 (Pipeline), Phase 3 (Integration), Phase 4 (Grey Areas). Each phase card spawned 5-10 task cards that were processed through the normal board workflow.
DECISION cards have a special flow because they require human choice before AI can act.
Step 1: AI or human creates DECISION card with options as checkboxes - [ ] A: Sequential pipeline (simpler, slower) - [ ] B: Parallel pipeline (faster, complex) - [ ] C: Hybrid approach - [ ] Other: See comment below Step 2: Human reviews options, checks ONE checkbox - [ ] A: Sequential pipeline - [x] B: Parallel pipeline ← human's choice - [ ] C: Hybrid approach Step 3: Human moves card to "ready" Step 4: AI scans board, finds DECISION in ready AI parses description, finds checked option = B AI adds confirmation comment AI removes decision-needed label AI moves to "done" and closes If "Other" is chosen: Human checks "Other: See comment below" Human adds comment explaining their custom choice AI reads the comment to understand the decision
The /gitlab-board skill provides quick commands for board management.
| Command | What It Does |
|---|---|
/gitlab-board cicd | Show board status: blocked items, ready items, in-progress, decision cards |
/gitlab-board cicd all | Process all columns: review → in-progress → ready |
/gitlab-board cicd 22 | Execute specific issue #22 |
/gitlab-board cicd 22,23,24 | Execute issues in specified order |
/gitlab-board cicd ready | Execute all items in the ready column |
/gitlab-board setup cicd | Create or fix board columns (idempotent) |
Labels are defined at the group level (e.g., "administrators"). When a new group is added (e.g., "developers"), labels need to be copied. The scripts/replicate-labels.sh script handles this.
./scripts/replicate-labels.sh [source_group] [target_group] # Default: administrators → developers What it does: 1. Looks up group IDs dynamically (not hardcoded) 2. Fetches all labels from source group via GitLab API 3. Creates each label in target group 4. Handles "already exists" gracefully 5. Reports final count: "Created 27 labels, 3 already existed"