Designing a Command Library for Your Team

A team method for collecting, wording, and testing shared spoken commands

Voiskey Voiskey Team
Voice CommandsDevice AutomationDesigning Command Library

Inventory the Requests Your Team Repeats

Designing a Command Library for Your Team starts with observation, not invention. For two weeks, ask each person to note every request they repeat: opening a set of windows, preparing a document, moving a file, or arranging a review. Record the rough wording, how often it happens, and what the person does when the request fails. Do not normalize the wording yet; variation is exactly what you need to see. At the end, group the notes by outcome rather than by phrase. A library built from real repetition will be smaller and more useful than one built from a brainstorm of things voice control might do.

Interview the people who do the work instead of the people who manage it. Ask them to demonstrate one request from start to finish and to narrate why each step exists. Watch for steps they perform without mentioning, such as checking a window before typing or saving a copy before an edit. Those silent steps are the ones a shared command most often omits. Write them down as preconditions. If a request has no stable beginning or end, mark it as unsuitable for a shared command and keep it personal. A library that includes unstable requests erodes trust faster than a library that starts small.

Distinguish requests that save time from requests that save attention. A command that shaves two seconds but interrupts a train of thought may be worth less than one that removes a context switch. Ask each person which requests they would miss most if the shortcut disappeared. The answers often cluster around transitions between tasks rather than around individual keystrokes. Record the reason beside each request so the library can be defended later. When two requests appear to overlap, keep both until you see which one people actually use. Premature merging hides the real usage pattern. A short reason beside each entry also helps when you must justify the first release.

Set a size limit before you start writing. A first library with more than twenty commands is hard to learn and hard to test. Pick the ten to fifteen requests that appear most often across the team and leave the rest on a waiting list. Write the waiting list down so people can see their request was heard rather than ignored. Assign a review date when the next batch can be considered. A visible limit turns a vague ambition into a queue, and a queue is easier to manage than a growing collection of half-tested phrases. A queue that moves is more motivating than a list that only grows.

Write Commands in a Single Grammar

Choose one sentence pattern and apply it to every command. A pattern such as action, object, destination keeps the library predictable and makes new entries easy to add. Write the pattern at the top of the document and give one example. When a proposed command does not fit, rewrite it rather than adding a second pattern. Two patterns are the beginning of many. Test whether a new team member can produce a correct command for an unseen request after reading only the pattern and three examples. If they cannot, the grammar is too loose or the examples are too few.

Use concrete nouns and avoid pronouns. A command that says move it left depends on what is currently selected, which makes the result unpredictable. Replace pronouns with names: move the draft window left, open the review folder, place the calendar on the second screen. Concrete nouns also make the commands easier to translate for colleagues who speak another language, since names survive translation better than references. Voiskey supports more than one hundred languages and translation, and a library with stable nouns is easier to extend across a multilingual team. Review each entry once specifically for pronouns before publishing it. Specific names also make a failed command easier to diagnose.

Write commands at the level of an outcome, not a sequence of interface steps. An outcome survives a change in layout or menu, while a step list breaks the moment something moves. If a command truly needs a sequence, such as prepare a folder and open a document inside it, split it into two named commands and let the user say both. This keeps each entry testable on its own. Note any dependency between commands in the same row. Dependencies that are invisible in the document become surprises during use, and surprises are what make people stop trusting a shared library.

Add a short negative example to each command. A negative example states what the command does not do, such as this does not close other windows or this does not rename the file. These lines prevent the most common misunderstanding, where a person assumes a shared command covers an adjacent task. Keep the negative example to one sentence and place it beside the entry. When a command changes, update the negative example in the same edit. A library that documents its boundaries is easier to trust than one that only documents its intentions. Boundaries are part of the command's definition.

Sort Commands by Frequency and Consequence

Sort the library by how often a command is used and how much a mistake costs. High frequency, low consequence commands belong in the first group because people will learn them quickly and errors are easy to fix. High consequence commands, such as anything that moves or deletes work, need a review step and a slower rollout. Draw a simple two-by-two grid and place each command in a cell. The grid makes arguments about priority concrete. When someone wants a command added, ask which cell it belongs in and why. Placement should be based on observed use, not on enthusiasm.

Put the most used commands on a single page. People will not consult a long reference during work, so the page should be short enough to read at a glance. Order entries by the moment they are used, not alphabetically, because a working sequence is easier to recall than a dictionary. Reserve the full document for definitions, exceptions, and examples. Keep the one-page sheet in the place where the team already looks for instructions. If a command cannot earn a place on that page, it is a candidate for the waiting list rather than the first release. The page should be readable without picking it up.

Treat high consequence commands differently. Add a confirmation step, a named owner, and a rollback instruction to each one. The confirmation can be as simple as requiring the speaker to state the object and then repeat it before acting. Write the rollback as a numbered list that someone else can follow without asking questions. Test the rollback once during the pilot, because a rollback nobody has tried is a hope rather than a plan. High consequence commands should also appear in the review each month, even when nobody has reported a problem, since silence is not evidence of health. Treat the rollback as part of the command, not as an appendix.

Revisit the sort after a month of use. Usage patterns shift as people learn the library, and a command that seemed rare may become central once it is easy. Count actual uses rather than asking people to estimate, because estimates tend to reflect intention rather than habit. Move commands between cells based on what you observe, and record the reason for each move. If a high consequence command is used often and has never failed, consider simplifying the confirmation, but only after reviewing the log. The sort is a living decision, not a one-time classification. A command that moves cells without a recorded reason invites debate later.

Pilot the Library on Real Work With Voiskey

Pilot on ordinary work rather than a demonstration. Ask three or four people to use the one-page sheet for a week on tasks they would do anyway. Voiskey is a voice typing app for macOS and Windows that places recognized text at the insertion point, and its team plan offers shared vocabulary and workflows, which is exactly what a command library needs to stay consistent across people. Its Jev integration lets direct voice commands guide Jev through everyday device tasks, and that integration is early-stage and under active refinement, so test each command rather than assuming it. Record usage and failures daily, not at the end of the week.

Give participants one instruction: use the sheet, and when a command fails, stop and write down the exact wording and what happened. Do not ask them to fix the command during the week, because individual fixes fragment the library. Collect the notes at the end and group failures by cause: unclear wording, missing precondition, wrong cell, or a command that should not exist. A failure that appears for two people is a library problem; a failure for one person is often a setup difference. This distinction prevents you from rewriting commands that were never broken. Sort the causes before you change a single line.

Measure time saved on the tasks that matter, not across everything. Choose three repeated tasks and compare the shared command with the current method over the same number of runs. Include the time spent looking up the command, because a library that requires consultation may save less than it appears. Note the human review step for high consequence commands and count it as part of the cost. If a command is slower but reduces errors or context switching, record that benefit in words rather than forcing it into a time figure. A pilot should produce a fair comparison, not a flattering one.

Close the pilot with a decision for every command. Each entry should be kept, revised, or removed, with a sentence of evidence. Ask the participants to nominate the one command they would keep if the library were cut to a single entry; that answer reveals what the team actually values. Keep the evidence beside the entry rather than in a separate report, so future readers can see why it exists. Schedule the next pilot before the meeting ends. A library that enters the pilot with fifteen commands and leaves with fifteen undecided has tested nothing. An undecided entry consumes attention every time someone opens the document.

Version the Library and Keep It Honest

Give the library a version number and a changelog. Every addition, rewrite, or removal gets a line with the date, the author, and the reason. Keep the one-page sheet and the full document under the same version so people do not work from different editions. When a command changes, announce it in the channel the team already uses, with the old wording, the new wording, and the date it takes effect. A quiet change is worse than no change, because people keep using the phrase they memorized. Version control is not bureaucracy; it is how a shared language stays shared.

Retire commands as deliberately as you add them. A command that has not been used in a quarter is a candidate for removal, but check whether it is seasonal before deleting it. Mark it as dormant first and see whether anyone asks for it. When you remove an entry, say what replaces it, if anything. A library that only grows becomes a document nobody reads, and an unread library cannot guide anyone. Keep the waiting list visible so people see that retirement is a normal part of maintenance rather than a rejection of their request. A dormant list is also a useful signal of what the team has outgrown.

Assign one owner and one backup. The owner decides what enters the library, reviews the changelog monthly, and runs the pilot for each new batch. The backup keeps the process alive during absences. Document the decisions in a short note rather than relying on the owner's memory, because a library that depends on one person is fragile. When ownership changes, hand over the changelog, the recent pilot results, and the waiting list in one meeting. Ask the new owner to add one command and remove one as a test. Ownership is real only when the transfer works without the previous owner.

Make adoption easy for new colleagues. Give them the one-page sheet, the grammar, and three worked examples, then ask them to download Voiskey and confirm the shortcut works before their first shared task. Voiskey learns names, jargon, acronyms, and spelling preferences, so a consistent command list also helps the captured text match the team's vocabulary. Pair the new person with someone who uses the library daily for the first week. Collect their hesitations in the same place as the pilot notes. A library that a new colleague can use without a walkthrough is the real measure of whether it is well designed.

FAQ s

Voiskey is a voice typing app that places recognized text at the insertion point, so a command proposal can be captured exactly as spoken. A team plan offers shared vocabulary and workflows, which helps command names and project terms stay consistent across people. Start with a one-page sheet of repeated requests, then test each command on ordinary work.

A team plan offers shared vocabulary and workflows, so the same command wording and project terms can be used by everyone. Voiskey also learns names, jargon, acronyms, and spelling preferences. Keep one authoritative sheet and read the exact entry during reviews, then check the captured line before adding or changing a command.

Text appears at the insertion point in any app or text field, so you can speak a proposed command into the sheet where you keep the library. Press the shortcut, say the exact wording, and check the result in that field. No copy and paste step is needed between the test and the entry.

Voiskey supports up to 220 words per minute, about five times faster than typing, so a proposal takes seconds to record during a review. Speak the exact wording you want tested, then confirm the captured line before adding it to the sheet. Speed matters most when several people suggest changes in one sitting.

Say less. Get more
Say less. Get more
Say less. Get more
Say less. Get more
VoiskeyVoiskey

Your voice, amplified.

Download Voiskey for Mac and Windows and give your team one shared command list.

Use it across macOS, Windows, iOS, and Android

Use it across