TechPrufer
Get started
GitLab
GitLab logoGitLab · Feature trail

Issue Tracking and Merge Request Workflow Integration

65 posts · Jun 2015 – May 2026

What this trail covers

GitLab's Agile planning capabilities are enhanced to support SAFe ceremonies by mapping SAFe concepts (Epic, Capability, Feature, User Story, Task, Team, Sprint, PI) to GitLab's work item hierarchy (Epics, Issues, Tasks) and organizational structure (Groups, Subgroups, Projects). This allows for end-to-end traceability from strategy to execution within a single DevSecOps platform. PI Planning is supported through Roadmap and Epic boards, Refinement via Epic boards and drawer views, Sprint Planni. The new epic experience introduces assignees, health status, time tracking, ancestry view, condensed descriptions, and custom colors for epics. It is built on a unified Work Items framework for consistency across epics, issues, and tasks, and future plans include templates, custom fields, configurable statuses, project-level epics, cloning, moving between groups/projects, and milestones.

All GitLab trails
  1. Transform MRs from manual tasks to an automated workflowThis post introduces significant enhancements to GitLab's Developer Flow, extending its capabilities beyond initial MR generation to cover the entire MR lifecycle. Key new features include an AI agent that can address reviewer feedback, resolve merge conflicts, research codebases, and split large MRs. It also introduces 'Resolve with Duo' for automated merge conflict resolution and 'One-click rebase and merge'. The underlying architecture is now a single agentic loop with a full developer toolset, and it utilizes `AGENTS.md` and `agent-config.yml` for project setup. These features are available on Premium and Ultimate tiers, with one-click rebase and merge available on Free tier as well.
  2. Fix bugs with Codex and GitLabThis post details the integration of Codex, an AI coding agent, with GitLab Duo Agent Platform and the Model Context Protocol (MCP) server. It demonstrates how Codex can be used to fix bugs locally by reading project code and `AGENTS.md` files, and then how it can leverage GitLab issues and MCP for richer context to implement changes aligned with requirements. The post also shows how GitLab's CI/CD and Duo Code Review take over after a merge request is created, and introduces the concept of external agents for addressing review feedback.
  3. Automate deployment processes with GitLab Duo Agent PlatformThis post details the creation and use of a custom AI agent within the GitLab Duo Agent Platform to automate the onboarding of new microservices into an existing GitOps workflow. The agent, configured with a system prompt generated by GitLab Duo, handles manifest generation, pipeline updates, and image automation. The process involves creating a new microservice, generating its initial code via another AI flow, and then using the custom agent to integrate it into the delivery and Flux configuration projects. The outcome is a significantly reduced time for onboarding complex setups.
  4. Claude Code and GitLab: Three workflows that shipThis post details the integration of Claude Code with GitLab's Model Context Protocol (MCP) to enhance the software development lifecycle. It demonstrates three workflows: 1) Fixing a C++ bug with Claude Code and then using GitLab CI/CD, security scanning, and Duo Code Review for the remaining stages. 2) Enhancing Claude Code's context by integrating the GitLab MCP Server to fetch issue details and directly create merge requests. 3) Using a Claude-powered external agent within Duo Agent Platform to address code review feedback. The post highlights how AI coding tools can accelerate code writing, while GitLab handles the subsequent stages of CI/CD, security, and review, creating an auditable trail for shipped changes.
  5. Agile planning gets a boost from new features in GitLab 18.10This post introduces the unified work items list and saved views as part of GitLab's Agile planning experience. The work items list combines epics, issues, and other work items into a single view, replacing separate list pages. Saved views allow users to store customized list configurations (filters, sort order, display options) for efficient and consistent team workflows. This is presented as a foundational step towards a more comprehensive planning experience with future capabilities like hierarchy views and consolidated Boards.
  7. Guide: Migrate from Azure DevOps to GitLabThis post details the process and tools for migrating from Azure DevOps to GitLab, focusing on migrating repositories, pipelines, and work items. It introduces GitLab's Congregate tool and built-in repository import for code migration, and outlines the mapping of Azure Pipelines to GitLab CI/CD and Azure Boards/work items to GitLab Issues, Epics, and Issue Boards. It also discusses planning considerations, organizational structure mapping, and the differences in permission models between the two platforms.
  8. Ace your planning without the context-switchingIntroduced GitLab Duo Planner, an AI agent built on the GitLab Duo Agent Platform, to automate and enhance software planning workflows. Duo Planner leverages work items (epics, issues, tasks) to assist with prioritization (RICE, MoSCoW, WSJF), work breakdown, dependency analysis, sprint planning, status reporting, and backlog management. It operates as a custom agent within the Duo Chat side panel, providing context-aware assistance.
  9. Vibe coding with GitLab Duo Agent Platform: 'Issue to MR' FlowThis post introduces the 'Issue to MR' agent Flow within the GitLab Duo Agent Platform. This Flow automates the process of turning a well-scoped issue into a draft merge request by analyzing the issue description, creating a development plan, and proposing an implementation. It streamlines application updates by reducing the need for manual code hunting, branching, and complex review processes. The post details the prerequisites, steps to use the Flow, and highlights benefits such as full project context, built-in security, interoperability, and scalability of collaboration.
  10. Embedded views: The future of work tracking in GitLabThis post introduces 'embedded views' powered by GitLab Query Language (GLQL). These views allow dynamic, real-time GLQL queries to be embedded directly within Markdown code blocks in various GitLab locations (wikis, epics, issues, merge requests, comments). Key features include always-up-to-date data on page load, contextual awareness using functions like `currentUser()` and `today()`, powerful filtering capabilities on over 30 fields, and customizable display options (table, list, numbered list) with control over displayed fields, limits, and sort order. The post details the syntax and provides examples of creating embedded views, highlighting their use in mission-critical processes at GitLab for tracking merge requests, triaging bugs, and managing planning. This extends the existing 'Issue Tracking and Merge Request Workflow Integration' by providing a dynamic, in-context data visualization layer for work items.
  11. Speed up code reviews: Let AI handle the feedback implementationThis post introduces the integration of GitLab Duo with Amazon Q, enabling an AI agent to automatically implement code changes based on reviewer comments in merge requests. Users can invoke this functionality using the `/q dev` quick action. The AI analyzes feedback, modifies the codebase, and presents the changes in the 'Changes' tab for review. This feature aims to reduce manual effort in addressing code review feedback, accelerate review cycles, and improve developer productivity by automating routine implementation tasks.
  12. SAFe without silos in GitLabThis post details how GitLab's existing Agile project management features can be mapped and utilized to support the Scaled Agile Framework (SAFe). It provides a direct mapping of SAFe terminology to GitLab's work item hierarchy (Epics, Issues, Tasks) and organizational structure (Groups, Subgroups, Projects). It outlines how specific SAFe ceremonies (PI Planning, Refinement, Sprint Planning, Daily Stand-ups, Sprint Review) can be facilitated using GitLab's built-in capabilities such as Roadmap view, Epic boards, Issue boards, iteration-scoped boards, burndown/burnup charts, and lead/cycle time metrics. The post also emphasizes the advantages of a unified platform for planning and development, and provides implementation principles and getting started steps.
  13. Automating Agile workflows with the gitlab-triage gemIntroduces the `gitlab-triage` gem, a Ruby library for automating Agile workflows by interacting with the GitLab API. Details installation, API token retrieval, defining triage policies in `.triage-policies.yml` (e.g., applying labels, commenting on old issues), and running the bot manually or via GitLab CI/CD schedules. Provides advanced examples using Ruby scripts for custom logic, such as identifying issues assigned to team members outside their project or automatically setting due dates. Offers best practices for policy creation and execution, emphasizing starting simple, testing, monitoring, and using labels for triages.
  14. Data-driven DevSecOps: Exploring GitLab Insights DashboardsThis post introduces the configuration of GitLab Insights Dashboards using `.gitlab/insights.yml` to create custom merge request analytics. It details how to leverage labels for squad and requirement type tracking, and provides YAML examples for creating stacked bar charts to visualize merge requests merged per week/month, filtered by squad and categorized by type. It also mentions using the GitLab API and CI for label automation.
  15. Seamlessly migrate from Jira to GitLab with Jira2Lab at scaleIntroduced Jira2Lab, a tool designed for large-scale Jira to GitLab migrations. Key features include efficient data handling for thousands of issues, attachments, and comments; automatic mapping of custom Jira workflows and fields to GitLab; integration of GitLab CI/CD pipelines into the migration process; support for pilot migrations; real-time monitoring and logs; and customizable migration options. The post also outlines a five-phase migration methodology (Discovery and Planning, Setup, Pilot Migrations, Scaled Migrations, Wrap-up and Post-Migration Support) and presents a case study of a successful large-scale migration.
  16. Tutorial: Integrate GitLab Merge Request approvals with external systemsThis post details the deployment of a demo application that integrates with GitLab's External Status Check feature. It outlines the steps to deploy the application to Kubernetes, configure it with a GitLab token, and set up the status check within a GitLab project. The application receives API calls from merge requests, stores them in a database, and provides an interface for external approval/rejection, which then updates the merge request status. Debugging tips for pod logs and database access are also provided.
  17. Unveiling a new epic experience for improved Agile planningThis post details the introduction of a new epic experience within GitLab's Agile planning capabilities. Key new features include assignees, health status, time tracking, ancestry view, condensed descriptions, and custom colors for epics. The underlying architecture is based on a unified Work Items framework, ensuring consistency across epics, issues, and tasks. Future planned features include templates, custom fields, configurable statuses, project-level epics, cloning, moving between groups/projects, and milestones.
  18. First look: The new Agile planning experience in GitLabThis post introduces the 'Work Items' framework as a foundational change to unify the experience of issues and epics, addressing inconsistencies like epics lacking assignees and issues not being supported at the group level. It details the introduction of 'Tasks' as the first iteration powered by this framework, providing net new value while rebuilding existing capabilities. Future plans include refreshed epics and issues experiences with assignees and health status, custom fields, and configurable statuses, along with updates to lists, boards, and roadmaps.
  19. Enhancing GitLab with improved data filtering and visualizationsThis post announces an initiative to improve data filtering and visualization within GitLab's planning views. It details the goal of consolidating multiple views into a single, configurable experience that allows for user-friendly complex queries and flexible data visualization. Real-world applications are described, such as reviewing progress of interconnected projects with nested issues/epics and switching to roadmap/board views, and development teams planning sprints using a single customized view for work item context, status updates, and dependency understanding. The post invites feedback on proposed feature iterations.
  20. Unlocking Agile excellence: GitLab Epics for seamless portfolio managementThis post introduces and details GitLab's multi-level epics feature, highlighting its advantages for Agile portfolio management. It explains how multi-level epics allow for hierarchical organization of work across multiple groups and projects, up to seven layers deep. The post emphasizes benefits such as flexible compatibility with Agile frameworks, granular work breakdown, real-time visibility and collaboration with automatic progress updates, and efficient cross-team planning. It positions multi-level epics as a key component for connecting strategy to execution within the GitLab DevSecOps platform.
  21. Beyond Devs: GitLab Enterprise Agile Planning add-on for all rolesIntroduces an Enterprise Agile Planning add-on for GitLab Ultimate subscriptions, allowing non-technical users (product managers, designers, marketing, sales) to participate in planning workflows, utilize Value Stream Analytics, and access executive dashboards. This extends the existing Agile planning capabilities to a broader audience within the DevSecOps platform.
  22. 5 reasons to simplify your agile planning tool configuration with GitLabThis post details how GitLab's agile planning capabilities simplify configuration by moving enforcement points closer to the work itself (e.g., merge request approvals, compliance pipelines) rather than relying on rigid, enforced status workflows within work items. It highlights how automation, such as GitLab triage, can improve data quality by deriving status from DevOps activity. The post also emphasizes the improved user experience through convention over configuration, simplified developer tool integration via APIs and webhooks, and reduced time spent on tool configuration, ultimately enabling greater team autonomy and faster innovation.
  23. Coordinating major documentation projects with GitLabThis post details how The Good Docs Project uses GitLab's project management features (milestones, scoped labels, health status, project boards) to schedule, plan, track, and execute major documentation releases. It specifically highlights the use of issues for task management, the migration of brainstormed ideas to GitLab, and the process of creating release tags and notes on release day. It also mentions the use of GitLab CI/CD for building artifacts.
  24. Self-managed support extended to GitLab for Jira AppThis post details the extension of support for the GitLab for Jira app to work with GitLab Self-Managed instances. It outlines the benefits of displaying GitLab development artifacts (merge requests, commits, pipelines, etc.) directly within the Jira Development Panel, linking commits to Jira issues, transitioning issues from commits, and using Smart Commits for time tracking. The post also provides configuration steps for self-managed GitLab and clarifies the deprecation of the DVCS integration for Jira Cloud in favor of the new app.
  25. Two DevOps platform superpowers: Visibility and actionabilityThis post details how a DevOps platform provides visibility and actionability through features like epics and issues for project tracking, labels for organization and search, dashboards for metrics, and value stream analytics for workflow efficiency. It highlights how these capabilities allow users to gain context and take immediate action on insights.
  26. GitLab Heroes Unmasked: How I am elevating my company using GitLabThis post details the migration of a bespoke helpdesk platform to GitLab for issue tracking, including the development of a custom migration tool using C# to push groups, issues, notes, attachments, time logs, and labels into GitLab via the API. It also describes the implementation of a helpdesk workflow using scoped labels and GitLab boards, and the automation of reactive and scheduled tasks using the GitLab Triage RubyGem and Triage Ops project. Additionally, it covers the development of a Customer Relations Management (CRM) feature, the challenges of instance-level vs. project-level functionality, the migration to Linux/Docker for CI/CD pipelines with custom .NET and Android/Gradle images, and the use of GitLab Pages with Hugo and the Relearn theme for an internal intranet, including a custom Ruby script to aggregate documentation from various GitLab projects.
  27. How GitLab automates engineering managementThis post details the creation and usage of three Ruby scripts (`issues_not_in_epics.rb`, `epic_summary.rb`, `epic_issue_relationships.rb`) that automate the generation of status reports and relationship diagrams for GitLab epics and issues. These scripts parse issue and epic data via the GitLab API to provide engineering managers with better visibility into project status, dependencies, and overall progress. The `epic_issue_relationships.rb` script specifically generates Mermaid diagrams to visualize issue dependencies.
  28. 5 Great Phabricator features that inspired GitLabThis post details how Phabricator's review workflows, draft states, and commit linking inspired similar features in GitLab. It explains the evolution of Draft MRs (formerly WIP MRs) and how commit history in GitLab is enriched with links to MRs for debugging. It also discusses the inspiration for code coverage reports in MRs, including inline remarks, and how Phabricator's Herald and Harbormaster influenced GitLab CI/CD and automated workflows. Finally, it draws parallels between Phabricator's work boards and GitLab's issue and epic boards, highlighting the drag-and-drop functionality for status changes.
  29. GitLab and Jira integration: the final stepsThis post details the final steps of the GitLab-Jira integration, focusing on how to leverage commit messages to transition Jira issues, view linked GitLab data in Jira's Dev Panel, and browse/search Jira issues within GitLab. It outlines the configuration steps for enabling Jira issue display in GitLab and provides URL parameter examples for filtering issues by labels, status, reporter, and assignee. It also includes troubleshooting tips for common integration issues.
  30. How to achieve a GitLab Jira integrationThis post details the step-by-step configuration of the GitLab-Jira integration, covering both Jira Server and Jira Cloud. It explains how to set up API tokens in Jira, configure service templates or individual project integrations in GitLab, and utilize trigger words (Resolves, Closes, Fixes) in commit messages to automatically transition Jira issues. It also describes how GitLab mentions in commits and merge requests create links and comments in Jira issues. The post also touches on the Jira DVCS configuration for self-managed and cloud instances.
  31. How to integrate GitLab.com with Jira CloudThis post details the configuration of the GitLab for Jira Cloud app, focusing on real-time data synchronization between GitLab.com and Jira Cloud. It outlines the steps to install the app from the Atlassian Marketplace, link GitLab namespaces, and leverage commit messages to automatically transition Jira issues and link GitLab events. It also addresses troubleshooting for cross-site cookie issues and notes limitations regarding relative URLs.
  32. GitLab: New Tool to Visualize High-Level Project TrendsThis post details the creation and usage of GitLab's 'Insights' feature, which visualizes project trends using labels. It explains the initial motivation for building the tool (analyzing bug creation times), its evolution to track MR throughput, and the importance of label hygiene. The post provides an example of the MR throughputs dashboard configuration in YAML and describes how the Support team uses a customized 'Bugs SLO' dashboard. It highlights the flexibility of configuring Insights at group or project levels and the benefits of version-controlling the YAML configuration.
  33. Using Gitlab APIs: Real Use Case ScenarioThis post details a specific use case for GitLab APIs and CI/CD to automate bulk project building tests across multiple repositories within a group. It outlines how to use the Issues API to create issues for failed builds, collect these issues using the Groups API, and report them to a project Wiki using the Wikis API. The technical details include example cURL commands for each API interaction, explanations of parameters, and the authentication methods required.
  34. 3 Major improvements coming to GitLab EpicsIntroduced the ability to create issues directly from epics, automatically relating them to the parent epic. Enhanced roadmap views to display issue weight and progress, providing immediate visibility into epic completion status. Enabled the expansion of epics on roadmaps to display their hierarchical structure, showing parent-child relationships.
  35. Shorter feedback loops compound value in developmentThis post introduces the concept of throughput accounting and its application to optimizing R&D and business outcomes. It details the transition from cost-based accounting to throughput accounting, highlighting the impact of inventory on ROI. The post also describes the development of an intelligent decision support framework using NLP to extract topics and sentiment from text-based data across sales, support, and R&D tools. This framework enables better prioritization of roadmap items and alignment across teams. It also advocates for a continuous innovation framework with lean sprints to validate assumptions and solutions.
  36. 2 Examples of how marketing uses GitLab to manage complex projectsThis post details how marketing teams use GitLab's issue tracking, epics, and labels for project management, specifically for the 'Just Commit' marketing campaign and product marketing projects. It highlights the use of ancestor and child epics for organizing campaign goals and action items, and the utilization of issue lists with DRIs and due dates to manage dependencies and timelines. It also explains the strategic use of issue boards, sorted by labels or assignees, to visualize work status and individual contributions.
  37. Moving workflows to GitLab: The case of the HIPAA Audit ProtocolThis post introduces a Python script utilizing the python-gitlab API to automate the creation of GitLab issues from a CSV file derived from the HIPAA Audit Protocol. It details how to map CSV columns to issue attributes like title, description, and labels, demonstrating a practical application of API-driven workflow automation for non-development use cases. The post also highlights the flexibility of the API over issue importers and suggests adapting the script for other workflows.
  38. Issue labels can now be scoped!Introduces Scoped Labels, a feature that allows mutually exclusive labels to be applied to issues, merge requests, or epics. This enables custom fields and workflow states, preventing conflicts and cleaning up issue lists. The feature accelerates delivery by allowing teams to define workflow steps and measure the flow of work. It is a paid feature available to Premium and Ultimate tiers for self-managed GitLab or Silver and Gold tiers for GitLab.com.
  39. How we use GitLab to automate our monthly retrospectivesThis post details the automation of monthly retrospective issue creation and updating using GitLab's scheduled pipelines and API. It describes using scheduled pipelines to create issues on the 1st of the month and update them on the 9th with lists of shipped and slipped issues. The automation uses the GitLab API with protected variables and quick actions for labels and due dates. The project 'async-retrospectives' is shared as an example of how this automation can be configured and adopted by other teams.
  40. How to work on two Git branches at the same timeThis post introduces a workflow for working on two Git branches simultaneously by using a local development environment for one branch and the GitLab Web IDE for another. It demonstrates how to manage separate development work and documentation in distinct merge requests to allow for independent shipping and accurate documentation.
  41. GitLab's 2019 product vision for DevOps CreateThis post outlines GitLab's 2019 product vision for the DevOps Create stage, focusing on improvements to source code management, collaboration, and code review. Key technical areas discussed include distributed merge requests for contributing to open source, improved forking workflows (branch comparison, cherry-picking, permission inheritance), API for line-by-line code quality feedback in merge requests, smarter diffs, proposed changes via comments, commit-by-commit code review, autosquashing, and commit message visibility. The Web IDE is also discussed with plans for client-side and server-side evaluation, web terminals, dark themes, Vim keybindings, and integration of merge request discussions.
  42. Coming in 11.3: Seamless planning with epics & roadmapIntroduced the concept of Epics and Roadmaps as distinct but related features for group-level planning. Epics are group-level issues for larger scopes, decomposable into project-level issues. Roadmaps visualize epics over time. Introduced the ability to assign fixed dates to epics for top-down planning and the dynamic linking of epic dates to the earliest/latest milestone dates of their attached issues for bottom-up planning, allowing seamless transition between planning methodologies.
  43. 4 ways to use GitLab Issue BoardsThis post details four ways to use GitLab Issue Boards: workflow tracking with labels, cross-functional planning with categories (labels), team visibility with assignee lists, and milestone planning. It explains how to configure issue boards by leveraging GitLab's issue tracking and label functionality to create different views and manage workflows. It also mentions the integration with milestones for Agile workflows.
  44. How the GitLab UX team uses epicsThis post details how the GitLab UX team adopted and utilized epics for planning and tracking UX efforts. It explains the concept of epics at GitLab as a collection of issues with a shared theme, enabling efficient management of a portfolio of projects. The team developed a UX strategy template to define challenges, vision, focus areas, mission, activities, and success metrics for epics. The merge request page was used as a case study, demonstrating how existing issues were matched to research findings and organized within an epic. Future enhancements like sub-epics, labeling, discussions, project-level epics, and integration with roadmaps are also mentioned.
  45. A VS Code extension for GitLab: GitLab WorkflowThis post introduces the GitLab Workflow VS Code extension, detailing its development and features. It enables users to view assigned issues and merge requests, check pipeline status, open files and MRs on GitLab.com, create snippets, compare branches with master, and validate `.gitlab-ci.yml` files directly from within VS Code. The extension aims to reduce context switching and boost developer productivity.
  46. An Agile approach to documentation and structureThis post details the use of GitLab's project management features (issues, milestones, issue boards) and Markdown for organizing project documentation and tracking progress for a new application, UnscrewMe. It describes setting up a 'Group' with three repositories for documentation, the web application, and a pre-launch website, and outlines a flexible folder structure for organizing content.
  47. How to automatically create a new MR on GitLab with GitLab CIIntroduced a script that leverages GitLab CI and the GitLab API to automatically create a 'WIP' merge request for a new commit if one doesn't already exist for that branch. The script identifies the default branch, checks for existing open merge requests for the source branch, and if none are found, creates a new merge request assigned to the committer with `remove_source_branch` enabled.
  48. The evolution of the GitLab Issue BoardThis post details the evolution of the GitLab Issue Board from its initial release in 8.11 to its state in 9.0. Key developments include the introduction of multiple issue boards, an improved search and filter interface, the addition of milestones for organizing issues into cycles, and the ability to reorder issues within lists via drag-and-drop. The post highlights the iterative development approach used to build these features.
  49. Migrating your JIRA issues to GitLabThis post details a method for migrating JIRA issues to GitLab issues using REST APIs. It outlines the necessary API calls for both JIRA (fetching issues, attachments, and comments) and GitLab (searching users and creating issues). It also describes the mapping of JIRA fields to GitLab issue fields, including handling user assignments and comments. The post provides code snippets using `axios` for demonstration.
  50. GitLab 2016 year in reviewThis post details the introduction of Merge Conflict Resolution into the GitLab web interface, allowing users to resolve simple conflicts directly from GitLab. It also introduces Merge Request Discussion Resolution, enabling comments and discussions on merge request diffs to be resolved individually or in threads, preventing feedback from being missed.
  51. Customer Story: Data startup Cognitive Logic talks migrating to GitLabThis post details Cognitive Logic's use of GitLab's validated merge request system for code quality and the GitLab Docker registry for build artifacts. It also highlights a desire for improved CI orchestration between repositories, with a mention of existing functionality and ongoing development to address this.
  52. Track your time in the same tool you do your workIntroduced Time Tracking functionality to GitLab Enterprise Edition (available for free on GitLab.com during beta). This feature allows users to record time spent on tasks and set time estimates directly within issues and merge requests using `/spend` and `/estimate` slash commands. Multiple `/spend` commands aggregate into a total time spent visible in the sidebar, while the last `/estimate` command overrides previous ones. This aims to reduce reliance on external time tracking tools.
  53. Resolving Merge Conflicts from the GitLab UIIntroduced the ability to resolve merge conflicts directly within the GitLab UI. This feature allows users to fix conflicts without needing to check out branches locally. The implementation supports text-based conflicts and provides an editor for manual resolution. Future plans include support for binary files and renames.
  54. Feature Highlight: Designing Issue BoardsIntroduced the concept and design principles for a new Issue Board feature, distinct from the existing Milestone Board. The new board aims to provide a more visual overview of issues, support multi-step workflows, and leverage existing metadata like labels for sorting and filtering. It details the proposal, feedback received (including concerns about using labels as lists and assigning multiple list labels), and the collaborative refinement process leading to the draggable card interface with default lists and search functionality. The post also outlines future plans for multiple and group-level boards.
  55. Announcing The GitLab Issue BoardIntroduced the GitLab Issue Board, a new project management tool integrated with GitLab Issues and Labels. The Issue Board visualizes the development process using lists (columns) based on labels, allowing drag-and-drop functionality for issues (cards) to move between stages. It automatically updates issue labels and closes issues when moved to a 'Done' list. The feature aims to improve planning, organization, and visualization of team workflows, building upon existing issue tracking.
  56. Applying GitLab Labels AutomaticallyThis post details the implementation of a webhook server using Ruby and Webrick to automatically apply labels to GitLab merge requests. It describes how to process merge request events, extract commit messages to determine Semver increments (patch, minor, major), and use the GitLab API to update merge request labels. It also provides pro-tips on handling updates and threading the server for reliability.
  57. Using GitLab LabelsThis post details how a team adopted GitLab labels to organize their infrastructure-as-code workflow. It explains the purpose of labels for directing focus and workflow, lists 11 adopted labels with their descriptions and automatic application status, and describes how these labels are used in the merge request process to indicate status like 'Needs Review', 'Blocked', and 'Ready to Deploy'. The post highlights how this system improved the ability to quickly identify MRs needing attention.
  58. Feature Highlight: Set Due Dates for Issues and Create MilestonesIntroduced the ability to set due dates for individual issues and create group-level milestones that can encompass issues from multiple projects. This enhances project timeline visibility and management by allowing users to assign specific deadlines to issues and group related tasks across different projects under a single milestone.
  59. Feature highlight: Move issues between projectsThis post details the technical implementation of moving issues between projects. It addresses the challenge of updating cross-project references (issues, merge requests, snippets, labels, commits) within issue descriptions and comments. The solution involves a Regexp-based approach to identify local references, substitute them with cross-project references, and then verify the substitution by comparing HTML output before and after the change. This approach was chosen for its speed of implementation over a more complex AST-based Markdown parser.
  60. Feature Highlight: Subscribe to LabelIntroduced the 'Subscribe to Label' feature, allowing users to receive notifications for issues and merge requests tagged with specific labels. This feature enhances issue tracking by enabling users to filter notifications based on relevant labels, improving focus on specific areas like performance.
  61. Feature Highlight: Confidential issuesIntroduced the concept of confidential issues, allowing issues to be marked as private and visible only to project members and assignees. This feature aims to simplify the reporting and handling of security vulnerabilities by eliminating the need for separate internal issue trackers. The development process involved managing merge conflicts due to the feature's security-sensitive nature and the long duration of the merge request.
  62. Tutorial: It's all connected in GitLabThis post details how to leverage cross-referencing within GitLab issues, merge requests, and commits to link related work. It explains the syntax for referencing issues (`#123`), MRs (`!123`), and snippets (`$123`). It also highlights the automatic closing of issues when a merge request description includes 'Closes #ID' or 'Fixes #ID'. The post emphasizes the role of issues as the single source of truth and the use of labels and milestones for organization.
  63. Feature Highlight: TodosIntroduced the 'Todos' feature, which aggregates notifications for assigned issues, merge requests, and @mentions into a single list. This feature reuses the existing Activity feed system and leverages Rails' ActiveModel::Dirty API to track attribute changes on issues and merge requests. It automatically marks todos as 'Done' when the user takes action on the associated issue or merge request, or when the issue/merge request is closed/merged by the user. The implementation also includes logic to handle changes in associations like labels and assignee_id.
  64. Feature Highlight: Create files and directories from the Files pageIntroduced the ability to create new files, upload files, create new directories, create new branches, and create new tags directly from the project's files page. This includes UI elements for these actions and the option to start a new merge request when committing changes.
  65. Making GitLab Better for Large Open Source ProjectsThis post details GitLab's existing and planned features for improving issue tracking and merge request workflows, specifically addressing the challenges of missing crucial information in bug reports, content-less comments, and adherence to contribution guidelines. It highlights the implementation of issue templates, the exploration of custom required fields, and the existing voting system for issues. It also mentions the ability to configure custom contributing files and the use of fast-forward merges or automatic rebasing for merge requests.
  66. Feature Highlight: WIPIntroduces the concept of 'Work In Progress' (WIP) merge requests by prepending 'WIP' or '[WIP]' to the merge request title. This prevents accidental merging of unfinished features while still allowing for code review and CI checks. Encourages a 'WIP mentality' of opening merge requests early to solicit feedback from colleagues, even on unfinished code, to catch potential mistakes and gain direction.
  67. Feature Highlight: Merge Request ApprovalsIntroduced Merge Request Approvals in GitLab Enterprise Edition, allowing users to set a required number of approvals before a merge request can be merged. This feature supports assigning specific approvers and setting default approvers for projects. Additionally, an option to automatically reset approvals after a new push to the merge request was added.
  68. Feature Highlight: Approve Merge RequestIntroduced Merge Request Approvals in GitLab EE 7.12, allowing users to set a required number of approvals from different people before a merge request can be merged through the UI. This feature adds an 'Approve' button to merge requests and enables merging once the required approvals are met.