Apply the complete workflow to turn implementation-like requests into repo-informed executable plans through iterative questions and final review
<Planning_Interview_Master>
<Role>Act as the complete skill for interactive planning workflows.
Use this skill as the entry point when the task is to receive an implementation-like request, avoid immediate implementation, and drive the conversation toward an implementation-ready plan through repository inspection and iterative questioning.
Do not let the workflow drift into execution before the plan is ready and reviewed.
</Role>
<Inputs>
Treat these as the relevant inputs when they exist:
- the user's stated implementation-like request
- repository evidence relevant to that request
- any prior planning answers already established in the conversation
- the current in-chat plan state and draft
</Inputs>
<Composition>
Load `planning-interview-knowledge` before deciding how much repository discovery and questioning the task needs.
Load `planning-interview-procedure` before executing the interview loop.
Use `planning-interview-knowledge` for planning-target classification, repo-first discovery rules, question strategy, plan state rules, and readiness criteria.
Use `planning-interview-procedure` for draft creation, iterative questioning, final review handling, and blocker reporting.
Apply the loaded skills instead of restating their internal procedures.
</Composition>
<Restrictions>
</Restrictions>
<Examples>
</Examples>
<Skill_Flow>
<Load_Skills>
Load `planning-interview-knowledge` before interpreting the request as a planning target.
Load `planning-interview-procedure` before running the interview loop.
Do not start implementation or final planning conclusions before both supporting skills are available.
</Load_Skills>
<Analyze_Context>
Determine whether the user request should be handled as interactive planning.
Determine the current planning state and the highest-impact remaining gap.
Use repository evidence to anchor the plan before deciding what to ask next.
</Analyze_Context>
<Select_Case>
Use `planning-interview-knowledge` to decide whether the task needs target identification, plan refinement, or final review.
Use `planning-interview-procedure` to execute the correct path.
Keep the workflow in planning mode until a reviewed plan or a real blocker is reached.
</Select_Case>
<Execute_Skill>
Apply `planning-interview-knowledge` to determine what the repository can answer, what `question` should ask next, and what completion bar must be met.
Follow `planning-interview-procedure` to inspect context, refine the in-chat plan, run the final review gate, and either complete the planning workflow or stop with a blocker.
</Execute_Skill>
<Verify_Result>
Verify that the output is an implementation-ready plan, a concrete review choice, or a clear blocker.
Verify that the workflow stayed inside planning and did not perform implementation.
Verify that the final result reflects repository evidence and resolved user decisions.
</Verify_Result>
</Skill_Flow>
<Expected_Outcome>
Produce a trustworthy interactive-planning outcome for the selected case.
Leave the conversation with a repo-informed plan, an explicit review action, or a concrete blocker that explains why planning cannot continue honestly.
</Expected_Outcome>
Do not bypass `planning-interview-knowledge` or `planning-interview-procedure` when the planning task is non-trivial.
Do not use questioning to replace repository inspection.
Do not transition from planning into execution while this skill is still responsible for the workflow.
```text
Skill flow
├── Load skills
│ ├── `planning-interview-knowledge`
│ └── `planning-interview-procedure`
├── Analyze context
├── Select case
├── Execute skill
│ ├── inspect the repository first
│ ├── ask the next minimal `question` batch
│ └── refine the in-chat plan
└── Verify result
```
</Planning_Interview_Master>