Context Tools
Fifteen corrections later you finally got the result you wanted — and it lives only inside that chat. Paste the conversation and distill the iterations into one reusable prompt: corrections become requirements, rejected directions become an avoid-list, the accepted version becomes the quality bar. Signals travel verbatim, never paraphrased.
Paste the chat where the iteration happened — corrections, rejections, and "keep this" moments are the raw material.
What a converged conversation contains: a rejected voice, an accepted framing, a hard constraint, a format decision, and a final-version moment — each mapped to its prompt section.
In feedback threads the rejections carry the knowledge: the mocking empty-state enthusiasm, the passive phrasing — converted into the avoid-rules that define the style.
A case-study chat that converged on the three-beat structure becomes a template: {{input}} changes per customer, everything the iteration earned stays fixed.
A support-reply iteration becomes a standing instruction: status-and-date first, ticket number in sentence one, never overpromise — paste once per session, use all day.
When the chat says "this is the final version", that's the moment to bottle: the scenario opening, the differentiators, the 170-word cap — extracted at peak convergence.
A converged email thread becomes a standing asset: the usage-anchored subject pattern, the value-before-discount rule, the five-sentence cap — extracted, not retyped.
Your editing preferences — short sentences, six-word headlines, em-dashes intact — declared across a chat in two languages, preserved as standing rules.
The social-campaign sequence that finally worked — hook, data point, contrarian take, thread — preserved as a workflow prompt that runs the whole recipe in order.
The result you finally liked lives inside the chat. Distill the iterations into one prompt: corrections become requirements, the accepted version becomes the quality bar.
A status-report iteration that converged on "lead with the decision-relevant number" becomes a prompt that produces that report every week without the Monday rewrite.
Carry a project into a new chat, model, or teammate without the context evaporating — capture the state, distill what's worth keeping, and rebuild it as durable context on the other side.
Turn a prompt that worked once into one you can reuse — pull the winning prompt out of the chat, mark the parts that change as variables, and lock it into a clean template.
Paste the conversation where the iteration happened, optionally state the final objective (otherwise the first message supplies it), and pick an output mode. The Revision Signal Engine detects the correction language deterministically — in English and Turkish: "not like that", "instead", "keep this", "from now on", "final version" — and sorts the lines into categories: corrections, rejected directions, accepted preferences, constraints, format decisions, standing rules, and examples. Click Distill Reusable Prompt for the package: the reusable prompt itself (task, iteration-earned requirements with a last-decision-wins rule, constraints, format, an AVOID list built from the rejections, and the accepted version as the quality bar), plus why-it-works notes, the preserved-requirements tally, and usage notes per mode. Signals travel VERBATIM — deduplicated, never paraphrased — and anything undetected becomes an honest bracketed gap, never an invented requirement. A confidence rating tells you when the conversation didn't converge enough to trust the draft blind. Nothing leaves your browser.
No — a summary tells you what happened; this produces an INSTRUCTION that makes it happen again. The output is a prompt: corrections became requirements, rejections became an avoid-list, the accepted version became the quality bar. You don't read it to remember the chat — you paste it to skip the chat.
Different relationships with the conversation. The Handoff Builder CONTINUES the same work in a new session — "pick up from here" — carrying state: decisions, open tasks, next steps. This tool makes re-running the conversation UNNECESSARY — "start at the result next time" — producing a reusable prompt from what the iteration taught. Handoff is a shift change; this is bottling the recipe.
Because your last message isn't the prompt — the whole conversation is. The result you liked came from the original request PLUS twelve corrections scattered across the thread; no single message contains them. PF restructures an existing prompt; this tool EXTRACTS the prompt from a conversation that never wrote one. Once extracted, PF can absolutely polish it — they compose.
No AI reads anything: detection is deterministic pattern matching in your browser, tuned to revision language in English and Turkish — "not like that", "instead", "make it shorter", "keep this", "from now on", "final version"; "böyle değil", "şöyle yap", "bunu koru", "son hali". Matched lines are cleaned of speaker labels and carried verbatim. What the patterns miss, the bracketed gaps invite you to add — nothing is invented.
It resolves the contradiction every iterated conversation contains: you asked for detailed at message three and shorter at message nine. The requirements keep conversation order, and the prompt states explicitly that later items override earlier ones where they conflict — the same way the conversation actually resolved. The closing rule adds the safety net: if something is still ambiguous, the model must ask, not silently pick.
Template mode places one {{input}} slot — the subject that changes per use — and that covers most reuse. The Prompt Variable Builder is the full instrument: it DETECTS every changeable value in a prompt and turns it into a managed template. The composition is the workflow: distill here, then variableize there. The package's own usage notes point the way.
It reframes the distilled result as a standing, paste-once-per-session instruction for THIS task type — deliberately task-scoped. A full operational system prompt — role, escalation rules, behavior boundaries — is a different product, and the mode's own usage notes send you to the System Prompt Generator for it. Same boundary with Workflow mode: it carries the sequence the conversation converged on, but designing multi-step workflows from scratch is the Multi-Step Prompt Builder.