A lightweight record that lets you replay a spoken prompt and get the same result

Keeping a Spoken Prompt log for reproducibility means recording the part of a request that made the result what it was, not everything you said while thinking. The useful minimum is short: the date, the file you targeted, the prompt as it was actually sent, the state of the project when you sent it, and what happened next. That last field is the one people skip, and it is the one that turns a diary into a record. A log line that says what you asked and what came back can be replayed; a line that says only what you asked cannot. Keep the format identical for every entry so the log stays readable when it is long.
Log the sent text rather than the raw speech. A voice request passes through a polish step that removes filler words, stutters, false starts, and self-corrections, and it adapts punctuation, formatting, tone, and word choice to the task. The polished sentence is what produced the result, so the polished sentence is what belongs in the log. If you dictated something notably different, add a short note about the intent behind the change, because the gap between what you meant and what you sent is often the reason a replay behaves differently. The sent text plus one note is enough; a transcript of your thinking is not.
Record the starting state in a form you can restore. A commit identifier is the cleanest option when you work in version control; a saved copy of the project is a workable fallback. Write the check you ran and the result you observed, so a replay has something to compare against beyond your memory. Add the tool or model setting if the project fixes one, and note any manual step you performed outside the prompt. These details are boring to write and decisive when you return three weeks later. A prompt log without a starting state is a list of sentences with no way to tell whether the sentence or the code changed.
Choose one place for the log and one owner. The place should be beside the project, in a file the team already opens, rather than in a personal notes app that disappears when a laptop is replaced. The owner is whoever is working in the session, and the handoff rule is simple: the next person appends rather than rewrites. Add a header that states the fields and their order so a newcomer can contribute without a meeting. A shared format with a single location is what makes a prompt log durable, and durability is the point of writing it down at all.
Capture at the moment of sending, not at the end of the session. Stop, append the line, send, and continue. The interruption costs a few seconds, and the alternative costs the detail that makes the entry useful. Keep the log file open in a second pane so appending is one movement rather than a context switch. Dictate the log line with the same speaking habit you use for prompts, then correct only the fields that matter: the file, the prompt, and the result. A log written in the moment is imperfect and complete; a log written later is polished and wrong in exactly the places you need it.
Borrow the prompt you just sent instead of describing it again. After the polish step, the text is already in the input field or in the conversation, so copy it into the log rather than re-dictating a summary. The same applies to the file path and the check command, which are easier to copy than to say twice. Reserve your voice for the fields that need judgment, such as the observed result and the reason you tried this prompt. This division keeps the friction low enough that you will still be logging at the end of a long session, which is when the most valuable entries are produced.
Use a fixed one-line shape and do not decorate it. A workable shape is date, file, prompt, state, result, next. Put the fields in the same order every time and separate them with a character that does not appear in prompts, so the line remains sortable. Resist headings, colors, and nested lists; a log that needs formatting is a log that gets abandoned. When a prompt needs more than one line, add a short continuation below the main line rather than inventing a new structure. Consistency is worth more than expressiveness here, because the log is read by whoever is replaying it, not by an audience.
Set a capture rule for prompts that fail. A failed prompt is the most useful entry in the log, because it records a path that did not work and the reason it did not. Write the failure with the same fields and add one sentence about what you changed next. If you iterated three times on the same request, log all three but mark the one that succeeded. This small discipline turns a frustrating hour into a reusable lesson, and it prevents the common waste where the same dead end is rediscovered a month later by the same person with no memory of the first attempt.
Replay the log in order when a result needs to be reproduced, rather than jumping to the entry that looks relevant. Most prompts depend on the state left by earlier ones, so replaying a middle entry against a different starting point produces a different result and a false conclusion. Start from the recorded state, run the checks as written, and compare the observed result with the logged result. If the two differ, note where they first diverge instead of adjusting the prompt immediately. Divergence is information, and it usually points at a dependency you did not know the prompt had.
Read the logged prompt exactly as it was sent, including punctuation and formatting. The polish step may have chosen a structure that mattered, such as a list that became three sentences or a constraint that moved to the end. Paraphrasing during a replay changes the input and invalidates the comparison. If you must adapt the prompt to a new file, change only the file field, and mark the entry as adapted so the log does not claim a pure replay. Write the adaptation in the new line, not in the original. The distinction between replay and adaptation is the difference between evidence and a story about evidence.
Replay with the same checks and record the same fields. A replay that ends without a check is a demonstration rather than a reproduction, because it cannot fail in a way anyone can see. Run the command the log records, compare the visible result, and append a new line that references the original entry. Keep the two lines adjacent so the comparison is obvious to a reader. When a replay succeeds, that success is worth recording too, since a log of failures alone gives a misleading picture of what the prompt can do. A single reference number is enough to link the pair.
Keep replay cheap enough to be routine. A replay that takes an hour of setup will not happen, so reduce the setup by recording the exact commands and the fixture the prompt assumes. If the project needs a fixed example, include it in the log rather than pointing at a folder that may have changed. Test the replay path yourself on a second machine or a clean copy before you rely on it. A log you have never replayed is a hypothesis, and the first replay is the experiment that tells you whether the record is complete. Do the first one while the session is still fresh.
Compare across sessions by grouping entries that share a goal rather than a date. A feature often spans several days, and the useful view is the sequence of prompts that moved it forward, including the ones that were reverted. Read the group from the first entry to the last and look for two patterns: prompts that repeat with small changes, and results that improve without a stated reason. The first pattern is a candidate for a reusable snippet. The second is a warning that something changed outside the log, such as a dependency version or a file you edited by hand.
Use Voiskey to dictate the comparison note while the two entries are open, so the differences land in one place. Speak the fields that changed and the field that did not, then the conclusion you are drawing. Keep the note to three sentences, because a comparison that runs long is usually two comparisons. The point of the exercise is a decision: promote the prompt into the library, fix the starting state, or retire the entry. Write the decision next to the pair so the next reader does not repeat the analysis from scratch. A decision is the only output that makes the note worth keeping.
Track the prompts that produced a result you could not explain. Those entries are the most valuable and the most often deleted, because they feel like noise. Instead, mark them and add one line about what you would check next time. Over a month, the marked entries reveal the assumptions you keep making without noticing, such as expecting a helper to exist or a field to be present. That list is more useful than a style guide, because it describes the specific ways your prompts fail in this project rather than in general. Read the list before a new session begins.
Share one comparison per week with whoever else works in the code. A short message that names the group, the two entries, and the decision gives a teammate the benefit of your replay without the setup cost. Ask them to run one replay and report whether their result matches. Two independent replays are a stronger signal than ten entries you wrote alone, and the exchange usually surfaces a missing field in the format. The log gets better through use, and use is what a weekly habit guarantees. Keep the message to one screen so it is read before the week ends.
Keep the fields short and identical for each entry: the date, the target file, the prompt as it was sent, the state of the project, and the result you observed. Voiskey polishes a spoken request by clearing filler, stutters, false starts, and self-corrections and by adapting punctuation and phrasing, so the sent text is the version worth recording. One note about your intent covers the gap between what you meant and what you sent.
Yes, and that is why the log should hold the sent text rather than the raw speech. Voiskey adapts punctuation, formatting, tone, and phrasing to what you are trying to do, so a request can arrive as a list, as separate sentences, or with a constraint moved to the end. Replay the logged text exactly and read it before sending. If you paraphrase during a replay, the input differs and the comparison no longer tells you anything useful.
Voiskey turns spoken requests into AI-ready prompts, including file names, paths, and commands, and it learns names, jargon, acronyms, and spelling preferences. Even so, paths are easy to mishear, so say each segment as a short phrase and pause between segments. For entries you expect to replay, type any fragment that must match exactly. The log then holds the same characters you sent, which is what makes a replay meaningful.
The flow is speak, polish, type, and edit: you speak the request, the app polishes it, the text is typed at the insertion point, and you edit in place. Because the polished text is already in front of you, you can copy it into the log instead of describing it again. Reserve your voice for the fields that need judgment, such as the observed result and the reason for the attempt. That keeps capture fast enough to do at the moment of sending.

Download Voiskey for Mac and Windows and speak log lines at the insertion point.
Use it across macOS, Windows, iOS, and Android