_index.md

stage: none
group: unassigned
info: For assistance with this Style Guide page, see https://handbook.gitlab.com/handbook/product/ux/technical-writing/#assignments-to-other-projects-and-subjects.
description: Writing styles, markup, formatting, and other standards for GitLab Documentation.
title: Documentation Style Guide

This document defines the standards for GitLab documentation, including grammar, formatting, and more. For guidelines on specific words, see the word list.

The GitLab voice

The GitLab brand guidelines define the voice used by the larger organization.

Building on that guidance, the voice in the GitLab documentation strives to be concise, direct, and precise. The goal is to provide information that's easy to search and scan.

The voice in the documentation should be conversational but brief, friendly but succinct.

Documentation is the single source of truth (SSoT)

The GitLab documentation is the SSoT for all product information related to implementation, use, and troubleshooting. The documentation evolves continuously. It is updated with new products and features, and with improvements for clarity, accuracy, and completeness.

This policy prevents information silos, making it easier to find information about GitLab products. It also informs decisions about the kinds of content included in the documentation.

Topic types

GitLab uses topic types to organize the product documentation.

Topic types help users digest information more quickly. They also help address these issues:

• Content is hard to find. The GitLab documentation is comprehensive and includes a large amount of useful information. Topic types create repeatable patterns that make the content easier to scan and parse.
• Content is often written from the contributor's point of view. The GitLab documentation is written by a variety of contributors. Topic types (tasks, specifically) help put information into a format that is geared toward helping others, rather than documenting how a feature was implemented.

Docs-first methodology

The product documentation should be a complete and trusted resource.

• If the answer to a question exists in documentation, share the link to the documentation instead of rephrasing the information.
• When you encounter information that's not available in GitLab documentation, create a merge request (MR) to add the information to the documentation. Then share the MR to communicate the information.

The more we reflexively add information to the documentation, the more the documentation helps others efficiently accomplish tasks and solve problems.

Writing for localization

The GitLab documentation is not localized, but we follow guidelines that help us write for a global audience.

The GitLab voice dictates that we write clearly and directly with translation in mind. Our style guide, word list, and Vale rules ensure consistency in the documentation.

When documentation is translated into other languages, the meaning of each word must be clear. The increasing use of machine translation, GitLab Duo Chat, and other AI tools means that consistency is even more important.

The following rules can help documentation be translated more efficiently.

Avoid:

• Phrases that hide the subject like there is and there are.
• Ambiguous pronouns like it.
• Words that end in -ing.
• Words that can be confused with one another like since and because.
• Latin abbreviations like e.g. and i.e..
• Culture-specific references like kill two birds with one stone.

Use:

• Standard text for links.
• Lists and tables instead of complex sentences and paragraphs.
• Common abbreviations like AI and CI/CD and abbreviations you've previously spelled out.

Also, keep the following guidance in mind:

• Be consistent with feature names and how to interact with them.
• Break up noun strings. For example, instead of project integration custom settings, use custom settings for project integrations.
• Format dates and times consistently and for an international audience.
• Use illustrations, including screenshots, sparingly.
• For UI text, allow for up to 30% expansion and contraction in translation. To see how much a string expands or contracts in another language, paste the string into Google Translate and review the results. You can ask a colleague who speaks the language to verify if the translation is clear.

Markdown

All GitLab documentation is written in Markdown.

The documentation website uses the Hugo static site generator with its default Markdown engine, Goldmark.

Markdown formatting is tested by using markdownlint and Vale.

HTML in Markdown

Hard-coded HTML is valid, although it's discouraged for a few reasons:

• Custom markup has potential to break future site-wide changes or design system updates.
• Custom markup does not have test coverage to ensure consistency across the site.
• Custom markup might not be responsive or accessible.
• Custom markup might not adhere to Pajamas guidelines.
• HTML and CSS in Markdown do not render on /help.
• Hand-coding HTML can be error-prone. It's possible to break the page layout or other components with malformed HTML.

HTML is permitted if:

• There's no equivalent markup in Markdown.
• The content is reviewed and approved by a technical writer.
• There is an urgent need for the custom element that cannot wait for implementation by Technical Writing engineers.

If you have an idea or request for a new element that would be useful on the Docs site, please submit a feature request.

Heading levels in Markdown

Each documentation page must include a title attribute in its metadata. The title becomes the H1 element when rendered to HTML. Do not add an H1 heading in Markdown, as there can be only one per page.

• For each subsection, increment the heading level. In other words, increment the number of # characters in front of the topic title.
• Avoid heading levels greater than H5 (#####). If you need more than five heading levels, move the topics to a new page instead. Heading levels greater than H4 do not display in the right sidebar navigation.
• Do not skip a level. For example: ## > ####.
• Leave one blank line before and after the topic title.
• If you use code in topic titles, ensure the code is in backticks.
• Do not use bold text in topic titles.

Shortcodes

Shortcodes are snippets of template code that we can include in our Markdown content to display non-standard elements on a page, such as alert boxes or tabs.

GitLab documentation uses the following shortcodes:

• Alert boxes
  • Note
  • Warning
  • Flag
  • Disclaimer
  • Details
• Availability details
• Version history
• Icons
• Tabs

Language

GitLab documentation should be clear and easy to understand.

• Avoid unnecessary words.
• Be clear, concise, and stick to the goal of the topic.
• Write in US English with US grammar. (Tested in British.yml.)

Active voice

In most cases, text is easier to understand and to translate if you use active voice instead of passive.

For example, use:

• The developer writes code for the application.

Instead of:

• Application code is written by the developer.

Sometimes, using GitLab as the subject can be awkward. For example, GitLab exports the report. In this case, you can use passive voice instead. For example, The report is exported.

Customer perspective

Focus on the functionality and benefits that GitLab brings to customer, rather than what GitLab has created.

For example, use:

• Use merge requests to compare code in the source and target branches.

Instead of:

• GitLab allows you to compare code.
• GitLab created the ability to let you compare code.
• Merge requests let you compare code.

Words that indicate you are not writing from a customer perspective are allow and enable. Try instead to use you and to speak directly to the user.

Building trust

Product documentation should be focused on providing clear, concise information, without the addition of sales or marketing text.

• Do not use words like easily or simply.
• Do not use marketing phrases like "This feature will save you time and money."

Instead, focus on facts and achievable goals. Be specific. For example:

• The build time can decrease when you use this feature.
• You can use this feature to save time when you create a project. The API creates the file and you do not need to manually intervene.

Capitalization

As a company, we tend toward lowercase.

Topic titles

Use sentence case for topic titles. For example:

• # Use variables to configure pipelines
• ## Use the To-Do List

UI text

When referring to specific user interface text, like a button label, page, tab, or menu item, use the same capitalization that's displayed in the user interface.

If you think the user interface text contains style mistakes, create an issue or an MR to propose a change to the user interface text.

Feature names

Feature names should be lowercase.

However, in a few rare cases, features can be title case. These exceptions are:

• Added as a proper name to markdownlint, so they can be consistently applied across all documentation.
• Added to the word list.

If the term is not in the word list, ask a GitLab Technical Writer for advice. For assistance naming a feature and ensuring it meets GitLab standards, see the handbook.

Do not match the capitalization of terms or phrases on the Features page or features.yml by default.

Other terms

Capitalize names of:

• GitLab product tiers. For example, GitLab Free and GitLab Ultimate.
• Third-party organizations, software, and products. For example, Prometheus, Kubernetes, Git, and The Linux Foundation.
• Methods or methodologies. For example, Continuous Integration, Continuous Deployment, Scrum, and Agile.

Follow the capitalization style listed at the authoritative source for the entity, which may use non-standard case styles. For example: GitLab and npm.

Fake user information

You may need to include user information in entries such as a REST call or user profile. Do not use real user information or email addresses in GitLab documentation.

For text:

• Use diverse or non-gendered names with common surnames, like Sidney Jones, Zhang Wei, or Alex Garcia.
• Make fake email addresses end in example.com.

For screenshots:

• Temporarily edit the page before you take the screenshot:

  1. Right-click the text you want to change.
  2. Select Inspect.
  3. In the Elements dialog, edit the HTML to replace text that contains real user information with example data.
  4. Close the dialog. All of the user data in the web page should now be replaced with the example data you entered.
  5. Take the screenshot.

• Alternatively, you can create example accounts in a test environment, and take the screenshot there.

• If you can't easily reproduce the environment, you can blur the user data by using an image editing tool like Preview on macOS.

Fake URLs

When including sample URLs in the documentation, use:

• example.com when the domain name is generic.
• gitlab.example.com when referring only to GitLab Self-Managed. Use gitlab.com for GitLab.com.

Fake tokens

There may be times where a token is needed to demonstrate an API call using cURL or a variable used in CI. It is strongly advised not to use real tokens in documentation even if the probability of a token being exploited is low.

You can use these fake tokens as examples:

Token type	Token value
Personal access token	<your_access_token>
Application ID	2fcb195768c39e9a94cec2c2e32c59c0aad7a3365c10892e8116b5d83d4096b6
Application secret	04f294d1eaca42b8692017b426d53bbc8fe75f827734f0260710b83a556082df
CI/CD variable	Li8j-mLUVA3eZYjPfd_H
Project runner token	yrnZW46BrtBFqM7xDzE7dddd
Instance runner token	6Vk7ZsosqQyfreAxXTZr
Trigger token	be20d8dcc028677c931e04f3871a9b
Webhook secret token	6XhDroRcYPM5by_h-HLY
Health check token	Tu7BgjR9qeZTEyRzGG2P

Contractions

Contractions are encouraged, and can create a friendly and informal tone, especially in tutorials, instructional documentation, and user interfaces.

Some contractions, however, should be avoided:

Do not use a contraction	Example	Use instead
With a proper noun and a verb	Terraform's a helpful tool.	Terraform is a helpful tool.
To emphasize a negative	Don't install X with Y.	Do not install X with Y.
In reference documentation	Don't set a limit.	Do not set a limit.
In error messages	Requests to localhost aren't allowed.	Requests to localhost are not allowed.

Possessives

Try to avoid using possessives ('s) for proper nouns, like organization or product names.

For example, instead of Docker's CLI, use the Docker CLI.

For details, see the Google documentation style guide.

Prepositions

Use prepositions at the end of the sentence when needed. Dangling or stranded prepositions are fine. For example:

• You can leave the group you're a member of.
• Share the credentials with users you want to give access to.

These constructions are more casual than the alternatives:

• You can leave the group of which you're a member.
• Share the credentials with users to which you want to give access.

Acronyms

If you use an acronym, spell it out on first use on a page. You do not need to spell it out more than once on a page.

• Titles: Try to avoid acronyms in topic titles, especially if the acronym is not widely used.
• Plurals: Try not to make acronyms plural. For example, use YAML files, not YAMLs. If you must make an acronym plural, do not use an apostrophe. For example, use APIs, not API's.
• Possessives: Use caution when making an acronym possessive. If possible, write the sentence to avoid making the acronym possessive. If you must make the acronym possessive, consider spelling out the words.

Numbers

For numbers in text, spell out zero through nine and use numbers for 10 and greater. For more information, see the Microsoft Style Guide.

Text

• Write in Markdown.

• Insert an empty line for new paragraphs.

• Insert an empty line between different markups (for example, after every paragraph, heading, list, and so on). Example:

  ## Heading
  
  Paragraph.
  
  - List item 1
  - List item 2

Line length

To make the source content easy to read, and to more easily compare diffs, follow these best practices when possible.

• Split long lines at approximately 100 characters.
• Start each new sentence on a new line.

Comments

To embed comments within Markdown, use standard HTML comments that are not rendered when published. Example:

<!-- This is a comment that is not rendered -->

Punctuation

Follow these guidelines for punctuation.

• End full sentences with a period, including full sentences in tables.
• Use serial (Oxford) commas before the final and or or in a list of three or more items. (Tested in OxfordComma.yml.)

When spacing content:

• Use one space between sentences. (Use of more than one space is tested in SentenceSpacing.yml.)
• Do not use non-breaking spaces. Use standard spaces instead. (Tested in lint-doc.sh.)
• Do not use tabs for indentation. Use spaces instead. You can configure your code editor to output spaces instead of tabs when pressing the Tab key.

Do not use these punctuation characters:

• ; (semicolon): Use two sentences instead.
• – (en dash) or — (em dash): Use separate sentences, or commas, instead.
• “ ” ‘ ’: Double or single typographer's ("curly") quotation marks. Use straight quotes instead. (Tested in NonStandardQuotes.yml.)

Placeholder text

In a code block, you might want to provide a command or configuration that uses specific values.

In these cases, use < and > to call out where a reader must replace text with their own value.

For example:

cp <your_source_directory> <your_destination_directory>

If the placeholder is not in a code block, use < and > and wrap the placeholder in a single backtick. For example:

Select **Grant admin consent for `<application_name>`**.

Quotation marks

Only use quotation marks when quoting direct text, and use double quotes ("). For guidance about writing UI elements and in-line code, see Text formatting.

Do not put punctuation inside quotation marks, unless it is part of the quoted text.

Text formatting

When formatting text, use:

• Bold for UI elements and pages.
• Inline code style for inputs, outputs, code, and similar.
• Code blocks for command line examples, and multi-line inputs, outputs, code, and similar.
• <kbd> for keyboard commands.

Bold

Use bold for:

• UI elements with a visible label. Match the text and capitalization of the label.
• Navigation paths.

UI elements include:

• Buttons
• Checkboxes
• Settings
• Menus
• Pages
• Tabs

For example: