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.
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
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.
<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>