> ## Documentation Index
> Fetch the complete documentation index at: https://docs.gorules.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Natural language

> Read and edit rules as plain sentences - the same logic, rendered for business users.

Every rule in GoRules has two faces: the ZEN expression a developer writes, and a natural-language sentence anyone can read. They are the same stored logic - natural language is a display mode, not a translation step, so nothing can drift out of sync.

```
applicant.employment in ["EMPLOYED", "SELF_EMPLOYED"]
```

renders as:

> applicant.employment **is one of** Employed, Self-employed

## Switching modes

The **Developer mode** switch in the editor header controls the default for everything you open: business mode shows sentences, developer mode shows expressions. You can also flip an individual rule with the **Rule display: Code | Natural** toggle. The stored rule never changes - only how it's shown to you.

## How expressions become sentences

Operators map to phrases, and the phrasing adapts to the data type:

| Expression                     | Reads as                                    |
| ------------------------------ | ------------------------------------------- |
| `score >= 640`                 | score **is at least** 640                   |
| `startDate >= d('2026-01-01')` | startDate **is on or after** 1 January 2026 |
| `country in ["US", "CA"]`      | country **is one of** US, CA                |
| `amount in [100..500]`         | amount **is between** 100 **and** 500       |
| `tags contains "vip"`          | tags **contains** vip                       |
| `sum(items.price)`             | **the sum of** items.price                  |
| `fee ?? 0`                     | fee **or else** 0                           |

Note the date-awareness: `>=` reads "is at least" for numbers but "is on or after" for dates. Aggregations read as phrases too - "the average of", "the smallest of", "the number of items in".

## Dictionary labels

When a field is typed with a [dictionary](/learn/authoring/policies#dictionaries-shared-vocabulary), sentences use the labels, not the stored values: `terms in ["NET30", "NET60"]` reads "terms **is one of** Net 30 days, Net 60 days". Business users see the vocabulary they know; evaluation still compares the underlying values.

## Editing in natural language

Natural language is editable, not just readable:

* Values in a sentence are tokens you can click and change in place. Date and time tokens open a calendar and time picker, so "is on or after *1 March 2026*" is edited by picking a date, not by typing an ISO string.
* Dictionary-typed tokens offer their labelled options.
* If you rewrite a sentence in your own words, GoRules AI converts it back into a valid expression - and shows you the result, so the logic stays precise.

## When to use which mode

There's no wrong answer - the modes exist so each person works in the notation they're fastest in. Analysts review and edit rules as sentences; developers drop to code for complex expressions; both look at the same rules. A practical default: author precise logic in developer mode, review and demo in business mode.

<Tip>
  Natural language is only as readable as your vocabulary. Dictionaries and well-named fields do most of the work - "employment is one of Employed, Self-employed" reads well because the labels exist.
</Tip>