Describe slow actions precisely so fixes arrive in reviewable pieces

Describing Performance Problems to an AI editor works best when you name one slow action and its boundary before anything else. Write the action as a user would perform it: open the report, filter by date, scroll to the last row. State where the slowness begins and where it ends, because an action that feels slow may include loading, rendering, or a second request. Add the size of the input, such as the number of rows or items, and the environment where you saw it. This boundary is the unit you will describe in every prompt. Write it on one line.
Separate the observed symptom from the suspected cause. The symptom is what you saw: a spinner for several seconds, a frozen scroll, a delayed click. The cause is a guess about what produced it. Speak symptoms first and keep them in a numbered list. Without this separation, a prompt becomes a story about a theory, and the editor may fix the theory instead of the problem. Add a note when you are unsure, and mark the suspicion as a question rather than a statement. The list of symptoms is the reference for every later request. It is also the first thing a reviewer will ask for.
State the expected behavior without inventing a metric. You can say the list should respond as soon as the user stops typing, or that the second open should not wait on the same work as the first. You do not need a specific number to describe the intended feel, and you should not invent a target you cannot defend. If the team already has a target, quote it and say where it comes from. Otherwise describe the sequence of events the user should experience, and let the engineer choose a measurement. A described sequence is easier to test than a vague adjective.
Write the boundary statement into the task before you speak to the editor. One paragraph with the action, the input size, the observed symptom, the expected sequence, and the environment is enough. Read it back and remove any sentence that describes a fix. The paragraph is your contract for the session: every prompt should refer to this action, not to a different screen that happens to feel similar. A clear boundary keeps the conversation from wandering into unrelated optimizations that add risk without improving the reported experience. Update the paragraph only when you have new observations, and keep the old copy.
Number the steps exactly as you performed them, including the ones that seem obvious. Start from a state another person can reach: a fresh page, a saved draft, a sample account. Write each step as one action and one result. If a step depends on timing, such as clicking before a list finishes loading, say so, because timing is often the whole bug. Speak the steps one at a time and review each line at the insertion point before adding the next. A numbered list that another person can follow is worth more than a detailed theory. Keep the list short enough to run in a few minutes.
Note what does not matter. If the problem appears with a large list but not a short one, say so; if it appears on the second visit but not the first, say so. Negative information narrows the search faster than another adjective. Also note any step you skipped, because a skipped step may be the missing condition. A reproduction that states its boundaries lets an engineer decide quickly whether a guess is plausible, and it prevents the slow cycle of trying fixes against a problem nobody can recreate. Record the date and the version where you observed it, plus the input size.
Ask for a reproduction check before asking for a fix. A useful prompt is to present the steps and ask where they are ambiguous before anything changes. The answer often reveals a missing precondition or a step that only works on your saved state. Correct the list, then speak the next request. This small pause is cheaper than a patch based on a misunderstood sequence. It also trains you to write steps that survive being read by someone who was not there. Ambiguity found now is a fix avoided later. Say the check request explicitly instead of assuming it, and wait for the answer.
Keep the reproduction list with the task after the conversation ends. Add the steps, the observed symptom, and the version to the issue. If the problem disappears, keep the list anyway with a note about when it last occurred; a later report can be compared with it. When you dictate a new report, speak the old list first and say what changed. This continuity turns isolated complaints into a history, and a history is what makes a performance problem solvable instead of mysterious. A short history beats a long argument about whether the problem is real. Keep the list with the issue.
Use verbs that describe behavior rather than mechanisms. Saying the list pauses after I type is a symptom; saying the query is slow is a mechanism. Saying the page jumps when images load is a symptom; saying the layout is thrashing is a mechanism. When you speak a mechanism, mark it as a hypothesis and keep it separate. The editor can then propose a test for the hypothesis instead of treating it as fact. A description built from symptoms stays true even if your theory is wrong, which is exactly what you want in a bug report. Say the symptom first in every sentence you dictate.
Include what changed recently, if anything. A new release, a new field on the screen, a larger list, a different device, or a change in the workflow are all useful signals. Say when the change happened and how confident you are. Do not claim a cause from correlation alone; a change that shipped the same week is a lead, not a verdict. The point is to give the editor a short list of things worth checking, while keeping the list clearly labeled as possibilities rather than conclusions. A labeled possibility is useful; a confident guess is a trap. Name the test that would settle it.
Describe the blast radius. Say whether the problem affects one screen or several, one user or everyone, one input size or all sizes. If you have only seen it once, say that. A report that claims the app is slow invites a broad, risky change, while a report that says this list pauses only when it holds more than a few hundred rows invites a targeted one. Speak the scope in the same breath as the symptom, and update it when you learn more. Scope is often the difference between a fix and a rewrite. Narrow scope also makes the result easier to verify.
Close the description with a list of open questions. Write two or three things you genuinely do not know, such as whether the delay happens before or after the request returns. Ask the editor to answer those questions with evidence from the code or with a small experiment. Open questions keep the collaboration honest and prevent a confident answer from replacing an observation. They also give you a checklist for the next test round, so each session ends with fewer unknowns than it started with. Keep the list in the task and strike items as evidence arrives. Fewer unknowns mean a smaller, safer change.
Ask for one hypothesis and one change at a time. A prompt such as proposing the smallest change that tests whether rendering is the bottleneck, then stopping before editing unrelated code, keeps the diff reviewable. When the change arrives, read it against the symptom and the scope. If it touches five files for a single-screen problem, ask why. Small changes are easier to test, easier to revert, and easier to explain to a reviewer who was not in the session. Save the larger redesign for a separate task with its own evidence. Size is a signal of whether the diagnosis was precise.
Require a before-and-after observation for each change. The observation can be the same reproduction steps, run again, with the same input size. Ask the editor to state what should differ if the hypothesis is right, then run the steps yourself. If nothing differs, the change did not test the hypothesis, no matter how reasonable it looks. Keep the result with the change so the next person knows what was tried. A performance conversation without observations is just a sequence of opinions. Two runs with the same steps are worth more than ten theories. Record the input size for both runs.
Speak the request where the code lives. With Voiskey, you can press a shortcut in your code editor, say the hypothesis and the boundary, and the text appears at the insertion point, including file names and paths. That keeps the instruction next to the function it concerns instead of in a separate chat window. Download Voiskey and use it to draft one such request, then edit the sentence before sending. The workflow is Speak-Polish-Type-Edit, and it fits performance work because the request is short and specific. Clear instructions lead to smaller, more reviewable patches. Start with the symptom, then state the boundary.
Review each change with a stop rule. If the change grows beyond the stated boundary, pause and ask for a narrower version. If the change includes a new dependency, ask what it replaces. If the change removes a safety check to gain speed, stop and discuss the tradeoff before merging. Write the stop rule in the task so the reviewer applies it without debate. A reviewable piece has a clear symptom, a clear boundary, and a clear observation, and anything outside that shape belongs in a separate request. The stop rule protects both speed and correctness. Apply it before merging, not after a regression.
Keep a running log of slow actions, one line each. Include the date, the action, the input size, the observed symptom, and the version. Speak the line into the log while the problem is fresh, then clean it at the insertion point. A log written after the fact is usually missing the size or the version, and those two fields are what make a repeat possible. Over a month, the log shows whether the same screen keeps appearing and whether the changes actually reduced the pauses users report. A log is cheap; a lost observation is expensive. Keep it in the repository so it travels with the code.
Group the log by action, not by date, when you review it. Grouping reveals a pattern, such as every slow action involving a large list, while a date order shows only a sequence of unrelated complaints. Count how often each action appears and note the changes that followed. If an action disappears from the log after a change, that is evidence worth keeping. If it returns, the earlier change did not hold. A grouped log turns scattered reports into a small set of problems the team can actually plan for. Review it monthly and delete entries that are no longer relevant. A short log is easier to trust than a long backlog.
Use Voiskey to dictate log lines as you test. Press the shortcut, say the action and the size, and let the text land at the insertion point in the log file. It removes filler and false starts, so the line matches the format of the other entries. Download Voiskey for the machines used in testing, and make the shortcut part of the test routine. When the log is easy to write, people write it, and a written log is what turns a vague feeling of slowness into a repeatable case. Keep the format to one line so the log stays scannable.
Close the loop with a short monthly read. Open the log, pick the most frequent action, and run its reproduction steps again. If the symptom is gone, note the version where it stopped. If it remains, write the next hypothesis and a boundary for the change. Share the read with the team in three sentences: what improved, what persists, and what is next. This ritual keeps performance work attached to observed behavior instead of a one-time cleanup, and it gives every future report a place to start. Evidence from a simple log beats memory in every review. Keep the read brief so it happens every month.
Voiskey is an AI voice typing app for desktop use. You press a shortcut, speak the symptom, the steps, and the boundary, and text appears at the insertion point in your editor. It removes filler words and false starts, and adapts punctuation and wording, so a spoken report becomes a precise, reviewable prompt.
Yes. Voiskey turns spoken requests into AI-ready prompts, including file names, paths, and commands. Say the path where the slow code lives, then review the text at the insertion point before sending. If a name is unusual, say it once clearly and reuse it, because Voiskey learns names, jargon, acronyms, and spelling preferences.
Say one slow action and where it begins and ends, the input size, and the symptom you observed. Keep a suspected cause separate and label it as a guess. Voiskey adapts formatting to the task, so the short sequence arrives as a readable prompt. Add the reproduction steps after the boundary, one line each.
Voiskey supports 100+ languages and translation. You can dictate the report in one language and ask for another version, then read the result at the insertion point. Keep file names, paths, and version numbers unchanged, and check that the translated text still separates the symptom from the suspected cause.

Download Voiskey for Mac and Windows and speak each performance report at your cursor.
Use it across macOS, Windows, iOS, and Android