Tech verbs, collocations and phrasal verbs

“I gave a review and did a rollback” is understood, but it tells a team that the writer is new to its English: the team says “I reviewed the PR and rolled back the change”. One sprint week of tickets, chats and stand-ups, checked below, used 21 pairs of a verb and a noun like these, and a meeting summary from the same week used 11 phrasal verbs and idioms that a reader of a second language may take word by word.

This lesson teaches the verbs teams pair with code, releases and incidents, the verbs whose meaning is exact, such as deprecate, and the phrasal verbs and idioms to understand in meetings and replace in writing. It ends with the Agile words of the Scrum Guide, used as the guide defines them.

Code, releases and incidents have their own verbs

Oxford’s learner’s dictionary defines a collocationcollocation: Words that go together far more often than chance would predict, such as cut a release or file a bug. Using the usual pair makes a sentence sound natural to the team. as words that go together “more frequently than would happen by chance”. Teams have their own: you open or raise a pull request, file a bug, cut a release, ship a feature and page the on-call engineer. Use another verb and the reader still understands you, but has to translate. Follow one change from a pull request to every user:

The program marks the pairs of a list in one sprint week of messages. Press Edit and add your team’s own pairs to PAIRS, or paste a message of yours into TEXTS:

// One sprint week told in a ticket, a chat thread and a stand-up, with the verb and noun pairs teams use for code,
// releases and incidents marked in [brackets]. The pairs are MySmartCoPilot's list; add the ones your team uses.

const PAIRS = [
  'open a pull request', 'raise a pull request', 'file a bug', 'raise a ticket', 'triage the tickets', 'review the PR',
  'approve the PR', 'merge it into main', 'bump the version', 'cut a release', 'ship the feature', 'roll out the change',
  'roll back the change', 'spin up an environment', 'tear down the environment', 'provision the database',
  'deprecate the endpoint', 'page the on-call engineer', 'fix the bug', 'run the tests', 'push a fix',
  'deploy the build', 'flip the flag',
];

const TEXTS = [
  ['Ticket', 'Customers report that exports time out. Please triage the tickets from this morning, file a bug for each new error and raise a ticket for the data team.'],
  ['Chat', 'I have opened a pull request with the fix. Could you review the PR before lunch? Once you approve the PR, I will merge it into main and bump the version.'],
  ['Chat', "Thanks. Let's cut a release at 15:00 UTC, roll out the change to 10 % of users first, and flip the flag for the rest tomorrow."],
  ['Stand-up', 'Yesterday the error rate rose after the deploy, so we paged the on-call engineer, rolled back the change and pushed a fix. Today I will spin up an environment for the load test and tear down the environment when it ends.'],
  ['Stand-up', 'On Friday we ran the tests on the release branch, deployed the build to production and shipped the feature to every user.'],
  ['Stand-up', 'Next sprint we will provision the database for the new region and deprecate the endpoint that the old exporter uses.'],
];

// A pair matches in any tense: "paged the on-call engineer" for "page the on-call engineer".
const stem = (verb) => verb.replace(/e$/, '');
const patternOf = (pair) => {
  const [verb, ...rest] = pair.split(' ');
  const irregular = { open: 'open(?:s|ed|ing)?', run: 'r[au]n(?:s|ning)?', cut: 'cut(?:s|ting)?', spin: 'sp[iu]n(?:s|ning)?', tear: 't(?:ear|ore|orn)(?:s|ing)?', ship: 'ship(?:s|ped|ping)?', flip: 'flip(?:s|ped|ping)?' };
  const v = irregular[verb] ?? `${stem(verb)}(?:e|es|ed|ing|s)?`;
  return new RegExp(`\\b${v}\\s+${rest.join('\\s+')}\\b`, 'gi');
};

let total = 0;
for (const [kind, text] of TEXTS) {
  let marked = text;
  let found = 0;
  for (const pair of PAIRS) {
    marked = marked.replace(patternOf(pair), (m) => {
      found++;
      return `[${m}]`;
    });
  }
  total += found;
  console.log(`${kind} (${found}):\n  ${marked}\n`);
}
console.log(`${total} pairs in one sprint week`);

Ticket (3):
  Customers report that exports time out. Please [triage the tickets] from this morning, [file a bug] for each new error and [raise a ticket] for the data team.

Chat (5):
  I have [opened a pull request] with the fix. Could you [review the PR] before lunch? Once you [approve the PR], I will [merge it into main] and [bump the version].

Chat (3):
  Thanks. Let's [cut a release] at 15:00 UTC, [roll out the change] to 10 % of users first, and [flip the flag] for the rest tomorrow.

Stand-up (5):
  Yesterday the error rate rose after the deploy, so we [paged the on-call engineer], [rolled back the change] and [pushed a fix]. Today I will [spin up an environment] for the load test and [tear down the environment] when it ends.

Stand-up (3):
  On Friday we [ran the tests] on the release branch, [deployed the build] to production and [shipped the feature] to every user.

Stand-up (2):
  Next sprint we will [provision the database] for the new region and [deprecate the endpoint] that the old exporter uses.

21 pairs in one sprint week

The week used 21 pairs, in several tenses: paged the on-call engineer, rolled back the change, shipped the feature. The same few verbs carry most of the work. When a verb feels doubtful, the pairs below are the usual ones:

Rise and raise are worth a second look. Oxford’s note on the pair says that raise must have an object and rise is used without one: you “raise a ticket”, and “the error rate rose after the deploy”.

Deprecate is not remove: verbs with exact meanings

Some verbs have one exact meaning at work, and readers act on it. Google’s word list puts the most important one plainly: “To deprecate an item is to recommend against the item’s use”, and it warns against deprecated for something removed, deleted, shut down or turned down. A deprecated API still works; users are told to move away from it before a later release removes it. Announcing a removal as a deprecation is how users end up surprised. The table pairs each exact verb with the word it is often confused with:

The same care applies to the forms of a word. Deploy is the verb, deployment the noun and deployable the adjective: “We deploy the fix”, “the deployment failed”, “a deployable build”. Mixing them up, as in “We will deployment the fix”, is a slip readers notice at once.

Phrasal verbs and office idioms: understand them, then write one plain verb

The British Council’s lesson describes phrasal verbsphrasal verb: A verb with a particle such as up, out or into, whose meaning often differs from the verb alone: look into means investigate. as very common in English, “especially in more informal contexts”: a verb and a particle, where “the particle often changes the meaning of the verb”. Look into means investigate, come up with means propose, get back to means reply to. You will hear them in every meeting, along with office idioms such as circle back, take it offline and low-hanging fruit.

In writing for a global team, they cost the reader. Google’s guide for a global audience says “Avoid phrasal verbs when possible” and asks writers to “substitute a simpler verb first”, with exceptions such as set up, log in and sign in. It names ballpark figure and back burner among the idiomsidiom: A phrase whose meaning is not the sum of its words, such as "ballpark figure" for a rough estimate. Readers outside the culture that uses it, and translation tools, may take it word by word. More in “Writing for a global audience in tech teams” that “can be confusing and difficult to translate”. The program checks a meeting summary before and after a rewrite:

// A meeting summary checked for phrasal verbs and office idioms that a reader of a second language, or a translation
// tool, may take word by word. Each has a plain alternative. "Google" marks the phrases Google's style guide names;
// the rest are MySmartCoPilot's list. Understand them when you hear them; write the plain words.

const PHRASES = [
  [/\b(?:go|goes|went|going) over\b/i, 'go over', 'review'],
  [/\b(?:come|came|coming) up with\b/i, 'come up with', 'propose'],
  [/\blook(?:s|ed|ing)? into\b/i, 'look into', 'investigate'],
  [/\bget(?:s|ting)? back to\b|\bgot back to\b/i, 'get back to', 'reply to'],
  [/\bpick(?:s|ed|ing)? (?:it |this |them )?up\b/i, 'pick up', 'take'],
  [/\breach(?:es|ed|ing)? out to\b/i, 'reach out to', 'contact'],
  [/\blow-hanging fruit\b/i, 'low-hanging fruit', 'a quick, safe fix'],
  [/\bback burner\b/i, 'back burner (Google)', 'later, at a lower priority'],
  [/\bbandwidth\b/i, 'bandwidth, meaning time', 'time, or capacity'],
  [/\bcircle back\b/i, 'circle back', 'discuss again, with a time'],
  [/\bballpark figure\b/i, 'ballpark figure (Google)', 'a rough estimate'],
  [/\btake (?:it |the \w+ (?:question |topic )?)?offline\b/i, 'take it offline', 'discuss it in a separate call'],
  [/\btouch base\b/i, 'touch base', 'talk, or check in'],
  [/\bmove the needle\b/i, 'move the needle', 'make a measurable difference'],
];

function flags(text) {
  return PHRASES.filter(([re]) => re.test(text)).map(([, label, plain]) => `${label} -> ${plain}`);
}

const before =
  'Thanks all. We went over the error budget and came up with three options. Asha will look into the cache misses ' +
  'and get back to us by Thursday. The retry change is low-hanging fruit, so Ravi will pick it up. The migration goes ' +
  "on the back burner until we have the bandwidth. Let's circle back on the ballpark figure for the new region, and " +
  'take the pricing question offline.';
const after =
  'Thanks, everyone. We reviewed the error budget and proposed three options. Asha will investigate the cache misses ' +
  'and reply by 17:00 UTC on Thursday. The retry change is a quick, safe fix, so Ravi will take it. The migration ' +
  'waits until the team has time for it. We will discuss a rough estimate for the new region at 10:00 UTC on Monday, ' +
  'and the pricing question in a separate call.';

for (const [label, text] of [['Before', before], ['After', after]]) {
  const found = flags(text);
  console.log(`${label}: ${found.length} phrase${found.length === 1 ? '' : 's'} to replace`);
  for (const f of found) console.log(`  ${f}`);
}

Before: 11 phrases to replace
  go over -> review
  come up with -> propose
  look into -> investigate
  get back to -> reply to
  pick up -> take
  low-hanging fruit -> a quick, safe fix
  back burner (Google) -> later, at a lower priority
  bandwidth, meaning time -> time, or capacity
  circle back -> discuss again, with a time
  ballpark figure (Google) -> a rough estimate
  take it offline -> discuss it in a separate call
After: 0 phrases to replace

The summary lost all 11 phrases, and it gained two times with their zones that get back to us by Thursday and circle back had left out. Know these phrases when you hear them; write the plain words:

Phrasal verbs that name an operation in your tools are the exception. If the tool and its docs say roll back or set up, use the same words, so readers can match your text to the screen.

Agile words mean exactly what the Scrum Guide says

Teams that work in Scrum use a small set of words with exact meanings, defined in the Scrum Guide by its authors. The guide is published under a Creative Commons licence; the short quotes below are its own words:

Two habits keep these words useful. Use them in the sense the guide gives, so “the Sprint Goal” means one objective, not a list. And keep their capitals when you refer to the Scrum events and artifacts, as the guide does, so a reader can tell the Scrum term from the everyday word: a sprint in a race is not your team’s Sprint.

Practise: fix the verbs of a sprint update

The exercise holds a sprint update with unusual verb and noun pairs and three office idioms. Fix it until the sample tests pass:

// Rewrite the update with the verb and noun pairs teams use and without office idioms. Keep every fact.
export const update =
  'Yesterday I gave a review to PR #233 and made an approval. Ravi did a rollback of the search change after the ' +
  'error rate rose. Today I will rise a ticket for the flaky test and make a release at 15:00 UTC. We do not have the ' +
  "bandwidth for the migration this sprint, so let's circle back on it in the planning meeting. The retry fix is " +
  'low-hanging fruit.';

import { test, assert } from 'mysmartcopilot:test';
import { update } from './update.mjs';

const UNUSUAL = [
  [/\b(?:give|gave|giving|do|did|doing) a review\b/i, 'review the PR'],
  [/\b(?:make|made|making) an approval\b/i, 'approve the PR'],
  [/\b(?:do|did|doing) a rollback\b/i, 'roll back the change'],
  [/\brise a ticket\b/i, 'raise a ticket'],
  [/\b(?:make|made|making) a release\b/i, 'cut a release'],
];
const IDIOMS = [/\bbandwidth\b/i, /\bcircle back\b/i, /\blow-hanging fruit\b/i];

test('no unusual verb and noun pairs', () => {
  for (const [re, use] of UNUSUAL) assert.ok(!re.test(update), `"${update.match(re)?.[0]}": write "${use}"`);
});

test('the pairs teams use are there', () => {
  assert.ok(/\breview(?:ed|s)? PR #233\b/i.test(update), 'say that you reviewed PR #233');
  assert.ok(/\bapprov(?:ed|e|es) (?:it|the PR|PR #233)\b/i.test(update), 'say that you approved it');
  assert.ok(/\broll(?:ed|s)? back the search change\b/i.test(update), 'say that Ravi rolled back the search change');
  assert.ok(/\b(?:raise a ticket|file a bug)\b/i.test(update), 'raise a ticket or file a bug for the flaky test');
  assert.ok(/\bcut a release\b/i.test(update), 'cut a release at 15:00 UTC');
});

test('no office idioms', () => {
  for (const re of IDIOMS) assert.ok(!re.test(update), `"${update.match(re)?.[0]}" is an office idiom: write the plain words`);
});

test('every fact stays', () => {
  for (const fact of ['Ravi', 'PR #233', 'search change', 'flaky test', '15:00 UTC', 'migration', 'planning meeting', 'retry fix']) {
    assert.ok(update.includes(fact), `the update no longer says "${fact}"`);
  }
});

Then work through the questions on the four ideas of the lesson. The first one comes from whichever idea your answers have been weakest on:

Interview questions

Warm-up (fresher to mid-level): What does it mean to deprecate an API, and how is it different from removing it?

To deprecate an API is to recommend against using it while it still works, usually because a later release will remove it. Google’s word list defines it that way and says not to use deprecated to mean removed, deleted or shut down. Removing it takes it out: calls to it fail. A good deprecation notice says what is deprecated, what to use instead and when the removal is planned, so users can move in time. Calling a removal a deprecation leaves users surprised by errors.

Two longer questions on tech vocabulary sit in this module’s bank:

Key takeaways

• Learn tech verbs with their nouns: open a pull request, cut a release, roll back a change, page the on-call engineer.
• Use exact verbs in their exact sense: deprecate is not remove, and stop, exit or cancel replace kill.
• Understand phrasal verbs and office idioms when you hear them, and write a plain single verb for a global team, except for operations your tools name, such as set up and roll back.
• Use the Scrum Guide’s words in the guide’s sense: one Sprint Goal, a Product Backlog that is ordered, a Daily Scrum of 15 minutes for the Developers.