Avoid, Finish, Keep, and Stop Doing

By the end of this lesson, you will be able to...

• Use avoid doing, finish doing, keep doing, and stop doing in short technical sentences.

• Explain how each verb changes the status of the second action.

• Rewrite incident and pull request notes so risky, completed, continued, and stopped actions are clear.

Idea in one sentence: After avoid, finish, keep, and stop, use doing because the second action is the thing being avoided, completed, continued, or stopped.

Core Insight

The first two lessons built the main contrast:

We discussed splitting the table.   -> action as object
We agreed to split the table.       -> action as goal

This lesson makes the doing side more practical.

In engineering work, you often need to say that a team avoided a risky action, finished a piece of work, kept a temporary behavior running, or stopped a harmful behavior.

We should avoid logging secrets.
We finished backfilling the table.
We kept retrying the job for ten minutes.
We stopped sending duplicate emails.

In all four sentences, the second action is not the next goal. It is the thing affected by the first verb.

That is why the pattern is:

avoid doing
finish doing
keep doing
stop doing

The grammar is small. The meaning is not. These verbs tell the reader whether an action was prevented, completed, continued, or ended.

The Small Situation

A team is debugging an incident.

The payment worker is retrying failed jobs. Some jobs are safe to retry. One path is not safe because it may log a token into an application log.

Someone writes this update:

We should avoid to log secrets while the worker retries failed jobs.

The reader can probably guess the meaning. But the sentence is not natural, and the relation between the two actions is cloudy.

The team is not planning to log secrets.

The team wants to prevent that action.

So the natural sentence is:

We should avoid logging secrets while the worker retries failed jobs.

Now the risk is visible:

logging secrets = the risky action to avoid

This is the same doing idea from lesson 001, but with a more urgent job. The action is the object of avoid.

The Naive Idea

The naive idea is:

If an action is in the future or has not happened, use `to do`.

That idea is tempting here because avoiding often talks about something that has not happened.

But English does not choose the pattern only from time.

It chooses the pattern from the first verb.

Compare:

Goal:
We need to log more context.

Risk to prevent:
We should avoid logging secrets.

Both sentences may talk about future behavior. The grammar is different because the relation is different.

Need points toward a required action.

Avoid points away from a risky action.

That is the model:

to do = action as goal
doing = action as object

In this lesson, the first verb tells you what happens to the action object.

The Four Verbs

Each verb gives the doing action a different status.

The second action behaves like an object:

avoid what?   -> logging secrets
finish what?  -> backfilling the table
keep what?    -> retrying the job
stop what?    -> sending duplicate emails

That question is often enough to repair a sentence.

Awkward:
We stopped to send duplicate emails.

Natural for ending the action:
We stopped sending duplicate emails.

Be careful: stop to send can be grammatical in a different meaning. It means someone stopped another activity in order to send something.

The operator stopped to send a status update.

That sentence means the operator paused what they were doing and sent an update.

But in an incident note, if the system was sending duplicate emails and then ended that behavior, use:

The system stopped sending duplicate emails.

The difference is not decorative. It changes the incident timeline.

A Worked Incident Note

Here is a rough incident update:

We avoided to log secrets. We kept to retry the failed jobs for ten minutes. We stopped to send duplicate emails after disabling the webhook. We finished to backfill the table at 14:20.

The intended meaning is useful. The pattern is wrong in four places.

Classify each first verb:

Now rewrite:

We avoided logging secrets.
We kept retrying the failed jobs for ten minutes.
We stopped sending duplicate emails after disabling the webhook.
We finished backfilling the table at 14:20.

This version gives the reader a clearer incident story:

1. A risky action was prevented.
2. A temporary retry behavior continued.
3. A harmful behavior ended.
4. A recovery task completed.

Input:

literal `to` phrases after avoid, keep, stop, finish

Transition:

identify what each first verb does to the second action

Intermediate state:

the second action is the object of avoid, keep, stop, or finish

Output:

avoid logging, keep retrying, stop sending, finish backfilling

Naive failure contrast:

`stopped to send duplicate emails` can sound like someone paused in order to send emails.
`stopped sending duplicate emails` says the duplicate-email behavior ended.

What Each Verb Helps You Say

Avoid Doing

Use avoid doing when the action is a risk or mistake you want to prevent.

We should avoid logging secrets.
We avoided changing production during the incident.
The migration avoids locking the table for more than a few seconds.

This pattern is useful in security, reliability, and data work because it names harm before it happens.

It also pairs well with a reason:

We should avoid logging secrets because logs are copied to the support workspace.

The useful question is:

What bad action do we want to prevent?

If the answer is an action, avoid doing is a strong candidate.

avoid logging secrets
avoid changing production
avoid dropping the column
avoid restarting the worker

This does not mean the team is afraid of all change. It means this specific action is unsafe under the current condition.

Finish Doing

Use finish doing when the action is complete.

We finished backfilling the table.
The worker finished processing the delayed jobs.
The script finished copying the missing rows.

This is useful in status updates because it separates completed work from planned work.

Compare:

We plan to backfill the table.
We finished backfilling the table.

The first points forward. The second reports completion.

The useful question is:

What work is now complete?

If the answer is an action, finish doing is natural.

finish backfilling
finish copying rows
finish draining the queue
finish validating the migration

Completion claims are easy to overstate. Add the object or scope when it matters:

Too broad:
We finished backfilling.

Clearer:
We finished backfilling the events table in staging.

Keep Doing

Use keep doing when an action continues.

We kept retrying the failed jobs.
The cache kept serving stale responses.
The alert kept firing after the deploy.

This pattern can describe intentional continuity:

We kept monitoring the queue during the rollout.

It can also describe an unwanted behavior:

The worker kept retrying jobs that could never succeed.

The context tells the reader whether continuing is good or bad.

The useful question is:

What action continued?

If the action continued because the team chose it, say the reason:

We kept monitoring the queue because the backlog was still falling.

If the action continued because the system was stuck, say the signal:

The worker kept retrying because the downstream API kept returning 503.

Keep doing is often stronger when it includes a time limit or signal:

We kept retrying for ten minutes.
The alert kept firing until the cache was cleared.

Stop Doing

Use stop doing when an action ends.

We stopped sending duplicate emails.
The worker stopped retrying after the queue was drained.
The dashboard stopped showing the error spike.

This pattern is important in incident writing because it marks a change in behavior.

It does not always mean the system is fixed. It only says that one action ended.

The worker stopped retrying.

Maybe the issue is fixed. Maybe the worker crashed. The sentence needs evidence if the cause matters:

The worker stopped retrying after we disabled the webhook.

The useful question is:

What action ended?

The answer may be a system behavior:

The worker stopped retrying.
The API stopped returning 500s.
The dashboard stopped showing the spike.

Or it may be a team action:

We stopped rolling out the change.
We stopped deleting old cache keys.

Do not let stopped quietly imply fixed.

Careful:
The alert stopped firing.

Clearer:
The alert stopped firing after we raised the threshold, but user errors are still elevated.

The first sentence says one signal ended. The second sentence says what changed and what risk remains.

Choosing the Verb in a Status Update

When you write a short update, choose the first verb before you worry about the second pattern.

Ask what you need the reader to know:

This is a writing decision, not only a grammar decision.

For example:

The worker kept retrying invalid jobs.

This sentence points to a continuing behavior.

If the important fact is that the behavior ended, choose a different first verb:

The worker stopped retrying invalid jobs after we patched the validation check.

If the important fact is that the team prevented the behavior before it reached production, choose another:

We avoided retrying invalid jobs in production by blocking them in staging.

The doing phrase stays similar. The first verb changes the engineering meaning.

Trade-offs and Limits

The trade-off is compactness versus ambiguity.

These patterns are compact:

avoid logging
finish backfilling
keep retrying
stop sending

They make status updates short and useful. But they can hide important conditions if the reader needs operational detail.

Too thin:
We stopped sending duplicate emails.

Better:
We stopped sending duplicate emails after disabling the webhook.

The pattern also does not tell the reader whether the action was good or bad by itself.

We kept retrying the job.

That could be good if retries are expected and bounded. It could be bad if retries are causing load or duplicate side effects.

You can see the boundary when a sentence needs a reason, limit, or signal:

We kept retrying the job for ten minutes, then stopped because the downstream API returned 401.

Now the reader sees both the action and the decision.

Common Confusions

Confusion: Stop doing and stop to do mean the same thing

Why it is tempting:

Both phrases contain stop and an action.

Better model:

Stop doing ends the action. Stop to do pauses another activity in order to do the action.

Ended the action:
We stopped sending duplicate emails.

Paused for a purpose:
We stopped to send a status update.

In technical incident notes, the first pattern is usually what you need when a system behavior ended.

Confusion: Keep doing is always positive

Why it is tempting:

Keep can sound intentional and controlled.

Better model:

Keep doing only says the action continued. The rest of the sentence says whether that was useful or harmful.

Useful:
We kept monitoring the queue during the rollout.

Harmful:
The worker kept retrying requests with invalid tokens.

Check Your Understanding

Check: Which sentence means the duplicate-email behavior ended?

A. We stopped sending duplicate emails. B. We stopped to send duplicate emails.

Think first, then reveal.

Answer: A. Stopped sending means the sending ended. Stopped to send means someone paused another activity in order to send emails.

Check: In We should avoid logging secrets, what is the risky action?

Think first, then reveal.

Answer: logging secrets. The first verb is avoid, and the second action is the risk to prevent.

Practice

Rewrite each literal sentence into natural technical English.

1. We should avoid to log secrets.
2. The worker kept to retry failed jobs.
3. We stopped to send duplicate emails after disabling the webhook.
4. The script finished to copy the missing rows.

Model answers:

We should avoid logging secrets.
The worker kept retrying failed jobs.
We stopped sending duplicate emails after disabling the webhook.
The script finished copying the missing rows.

Now choose the verb that matches the engineering meaning.

Risk to prevent:
avoid logging secrets

Completed recovery work:
finish backfilling the table

Temporary behavior continued:
keep retrying the job

Harmful behavior ended:
stop sending duplicate emails

Daily Practice Lines

We should avoid logging secrets.
We finished backfilling the table.
The worker stopped sending duplicate emails.

Spaced review from earlier lessons:

We discussed splitting the table.
We agreed to split the table.

Small variation:

Change one technical action, but keep the first verb honest.

logging secrets -> changing production -> dropping the column -> restarting the worker

Example:

We should avoid changing production during the incident.
We should avoid dropping the column before the backup is verified.
We should avoid restarting the worker while it is processing payments.

What To Carry Forward

You now have a small repair tool for many status updates.

Ask:

What did we avoid, finish, keep, or stop?

If the answer is another action, use doing.

avoid logging
finish backfilling
keep retrying
stop sending

The next lesson returns to the to do side with need, want, plan, and decide. Together, lessons 001-004 will give you the first practical map:

action as object -> doing
action as goal   -> to do

A useful daily habit is to read one sentence from left to right and stop at the first verb.

We avoided...
The worker kept...
The script finished...
The alert stopped...

Before you finish the sentence, predict the shape:

probably doing

That tiny pause trains the pattern without a rule table. It also helps you catch translated sentences before they land in a pull request, incident note, or status update.

Small repeated corrections are the point. You are building a reflex for common engineering verbs, one sentence at a time, in real team communication today.

Resources

• [ARTICLE] Cambridge Dictionary Grammar: Verb patterns - Use it as a reference for verbs that commonly take -ing or to.
• [ARTICLE] Cambridge Dictionary Grammar: -ing forms - Notice how -ing forms can behave like nouns in a sentence.
• [ARTICLE] Microsoft Writing Style Guide - Use it for clear, reader-friendly technical sentences, not for grammar drilling.

Key Takeaways

• Use avoid doing for a risky action you want to prevent.
• Use finish doing for completed work.
• Use keep doing for an action that continues.
• Use stop doing for an action that ends.
• Be careful with stop doing versus stop to do; they mean different things.