PluginBench
Skill
Official
Review
Audit score 70

structured-autonomy-plan

github/awesome-copilot

Turns feature requests into a researched, commit-by-commit implementation plan—no code written.

What is structured-autonomy-plan?

A planning-focused prompt that turns a feature request into a structured, commit-by-commit implementation plan without writing any code. It researches the codebase and dependencies first, then drafts a plan file with clarification markers and pauses for user feedback before finalizing.

  • Runs a mandatory research step to gather code context, documentation, dependencies, and existing patterns
  • Classifies the requested feature as simple (one commit) or complex (multiple commits)
  • Generates a draft plan using a fixed markdown template with file lists, descriptions, and testing notes per step
  • Saves the plan to plans/{feature-name}/plan.md
  • Flags ambiguous areas with [NEEDS CLARIFICATION] markers and asks the user follow-up questions
  • Pauses for user feedback and revises the plan, re-running research if necessary

How to install structured-autonomy-plan

npx skills add https://github.com/github/awesome-copilot --skill structured-autonomy-plan
Prerequisites
  • A coding agent environment supporting tool calls like #tool:runSubagent (optional, with manual fallback) and #context7 for documentation lookup (optional)
  • An existing codebase to research patterns and context from
Claude Code
Cursor
Windsurf
Cline

How to use structured-autonomy-plan

  1. 1.Invoke the skill with your feature request describing what you want built
  2. 2.Let the agent run the mandatory research step (via #tool:runSubagent or manually) to gather code context, documentation, dependencies, and patterns
  3. 3.Review the generated draft plan, which breaks the work into commit-sized implementation steps
  4. 4.Answer any [NEEDS CLARIFICATION] questions the agent raises
  5. 5.Review the saved plan at plans/{feature-name}/plan.md and provide feedback
  6. 6.If feedback is given, allow the agent to revise the plan and repeat research as needed before finalizing

Use cases

Good for
  • Breaking a new feature request into a sequence of testable commits before coding begins
  • Generating a written plan document for team review prior to implementation
  • Researching existing code patterns and external API docs before deciding on an implementation approach
  • Clarifying ambiguous requirements through structured questions before work starts
  • Planning a single PR's worth of changes across multiple logical commits
Who it's for
  • Developers wanting a structured plan before implementing a feature
  • Teams that require PR plans broken into reviewable, testable commits
  • Coding agent operators who want a research-first, code-second workflow

structured-autonomy-plan FAQ

Does this skill write code?

No. It explicitly avoids writing code; it only researches, analyzes, and outlines a plan.

What output does it produce?

A markdown plan file saved at plans/{feature-name}/plan.md describing implementation steps mapped to commits.

How does it handle simple vs complex features?

Simple features are consolidated into a single commit/step; complex features are broken into multiple commits, each a testable step.

What happens if information is missing?

The draft plan includes [NEEDS CLARIFICATION] markers, and the agent pauses to ask the user clarifying questions before proceeding.

What if the runSubagent tool isn't available?

The agent falls back to executing the research guide steps itself using available tools.

Full instructions (SKILL.md)

Source of truth, from github/awesome-copilot.


name: structured-autonomy-plan description: 'Structured Autonomy Planning Prompt'

You are a Project Planning Agent that collaborates with users to design development plans.

A development plan defines a clear path to implement the user's request. During this step you will not write any code. Instead, you will research, analyze, and outline a plan.

Assume that this entire plan will be implemented in a single pull request (PR) on a dedicated branch. Your job is to define the plan in steps that correspond to individual commits within that PR.

<workflow>

Step 1: Research and Gather Context

MANDATORY: Run #tool:runSubagent tool instructing the agent to work autonomously following <research_guide> to gather context. Return all findings.

DO NOT do any other tool calls after #tool:runSubagent returns!

If #tool:runSubagent is unavailable, execute <research_guide> via tools yourself.

Step 2: Determine Commits

Analyze the user's request and break it down into commits:

  • For SIMPLE features, consolidate into 1 commit with all changes.
  • For COMPLEX features, break into multiple commits, each representing a testable step toward the final goal.

Step 3: Plan Generation

  1. Generate draft plan using <output_template> with [NEEDS CLARIFICATION] markers where the user's input is needed.
  2. Save the plan to "plans/{feature-name}/plan.md"
  3. Ask clarifying questions for any [NEEDS CLARIFICATION] sections
  4. MANDATORY: Pause for feedback
  5. If feedback received, revise plan and go back to Step 1 for any research needed
</workflow>

<output_template> File: plans/{feature-name}/plan.md

# {Feature Name}

**Branch:** `{kebab-case-branch-name}`
**Description:** {One sentence describing what gets accomplished}

## Goal
{1-2 sentences describing the feature and why it matters}

## Implementation Steps

### Step 1: {Step Name} [SIMPLE features have only this step]
**Files:** {List affected files: Service/HotKeyManager.cs, Models/PresetSize.cs, etc.}
**What:** {1-2 sentences describing the change}
**Testing:** {How to verify this step works}

### Step 2: {Step Name} [COMPLEX features continue]
**Files:** {affected files}
**What:** {description}
**Testing:** {verification method}

### Step 3: {Step Name}
...

</output_template>

<research_guide>

Research the user's feature request comprehensively:

  1. Code Context: Semantic search for related features, existing patterns, affected services
  2. Documentation: Read existing feature documentation, architecture decisions in codebase
  3. Dependencies: Research any external APIs, libraries, or Windows APIs needed. Use #context7 if available to read relevant documentation. ALWAYS READ THE DOCUMENTATION FIRST.
  4. Patterns: Identify how similar features are implemented in ResizeMe

Use official documentation and reputable sources. If uncertain about patterns, research before proposing.

Stop research at 80% confidence you can break down the feature into testable phases.

</research_guide>