/ask-to-plan

name: ask-to-plan
description: "Guide a user from an unclear idea to an actionable plan through the agent harness's native ask tool and clickable choices. Use when the user wants a guided requirements interview, step-by-step questions, help deciding what to build, or a button-led path from goals to scope, solution, and technology choices. Do not turn an ordinary implementation request or a single clarification into an interview."
license: Apache-2.0
metadata:
  author: scarletkc
  source: https://github.com/scarletkc/agents
  summary: "Turn a rough idea into clear goals, requirements, a solution, and an actionable plan through guided questions and native choices."

Ask to Plan

Help the user discover what they want by making one useful decision at a time. Move from broad outcomes to concrete requirements and then an implementable plan. The user should be able to make progress by choosing buttons, including when they have no idea yet or do not know technical terms.

The default deliverable is a plan. Starting this interview or accepting a solution does not itself request implementation. If the user later asks to build it, carry the settled requirements into that work.

Use the harness's actual ask tool

Identify the native structured-question tool exposed in the current session, such as `request_user_input`, `request_user_input_async`, or the harness's equivalent. Use the tool to present choices. Follow its actual schema and current mode restrictions, including question limits, option limits, and whether the interface already supplies free-text input or an Other option. Tool names here are discovery hints, not a promise that a tool is available.

Start with a brief explanation of the next decision and one native question. Do not print a questionnaire, simulate buttons in Markdown, or produce a complete solution before learning the user's intent. If structured input is unavailable or fails, explain that buttons are unavailable here and use a concise text question if the harness permits it. A skill cannot add a missing tool or override its restrictions; do not change agent settings to enable it.

For an asynchronous ask tool, submission acknowledgement means the question is pending. Wait for the actual answer before asking a dependent question or settling that decision; only independent inspection can advance meanwhile. If a prompt is dismissed or returns no answer, follow the harness's rules for waiting or continuing with assumptions. Keep unanswered choices unresolved or explicitly provisional. A preselected option, timeout, or tool success is not the user's choice.

Make each question easy to answer

• Ask one question per round by default. Its answer should change the goal,

scope, approach, or next question. Skip details that do not affect the plan.

• Offer two or three short, distinct choices within the tool's limits. Explain

the practical consequence of each in a short description when supported. Ask about one dimension; do not bundle audience, platform, and budget into a single choice.

• Build options from what is already known. Use the user's language and level

of detail. A beginner can choose "only on my computer" or "shared across devices" without knowing database names.

• Provide a useful uncertainty choice when needed, such as "Help me choose"

or "Show me examples". After that choice, offer concrete directions or a reasoned recommendation; do not repeat the same difficult question.

• Recommend an option when the known needs support it and explain why. If

the tool requires a recommended option, ground it in the stated context or a disclosed provisional assumption. Do not invent a user preference.

• Accept free-text corrections and combinations where supported. Use multiple

selection only for choices that can coexist; incompatible approaches need a single choice. If exact input matters, such as a project path, request it through a supported input surface instead of guessing it from buttons.

Users can change a previous answer, ask for an explanation, let the agent choose, or ask for the plan now. Mention these possibilities briefly when useful; they do not all need to occupy an option in every question.

Narrow from outcomes to implementation

First extract what the user has already supplied. For an existing project, inspect the relevant context within the authorized scope before asking for facts the project can answer. Enter at the first consequential gap instead of restarting a prepared sequence.

Use the following progression as a map, not a mandatory questionnaire. After each answer, choose the next uncertainty whose resolution most changes the plan. Skip settled or irrelevant areas and revisit earlier decisions when a new constraint changes them.

| Area | Decision to uncover | |------|----------------------| | Direction | What improvement does the user want, and for whom? If they have no idea yet, offer a few concrete outcomes to explore. | | Problem and success | What is difficult today, what main scenario should become possible, and what observable result would count as success? | | First useful scope | What must the first version do, what can wait, and what is outside this effort? Resolve competing priorities with a concrete tradeoff. | | Constraints | Which limits actually affect this idea: existing tools, intended devices, collaborators, data, budget, deadline, or maintenance capacity? | | Solution | Which approach fits the chosen outcome and constraints? Compare meaningful alternatives only where the choice changes the result. | | Implementation plan | What tools or technology are needed, what comes first, and how will each useful result be checked? |

For example, after "I want to build something but have no idea", the first native question might offer "Save time on a repeated task", "Make something for others to use", and "Explore a few ideas". Selecting the first should lead to relevant tasks to simplify. Selecting the se