| name | qq-smart-next-move |
| description | After completing a build or reaching a milestone, steps back to ask the smart strategic questions before planning next. Data-backed, assumption-interrogating, combines options rather than picking one. |
| version | 1.0.0 |
| triggers | ["“what’s next”","“smart next move”","“what should I do”","“next steps”","“what now”"] |
Part of Claude Code operator skills: a collection of skills for running a real Claude Code setup.
Smart next move
Things are clicking, you’re in flow, and there’s a sense that you’re not done, that there’s a smart next move right here you don’t want to miss.
This skill captures that moment. It looks at what just happened, what it unlocked, and asks: what’s the thing that compounds this? Not “which backlog item is highest priority.” That’s a different question. This is “I’m cooking right now, what’s the smart thing to do next?”
This skill is scoped to the current thread’s work. Options are things that can be done right now, continuing the momentum. Not a cross-project review, not an exit ramp: just the smartest move from exactly where you are.
The process
Step 1: Inventory what just happened
Before asking forward-looking questions, establish the ground truth:
- What was built/completed? (Specific deliverables, not vague descriptions)
- What data do we have now that we didn’t before? (Usage patterns, test results, user feedback, performance numbers, business metrics)
- What surprised us during the build? (Unexpected complexity, scope changes, things that were easier/harder than expected)
- What assumptions were validated or invalidated? (Did the thing we built confirm what we thought, or did reality differ?)
Pull this from conversation context, recent session history, project state, and any available data. Don’t ask the user for what you can find.
Step 2: Ask the smart questions
These aren’t generic “what should we do next” questions. They’re assumption-interrogating, data-grounded questions specific to what just happened.
Framework (5 categories of smart questions):
1. Validation questions: Is the thing we built actually working?
- “We built X, but do we have evidence it’s actually being used/useful?”
- “What would tell us this was a mistake?”
- “If we deleted this tomorrow, what would break? What wouldn’t?”
- “Are we measuring the right thing, or are we measuring what’s easy?”
2. Unlock questions: What does this unlock that wasn’t possible before?
- “Now that X exists, what becomes trivially easy that was hard before?”
- “What other problems does this solve as a side effect?”
- “Who else could use this? What would they need changed?”
- “What’s the 80/20 extension: smallest addition, biggest new capability?”
3. Risk questions: What could go wrong that we’re not thinking about?
- “What’s the maintenance burden we just created?”
- “If the user has a bad week, does this thing break or keep running?”
- “What dependency did we just introduce that could fail?”
- “Is this creating technical debt we’ll regret in 3 months?”
4. Opportunity cost questions: Is there something higher-value we could do next in this session?
- “Given what we just finished, what’s the natural next step vs. the highest-value next step?”
- “Are we continuing this because it’s important or because we have momentum?”
- “Is there a follow-on task from what we just built that’s time-sensitive?”
- “What would make the work we just did MORE valuable if we did it right now?”
5. Strategic alignment questions: Does this move the needle on what matters?
- “How does this connect to revenue / client acquisition / the pipeline?”
- “Would a prospect care about this? Would a client?”
- “Are we building for the business or building because it’s interesting?”
- “What’s the simplest version of ‘next’ that a paying customer would value?”
Step 3: Present options as combinations
The user doesn’t pick A or B; they pick “A for sure, but maybe also B.” Present options as combinable, not mutually exclusive.
Scope: Options must be things that can be done in this session, continuing from what was just completed. Don’t suggest “go look at a completely different project.” That’s not a next move, that’s an exit.
Format:
Based on what we just built and the data we have, here are the moves I see:
A. [Option]: [1-2 sentences on what it is and why it matters]
- Data point supporting this: [specific evidence]
- Risk: [what could go wrong]
B. [Option]: [1-2 sentences]
- Data point: [evidence]
- Risk: [risk]
C. [Option]: [1-2 sentences]
- Data point: [evidence]
- Risk: [risk]
My recommendation: A + C together, skip B for now because [reason].
The question I’d want answered before committing: [the one data point or decision that would change the recommendation]
Step 4: Interview on gaps
Use AskUserQuestion (multiple choice) for any genuine gaps in your analysis. Don’t ask about things you can look up.
What this is NOT
- Not a task list. Your task manager has the task list. This is strategic questioning.
- Not “what’s in the backlog.” The backlog is full of things that seemed important when they were written. This asks what’s important NOW.
- Not planning. This is pre-planning, asking the questions that determine whether the plan is worth writing.
- Not a cross-project review. Stay scoped to what this session has been working on.
- Not an exit ramp. “Call it a day” or “do nothing” are never options. This skill is for when you want to KEEP GOING and need the smartest direction.
When to use
- After finishing a build (natural pause point)
- After a milestone (launch, release, audit completion)
- When the user says “what’s next” or “what now”
- At the start of a session when the last session completed a major deliverable
- When momentum is high but direction is unclear (“we’re cooking but where are we going?”)
Key principles
- Data over theory. If you can check a number, check it before opining.
- Challenge momentum. “We should keep going” is often inertia, not strategy.
- Revenue proximity matters. All else equal, the thing closer to money wins.
- Resilience filter. If the user can’t maintain it during a bad week, it shouldn’t be the next priority.
- Combine, don’t choose. The instinct to combine is usually right, so present options as combinable.
