GitLab Boards & Labels

How the Kanban board drives the workflow: card types, label taxonomy, and the AI-human collaboration protocol

The Six-Column Board

The GitLab Kanban board at Board #2 uses six columns. Cards flow left to right as work progresses.

Backlog
Add rollback metrics
INFO: Phase 3 summary
Ready
Fix deploy timeout
DECISION: SAST tool
In Progress
Matrix notifications v2
Review
Runner isolation test
Blocked
Deploy prod gate
Done
Label replication
DECISION: Pilot scope
ColumnLabelWho Moves Cards HereWhat It Means
BacklogbacklogHuman or AIUnprioritized work. Not yet ready for processing.
ReadyreadyHumanPrioritized and approved. AI can pick this up.
In Progressin-progressAIAI is actively working on this item.
ReviewreviewAIWork is done, awaiting human review.
BlockedblockedAI or HumanDependencies unresolved. Cannot proceed.
DonedoneAIWork verified by AI. Human closes when satisfied.

Key principle: Humans control entry, AI controls flow, humans control exit

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.

Three Card Types

Not all board cards are the same. The system uses three distinct card types, each with different structures and workflows.

FEATURE / BUG / ENHANCEMENT

Actionable work items that flow through the CI/CD pipeline. Have acceptance criteria checkboxes that AI marks as completed. The most common card type.

DECISION

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.

INFO

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.

FEATURE Card Structure

## 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

DECISION Card Structure

## 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

The "Read Comment" Protocol

This is the most important human-AI communication mechanism on the board. Understanding it is essential.

Mandatory first step for every card

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.

How the feedback loop works

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)

Why uncheck is critical

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."

Complete Label Taxonomy

Labels are defined at the GitLab group level and inherited by all projects in the group. There are 27 labels across 5 categories.

Board State Labels (pick one)

LabelColorPurpose
backlogGrayUnprioritized, waiting in queue
readyGreenPrioritized, AI can pick up
in-progressAmberAI actively working
reviewPurpleWork done, awaiting human review
blockedRedCannot proceed, dependencies unresolved
doneGrayVerified by AI, awaiting human closure

Type Labels (pick one)

LabelPurpose
type::featureNew functionality
type::bugSomething broken
type::enhancementImprovement to existing feature
type::refactorCode restructuring, no behavior change
type::docsDocumentation only
type::infrastructureDevOps / infrastructure change

Priority Labels (pick one)

LabelMeaning
priority::criticalDrop everything, fix now
priority::highNext in line after current work
priority::mediumNormal priority
priority::lowNice to have, do when convenient

Agent Labels (optional)

LabelAssigned Agent
agent::pmProject Manager (triage, clarification)
agent::architectSystem Designer (spec, planning)
agent::developerImplementer (code, deploy)
agent::securitySecurity Auditor (scan, review)
agent::qaQuality Assurance (test, validate)

Workflow Labels (situational)

LabelPurpose
needs-clarificationIssue is vague, questions posted
spec-approvedSpec passed QA checklist
ready-for-implementationTasks generated and validated
needs-human-reviewAI needs human input
auto-generatedIssue was created by AI, not human
decision-neededDECISION card awaiting human choice

Two Label Systems (Don't Confuse Them)

The CI/CD project uses two separate label systems for different purposes. Understanding the distinction prevents confusion.

Board Labels (gitlab-board skill)

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.

Pipeline Status Labels (CI/CD stages)

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.

They coexist, not conflict

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."

AI Self-Approval Pattern

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"

Why "done" but not "closed"?

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: Board-Driven Execution

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

Activation Flow

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.

Board-driven workflow in practice

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 Card Processing

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

Board Commands Reference

The /gitlab-board skill provides quick commands for board management.

CommandWhat It Does
/gitlab-board cicdShow board status: blocked items, ready items, in-progress, decision cards
/gitlab-board cicd allProcess all columns: review → in-progress → ready
/gitlab-board cicd 22Execute specific issue #22
/gitlab-board cicd 22,23,24Execute issues in specified order
/gitlab-board cicd readyExecute all items in the ready column
/gitlab-board setup cicdCreate or fix board columns (idempotent)

Label Replication Across Groups

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"