---
title: Word choice
description: Recommendations for choosing the right words in your documentation.
url: https://docs-v3-preview.elastic.dev/elastic/docs-content/pull/4236/contribute-docs/style-guide/word-choice
---

# Word choice
Find the right term to use in your technical documentation. Apply this guidance as follows:
- **Preferred**:  This term is recommended.
- **Use with caution**:  This term might be ambiguous.
  Make sure you are using the term correctly.
- **Avoid**: This term might be offensive or non-inclusive.
  Whenever possible, use the alternate suggestion, or a more specific term.

<tip>
  Use the [Vale linter](https://docs-v3-preview.elastic.dev/elastic/docs-content/pull/4236/contribute-docs/vale-linter) to check for style issues while writing documentation. Vale automatically flags common style guide violations, so you can catch and fix issues before publishing.
</tip>

---


| Word                                   | Status              | Usage notes                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|----------------------------------------|---------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| **abort**abort                         | 🔴 Avoid            | This word can be offensive. Use _shut down,_shut down, _cancel,_cancel, or _stop_stop instead.                                                                                                                                                                                                                                                                                                                                                                           |
| **above**above                         | 🟠 Use with caution | Don't use to refer to a postion. Directional language does not meet accessibility requirements.                                                                                                                                                                                                                                                                                                                                                                          |
| **add**add                             | 🟢 Preferred        | Use for establishing a new relationship.  Often used in create-then-add scenarios: _Create a dashboard, then add a visualization_Create a dashboard, then add a visualization. _Remove_Remove is the correct opposite.                                                                                                                                                                                                                                                   |
| **app**app, **application**application | 🟠 Use with caution | Use only when needed for clarity.  Otherwise, a Kibana app name can stand alone.  _App_App is a well-known abbreviation for _application_application and is preferred.                                                                                                                                                                                                                                                                                                   |
| **begin**begin                         | 🟠 Use with caution | Similar to _start_start, using _begin_begin depends on the context. _Begin a procedure,_Begin a procedure, _begin an analysis,_begin an analysis, or _begin an installation_begin an installation are common phrases. Similarly, _start a program,_start a program, _start an engine,_start an engine, or _start a timer_start a timer are frequently used.  _Start_Start is considered less formal than _begin_begin. _End_End is the correct opposite of _begin_begin. |
| **below**below                         | 🟠 Use with caution | Don't use to refer to a position. Directional language does not meet accessibility requirements.                                                                                                                                                                                                                                                                                                                                                                         |
| **blacklist**blacklist                 | 🔴 Avoid            | This word has roots in racism. Use _blocklist_blocklist instead.                                                                                                                                                                                                                                                                                                                                                                                                         |
| **boot**boot                           | 🔴 Avoid            | Use _start_start or _run_run instead.                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| **can**can                             | 🟢 Preferred        | Use to convey permission.                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| **cancel**cancel                       | 🟢 Preferred        | Use to stop an action without saving pending changes.                                                                                                                                                                                                                                                                                                                                                                                                                    |
| **cannot**cannot, **can't**can't       | 🟢 Preferred        | Use to indicate you don't have the ability to do something.  Often confused with _unable_unable.                                                                                                                                                                                                                                                                                                                                                                         |
| **choose**choose                       | 🔴 Avoid            | Use _select_select instead.                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| **click**click                         | 🟠 Use with caution | OK when describing mouse actions. Otherwise, use verbs that work with multiple devices, such as _select_select.                                                                                                                                                                                                                                                                                                                                                          |
| **clone**clone                         | 🟠 Use with caution | Use when creating a copy that is linked to the original. Often confused with _copy_copy and _duplicate_duplicate.                                                                                                                                                                                                                                                                                                                                                        |
| **copy**copy                           | 🟠 Use with caution | Use when creating an exact copy in the same location as the original. Often confused with _clone_clone and _duplicate_duplicate.                                                                                                                                                                                                                                                                                                                                         |
| **could**could                         | 🔴 Avoid            | Replace with _can_can or _might_might whenever possible.                                                                                                                                                                                                                                                                                                                                                                                                                 |
| **create**create                       | 🟢 Preferred        | Use for creating an object from scratch Not _create new_create new.  _Delete_Delete is the correct opposite.                                                                                                                                                                                                                                                                                                                                                             |
| **delete**delete                       | 🟢 Preferred        | Use when deleting data that users can no longer retrieve.  _Create_Create is the correct opposite.                                                                                                                                                                                                                                                                                                                                                                       |
| **disable**disable                     | 🟠 Use with caution | Don't use to describe something that is broken. Use _inactive_inactive, _unavailable_unavailable, _deactivate_deactivate, _turn off_turn off, or _deselect_deselect, depending on the context.                                                                                                                                                                                                                                                                           |
| **duplicate**duplicate                 | 🟠 Use with caution | Use when creating a copy of an object in the same location as the original.  Often confused with _copy_copy and _clone_clone.                                                                                                                                                                                                                                                                                                                                            |
| **easy**easy, **easily**easily         | 🔴 Avoid            | It can be frustrating for users to think that something is easy, but then struggle to do the task. Typically the same meaning can be conveyed without this word.                                                                                                                                                                                                                                                                                                         |
| **edit**edit                           | 🟢 Preferred        | Not _change_change or _modify_modify. Edit is the better choice for localization.                                                                                                                                                                                                                                                                                                                                                                                        |
| **e.g.**e.g.                           | 🔴 Avoid            | Don't use Latin abbreviations. Use _for example_for example or _such as_such as instead.                                                                                                                                                                                                                                                                                                                                                                                 |
| **enable**enable                       | 🟢 Preferred        | Use when turning on or activating an option or a feature.                                                                                                                                                                                                                                                                                                                                                                                                                |
| **enter**enter                         | 🟢 Preferred        | Use to refer to the user entering text. Not _type_type.                                                                                                                                                                                                                                                                                                                                                                                                                  |
| **execute**execute                     | 🔴 Avoid            | Use _run_run or _start_start instead.                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| **hack**hack                           | 🔴 Avoid            | For a noun, use _tip_tip or _work-around_work-around instead. For a verb, use _configure_configure or _modify_modify.                                                                                                                                                                                                                                                                                                                                                    |
| **hit**hit                             | 🔴 Avoid            | For a noun, use _visits_visits (as in web visits). For a verb, use _click_click or _press_press.                                                                                                                                                                                                                                                                                                                                                                         |
| **i.e.**i.e.                           | 🔴 Avoid            | Don't use Latin abbreviations.                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| **invalid**invalid                     | 🔴 Avoid            | Use _not valid_not valid or _incorrect_incorrect instead.                                                                                                                                                                                                                                                                                                                                                                                                                |
| **kill**kill                           | 🟠 Use with caution | Use _cancel_cancel or _stop_stop unless the actual command is `kill`.                                                                                                                                                                                                                                                                                                                                                                                                    |
| **launch**launch                       | 🔴 Avoid            | Use _open_open instead.                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| **may**may                             | 🟠 Use with caution | Use _may_may for permissibility. Use _can_can for capability. Use _might_might for possibility.                                                                                                                                                                                                                                                                                                                                                                          |
| **open**open                           | 🟢 Preferred        | Use instead of _launch_launch.                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| **please**please                       | 🔴 Avoid            | In most cases, _please_please is unnecessary. Exceptions are situations where the user must wait or do something inconvenient. Or, if the text sounds too abrupt without it.                                                                                                                                                                                                                                                                                             |
| **remove**remove                       | 🟢 Preferred        | Use when removing a relationship, but not permanently deleting the data. For example, you remove a visualization from a dashboard. _Add_Add is the correct opposite.                                                                                                                                                                                                                                                                                                     |
| **select**select                       | 🟢 Preferred        | _Select_Select is preferred over _choose_choose.                                                                                                                                                                                                                                                                                                                                                                                                                         |
| **simple**simple, **simply**simply     | 🔴 Avoid            | Often used before a before a verb like _select_select, but doesn't add any information or value. Implies that users should have been able to do such a simple task without assistance.                                                                                                                                                                                                                                                                                   |
| **start**start                         | 🟠 Use with caution | _Start_Start and _begin_begin depend on the context. _Start a program,_Start a program, _start an engine,_start an engine, or _start a timer_start a timer are common phrases. Similarly, _begin a procedure,_begin a procedure, _begin an analysis,_begin an analysis, or _begin an installation_begin an installation are frequently used.  _Start_Start is considered less formal than _begin_begin.                                                                  |
| **terminate**terminate                 | 🔴 Avoid            | Use _stop_stop or _exit_exit instead.                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| **type**type                           | 🔴 Avoid            | Use _enter_enter because there is typically more than one way to enter text than typing.                                                                                                                                                                                                                                                                                                                                                                                 |
| **unable**unable                       | 🟠 Use with caution | _Unable_Unable means not being able to perform an action. Often confused with cannot.                                                                                                                                                                                                                                                                                                                                                                                    |
| **utilize**utilize                     | 🟠 Use with caution | Don't use _utilize_utilize when you mean _use_use.                                                                                                                                                                                                                                                                                                                                                                                                                       |
| **view**view                           | 🟢 Preferred        | Preferred over _see_see because _view_view is more inclusive.                                                                                                                                                                                                                                                                                                                                                                                                            |
| **whitelist**whitelist                 | 🔴 Avoid            | Use _allowlist_allowlist instead.                                                                                                                                                                                                                                                                                                                                                                                                                                        |