The original phrasing is passive. This change uses more encouraging language ('ideal'), a contraction ('doesn't'), and simplifies the final clause for better readability and a more approachable tone.

```suggestion
The [<code>useLazyQuery</code>](../api/react/useLazyQuery) hook is ideal for manually executing queries. Unlike <code>useQuery</code>, <code>useLazyQuery</code> doesn't immediately execute its associated query. Instead, it returns a function that you call to execute the query.
```

This change reframes the sentence to be more reader-centric ('if you provide') and uses a contraction ('doesn't') to align with the approachable voice.

```suggestion
Unlike <code>useQuery</code>, if you provide options to <code>useLazyQuery</code> that change on re-renders, the hook doesn't automatically execute the query. Instead, <code>useLazyQuery</code> waits for you to call the execution function again before running the query with the updated options.
```

This revision uses contractions ('isn't'), favors the present tense ('use' instead of 'will be used'), and simplifies the sentence structure for better flow and readability.

```suggestion
The changed options are immediately applied to the underlying <code>ObservableQuery</code> (accessible via the <code>observable</code> property), even though the query isn't executed. This means other APIs, such as <code>refetch</code>, use the updated options even before you call the execution function again.
```

This phrasing is more direct and action-oriented, which is helpful for instructional content.

```suggestion
To change variables, call the execution function again with the new variables.
```

This revision is more reader-centric ('until you call') and avoids repeating the word 'called' for better readability.

```suggestion
The <code>variables</code> property is empty until you call the execution function for the first time. Use the <code>called</code> property from <code>useLazyQuery</code> to check if the execution function has run at least once.
```

The original sentence ending is slightly awkward. This change splits the sentence and rephrases the second part for improved clarity and flow.

```suggestion
In cases where you don't need to keep your component in sync with query state, use <code>client.query()</code> directly. This approach avoids unnecessary re-renders for data your component doesn't use.
```

Use contractions like 'isn't' to maintain an approachable tone.

```suggestion
Errors always cause the promise to reject. The <code>error</code> property isn't set when the promise resolves.
```

This revision is more reader-centric ('You can access') than the imperative 'Read', which is more suitable for explanatory text.

```suggestion
The promise resolves with an object that includes the error and any partial data from the query. You can access the partial data from the <code>data</code> property and the error from the <code>error</code> property.
```

This change simplifies the phrasing ('is instead set to' -> 'is') and uses a contraction ('isn't') for better readability.

```suggestion
<code>data</code> might be <code>undefined</code> instead of containing partial data. This typically happens when a [network error](./error-handling#network-errors) causes the query to fail, because the error isn't associated with GraphQL execution.
```

The original phrasing is slightly weak ('might find this undesirable'). This revision is more direct and clearly states the default behavior and the possibility of changing it.

```suggestion
By default, in-flight queries from <code>useLazyQuery</code> are aborted when their component unmounts, which rejects the promise. If you need the query to run to completion, you can change this behavior.
```

Using an imperative verb ('Call this method') is more direct and instructive for the reader.

```suggestion
The promise returned by the execution function includes a <code>.retain()</code> method. Call this method to ensure the query continues running even if the component unmounts.
```

This change makes the sentence more reader-centric ('you can shorten') and improves the logical flow by adding 'so'.

```suggestion
The <code>retain()</code> method returns the original promise, so you can shorten the previous example to a single line:
```