Dictating Style and Naming Conventions

A spoken style card that keeps names consistent across a codebase

Voiskey Voiskey Team
Voice Vibe CodingAI Code PromptsDictating Style Naming

Collect the Rules Your Team Already Uses

Dictating Style and Naming conventions works only when the conventions are written down before you speak. Ask three teammates for the rules they already follow, even if those rules live only in habit. Write down examples of names they like and names they avoid. Sort the answers into categories: files, functions, variables, tests, and user-facing labels. Where answers conflict, mark the conflict rather than smoothing it over. A guide built from existing practice is easier to adopt than one imported from a blog post, and it gives you a stable text to dictate from. Date the interview notes and keep the raw answers.

Find the rules that already live in the code. Sample twenty recent files and note the patterns your team actually uses: separators, case, prefixes, and the length of names. Compare the sample with the answers from the interviews. A rule that everyone claims but the code ignores is either outdated or misunderstood, and either way it needs a decision. Speak the discrepancy as a question for the team, not as a criticism. The goal is a short list that matches reality, because a list that contradicts the code will be ignored within a week. Short lists survive; long lists get skimmed. Keep the list to the rules that change a decision.

Write each rule as a sentence with an example pair. For instance: use camelCase for functions, so loadProfile is right and load_profile is wrong. A pair teaches faster than a paragraph, and it is easy to dictate and easy to check in a diff. Add the exception next to the rule, not in a separate section, so a reader sees both at once. When two examples are possible and only one is preferred, say why in one short clause. Reasons make a rule easier to remember and easier to challenge when the project changes. An example pair is a test you can run by eye.

Approve the list with the people who will live with it. Walk through each rule and ask for a show of hands or a clear objection. Record the decision, the date, and the owner. If the team cannot agree on a rule, leave it out and use the closest existing pattern until a decision is made. Do not let the list grow beyond what a new teammate can learn in an afternoon. The stage is done when the list has examples, exceptions, and one named owner, and when the code sample mostly matches it. A short approved list beats a long aspirational one. Review it when a new area of the code starts.

Speak Conventions as Short Examples

Turn each rule into a spoken drill. Say the rule, say a good example, and say a bad example, then ask for a rename in the same pattern. Voiskey removes filler and places the result at the insertion point, so the drill output is a clean line you can paste into your notes. Repeat the pattern with a second example that uses a different word, so the rule is not tied to one name. A drill that produces two correct renames is better evidence than a paragraph of agreement. Keep the drill short enough to finish in a few minutes. Practice on names you will actually use this week.

Use pairs that differ in only one dimension. A pair such as userCount and user_counts tests the case convention without also testing choice of vocabulary. If a pair differs in several ways, the learner cannot tell which part of the rule applied. Speak the dimension, the good form, and the bad form, then ask for a third example that follows the good form. Do this for files, functions, variables, and tests, one dimension at a time. Short, single-dimension pairs make the convention visible instead of mysterious. Visible conventions are easier to keep than memorized ones. Keep one pair per rule in the style card.

Dictate real renames, not invented ones. Pick a function from the current task and say its purpose, then speak the name you want. Check that the name follows every rule at once: the case, the prefix, the length, and the vocabulary from the glossary. If it breaks one rule, say which rule and fix it in the same breath. Voiskey learns names, jargon, acronyms, and spelling preferences, so a product term you use often stays stable across renames. Real examples are remembered longer than abstract drills and they improve the code immediately. A rename that follows the rules is a small piece of documentation.

Collect the drill output into a style card. The card lists each rule, its example pair, its exception, and one real name from the codebase. Keep it to a page and put it where you draft prompts. Read the card aloud before a naming-heavy task, then speak names without stopping to look up each rule. When a new rule appears, add it with a pair and a real example in the same session. A card that is easy to read aloud is a card that shapes what you say, which is the entire point of dictating with conventions. Keep the card versioned so changes are visible.

Keep a Style Card Beside Your Work

Place the style card where you actually work. If you dictate into an editor, keep the card in a split pane or a pinned tab. If you draft in a notes app, keep it at the top of the note. The best location is the one you see without searching, because a card you have to find is a card you skip. Speak the first three rules from memory, then check the card for the rest. A card is a tool, not an archive, so it should be short, current, and visible during the task rather than filed away. Treat it like a keyboard shortcut: nearby, familiar, and fast. Print it if that helps.

Format the card for spoken use. Each rule starts with a verb, each example is a single name, and each exception is one short clause. Avoid tables that are hard to read aloud and long paragraphs that hide the rule. Use plain punctuation, and write names exactly as they should be spelled, including capital letters. Voiskey learns spelling preferences, so the card's exact forms become the forms you hear back. A card written for the ear is easier to use in a spoken session than a card written for a formal document. Read one rule aloud to test the format before sharing the card. If it sounds awkward, rewrite it for speech. Keep one rule per line.

Keep the card honest about exceptions. A rule with a permanent exception should say so in one clause, and a rule with a rare exception should say when it applies. If an exception has no reason, remove the rule instead of documenting a habit. Read the exceptions aloud and ask whether each one still earns its place. A card full of exceptions is a sign the rules are too rigid, and a rigid card will be ignored under deadline. Fewer, clearer rules survive longer than a complete list that nobody can remember. Give every exception a reason and an owner.

Version the card and review it when a new area of code starts. Add a rule only with an example pair and a real name, and remove a rule only with a date and a reason. Put the version at the top and keep the previous copy available for comparison. A card that changes silently confuses the people who learned the old version. Announce the change in one sentence in the place the team already reads project notes. Review takes ten minutes and prevents weeks of quiet inconsistency. The card is only as good as its last review. Keep the review date visible.

Check Names in the Diff

Make the diff the last checkpoint. Before you commit a spoken change, read every new name and ask three questions: does it follow the card, does it use the glossary term, and does it describe the thing rather than the moment. A name such as tempFix or newHelper passes a compiler and fails a reader. Fix names in the same change, because a rename later touches more files and more tests. Keep the diff small enough that you can read every name without scrolling. The diff is where the convention either survives or quietly erodes. Read names before logic, and fix them in place.

Use a spoken pass to catch the names you skim. Read each changed line aloud and listen for a name that sounds vague, abbreviated in an unusual way, or inconsistent with its neighbors. A name you stumble over is often a name a reader will stumble over. With Voiskey, speak the corrected name into the file at the insertion point, then review the edit. Download Voiskey and run one diff through this pass to see how many names you catch. The pass takes a few minutes and prevents the slow drift that makes a codebase hard to navigate. Note the names you changed.

Check the cross-cutting names, not just the new ones. When a rename changes a shared component, search for the old name and update every use, including tests, examples, and comments. Speak the search term aloud before you start, and record the count so you know when the update is complete. If the count grows during the change, stop and investigate. A half-finished rename is worse than none, because it leaves two names for one idea. Add the rename to the commit message so the next reader sees the intent. Then search once more before you close the change. Record the final count.

Close the diff review with a short checklist entry. Note the number of new names, the rules checked, and any exception used. If an exception was needed, either update the card or fix the name. Ask a teammate to read the diff names without context and guess what each one does; if they guess wrong, the name is not carrying its weight. This check is quick and it turns the card from a document into a practice. Record the result beside the change so the habit is visible. A diff that passes the name check is easier to review for everything else. Attach the checklist to the review request.

Drill New Teammates With Spoken Examples

Run a twenty-minute drill with every new teammate. Give them the card, read three rules aloud, and ask them to rename three real identifiers from the current task. Have them speak the names into a scratch file and explain each choice. Correct the reasoning, not just the spelling. Repeat with a fourth name that sits near an exception, so they practice judgment rather than memorization. The drill ends when they can name the rule behind every choice. A teammate who can explain a name will keep the convention after the card is out of sight. Keep the drill notes.

Use the team's real code, not invented examples. Pick a function with a vague name and ask the new teammate to rename it following the card, then compare with the name the team would choose. Discuss the difference and update the card if the team's choice reveals a rule that was never written. Speak the final name into the file with Voiskey so the drill produces a real improvement, then review the diff together. Download Voiskey for the new teammate and set up the shortcut during the drill, because a tool introduced on day one becomes a habit. Schedule the drill before the first real task.

Pair the drill with a review rotation. Ask the new teammate to review one diff each week using the card, and ask a senior teammate to review the review. The rotation spreads the convention and surfaces disagreements early, while they are cheap to resolve. Keep a short log of the names that caused debate and add the clearest resolution to the card with an example pair. A convention that is reviewed by more than one person becomes shared practice instead of one person's preference, and shared practice is what survives a busy quarter. Rotate the senior reviewer as well so the standard is shared.

Close the onboarding loop with a spoken summary. Ask the new teammate to say the five rules they use most, record the summary with Voiskey, and store it beside the card. Download Voiskey for the team so the summary and the card share a format. Compare the summary with the card and fix any rule that was learned differently. A summary in the teammate's own words shows what the card actually communicates, which is more useful than a quiz score. Revisit the summary after a month and note what changed. Add one new example to the card and date the summary.

FAQ s

Voiskey is an AI voice typing app for desktop use. You press a shortcut, speak the rule or the name, and text appears at the insertion point in your editor. It removes filler words and false starts, and adapts formatting to the task, so a short style rule becomes a clean, usable prompt or note.

Yes. Voiskey learns names, jargon, acronyms, and spelling preferences, so a preferred spelling stays stable after you use it once in a real sentence. Say the exact form you want and check it at the insertion point. A team plan adds shared vocabulary and workflows, which keeps a group consistent.

Say the kind of identifier, the case style, and one good example and one bad example. Keep the exception in a separate sentence. Voiskey adapts punctuation and formatting to the task, so the spoken rule arrives as a readable instruction. Review it at the insertion point before adding the next rule.

Voiskey supports 100+ languages and translation. You can dictate the card in one language and ask for another version, then review the result at the insertion point. Keep identifier examples unchanged, and check that the translated rule still names the case style and the exception clearly.

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 speak each naming rule at your cursor.

Use it across macOS, Windows, iOS, and Android

Use it across