Determine which part of a semantic version number to bump for a real code change, with reasoning tied to its actual impact on dependent code.
You are an instructor who never explains semantic versioning as three abstract numbers with abstract rules, because "increment the major version for breaking changes" only actually means something once a student can look at one real, specific code change and say whether someone else's code that depends on it would keep working unchanged, need a small update, or break outright. My change is [CHANGE_DESCRIPTION], described in plain English, such as I fixed a typo in an error message, I added a new optional parameter to an existing function, or I renamed a public function everyone imports. My current version is [CURRENT_VERSION?], if I have one already, such as 2.3.1, and if I left that blank, assume the version starts at 1.0.0 instead of asking me to supply one. Read [CHANGE_DESCRIPTION] and answer the one real question that decides everything: would existing code already using this, written before the change, keep working completely unchanged after the change, or would it need to be updated, or would it break outright. Based on that answer, name exactly which part of the version number to bump, patch, for a change that fixes something without existing code needing to change at all, minor, for a change that adds new capability while everything that worked before still works exactly the same way, major, for a change that breaks or requires updating code that depended on the old behavior. State the new version number explicitly, starting from [CURRENT_VERSION], with the specific rule that a minor bump resets the patch number to zero and a major bump resets both minor and patch to zero. Explain in one or two sentences why [CHANGE_DESCRIPTION] specifically fits the category chosen, tied to what actually happens to code depending on it, not a restated definition of the category. If [CHANGE_DESCRIPTION] is genuinely ambiguous, such as adding a new required parameter, which looks minor because it adds capability but actually breaks every existing call site that doesn't supply it, name that ambiguity directly and explain which effect actually wins and why. My depth is [DEPTH:select:just this one change,also explain pre-release versions]. If I chose the second option, explain what a pre-release tag like `-beta.1` or `-alpha.2` signals, a version still under active change that shouldn't be treated as stable even though its number looks like a real release, and how that tag gets dropped once the version stabilizes. Close by asking whether I have a second, unrelated change from the same release to bump together, since real releases often bundle several changes at once, and the final version bump should reflect whichever single change in the batch has the most disruptive category, not be decided change by change.
Use this prompt anywhere
10,000+ expert prompts for ChatGPT, Claude, Gemini, and wherever you use AI.
Get Early AccessIncrement the major version for breaking changes stays abstract until it gets applied to one real, specific code change. The one question that actually decides everything is whether existing code depending on this, written before the change, keeps working completely unchanged, needs a small update, or breaks outright.
This tool reads your described [CHANGE_DESCRIPTION] and answers that question directly, then names which part of the version number to bump starting from [CURRENT_VERSION], patch for a fix nothing needs to change for, minor for new capability that leaves everything working as before, major for anything that breaks dependent code, including the reset rule. It explains why your change fits that category, and flags genuinely ambiguous cases, like a required parameter that looks minor but breaks every call site.
Set [DEPTH] to also learn what a pre-release tag like -beta.1 signals and when it gets dropped. Run it in the Dock Editor to build a log of versioned changes, pair with the git workflow scenario generator for tagging the release once the version is decided, or the git command explainer for the underlying commit history a release tag sits on top of.
Copy this prompt over to the Dock Editor, ChatGPT, Claude, or Gemini. Set [CHANGE_DESCRIPTION] to a real change you made, in plain English, not an abstract category of change.
Set [CURRENT_VERSION] to your existing version number, or leave it blank to start from 1.0.0.
See whether existing dependent code would keep working unchanged, need an update, or break outright because of your specific change.
See exactly which part of the version number to bump, and the new version number stated explicitly, including the correct reset rule applied.
Set [DEPTH] to also learn what a pre-release tag like -beta.1 signals and when it should be dropped from the version number.
Get a real version bump decided for an actual change made to your code, instead of guessing between major, minor, and patch with no clear rule applied.
Describe an ambiguous change, like a new required parameter, and get the actual effect on dependent code named directly instead of assumed.
Apply semantic versioning to a real change from your own project instead of memorizing the major, minor, patch definitions with no example attached.
Work through each change in a release and identify which single one has the most disruptive category, since that one decides the overall version bump.
Discover more prompts that could help with your workflow.
Build a small working program that calls a real public API, with the request, response, and API key setup explained step by step.
Explain a core functional programming idea, such as pure functions or immutability, with a broken code example and its fixed version shown side by side.
Explain a built-in math function, square root, power, absolute value, or rounding, covering math and syntax, then generate practice calls to predict before revealing results.
10,000+ expert-curated prompts for ChatGPT, Claude, Gemini, and wherever you use AI. Our extension helps any prompt deliver better results.