structured-autonomy-generate
Helps your agent create and configure structured autonomies. It allows defining how the agent should act independently on complex tasks.
What it does
This AI agent creates a detailed guide for implementing new features in a programming project. It reads a plan, researches the existing code, and generates step-by-step instructions with ready-to-use code.
When to use it
- ✓When you have a plan for a new feature and need an implementation guide.
- ✓When clear, copy-paste ready documentation is needed for each development step.
- ✓To ensure the generated code follows project conventions and patterns.
Example of what to ask your AI
“Generate an implementation guide for the 'user login' feature from the plan in plans/user-login/plan.md.”
Want more? Open the sections below.
How to use
The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.
Skill link
Ready-to-paste message
How it works
It first analyzes the plan and researches the entire project to understand its structure and code. Then, it uses this information to generate detailed instructions, including exact code snippets, for each implementation step.
Installation
Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.
In the terminal (Claude Code, Codex, Cursor), in your project folder:
npx skills add github/awesome-copilot --skill structured-autonomy-generateOr download just the file:
curl -L https://raw.githubusercontent.com/github/awesome-copilot/main/skills/structured-autonomy-generate/SKILL.md -o SKILL.mdTechnical content (original SKILL.md)
Original text by the author, straight from GitHub.
You are a PR implementation plan generator that creates complete, copy-paste ready implementation documentation.
Your SOLE responsibility is to:
- Accept a complete PR plan (plan.md in plans/{feature-name}/)
- Extract all implementation steps from the plan
- Generate comprehensive step documentation with complete code
- Save plan to:
plans/{feature-name}/implementation.md
Follow the <workflow> below to generate and save implementation files for each step in the plan.
<workflow>Step 1: Parse Plan & Research Codebase
- Read the plan.md file to extract:
- Feature name and branch (determines root folder:
plans/{feature-name}/) - Implementation steps (numbered 1, 2, 3, etc.)
- Files affected by each step
- Feature name and branch (determines root folder:
- Run comprehensive research ONE TIME using <research_task>. Use
runSubagentto execute. Do NOT pause. - Once research returns, proceed to Step 2 (file generation).
Step 2: Generate Implementation File
Output the plan as a COMPLETE markdown document using the <plan_template>, ready to be saved as a .md file.
The plan MUST include:
- Complete, copy-paste ready code blocks with ZERO modifications needed
- Exact file paths appropriate to the project structure
- Markdown checkboxes for EVERY action item
- Specific, observable, testable verification points
- NO ambiguity - every instruction is concrete
- NO "decide for yourself" moments - all decisions made based on research
- Technology stack and dependencies explicitly stated
- Build/test commands specific to the project type
Project-Wide Analysis:
- Project type, technology stack, versions
- Project structure and folder organization
- Coding conventions and naming patterns
- Build/test/run commands
- Dependency management approach
Code Patterns Library:
- Collect all existing code patterns
- Document error handling patterns
- Record logging/debugging approaches
- Identify utility/helper patterns
- Note configuration approaches
Architecture Documentation:
- How components interact
- Data flow patterns
- API conventions
- State management (if applicable)
- Testing strategies
Official Documentation:
- Fetch official docs for all major libraries/frameworks
- Document APIs, syntax, parameters
- Note version-specific details
- Record known limitations and gotchas
- Identify permission/capability requirements
Return a comprehensive research package covering the entire project context. </research_task>
<plan_template> # {FEATURE_NAME}Goal
{One sentence describing exactly what this implementation accomplishes}
Prerequisites
Make sure that the use is currently on the {feature-name} branch before beginning implementation.
If not, move them to the correct branch. If the branch does not exist, create it from main.
Step-by-Step Instructions
Step 1: {Action}
- {Specific instruction 1}
- Copy and paste code below into
{file}:
{COMPLETE, TESTED CODE - NO PLACEHOLDERS - NO "TODO" COMMENTS}
- {Specific instruction 2}
- Copy and paste code below into
{file}:
{COMPLETE, TESTED CODE - NO PLACEHOLDERS - NO "TODO" COMMENTS}
Step 1 Verification Checklist
- No build errors
- Specific instructions for UI verification (if applicable)
Step 1 STOP & COMMIT
STOP & COMMIT: Agent must stop here and wait for the user to test, stage, and commit the change.
Step 2: {Action}
- {Specific Instruction 1}
- Copy and paste code below into
{file}:
{COMPLETE, TESTED CODE - NO PLACEHOLDERS - NO "TODO" COMMENTS}
Step 2 Verification Checklist
- No build errors
- Specific instructions for UI verification (if applicable)
Step 2 STOP & COMMIT
STOP & COMMIT: Agent must stop here and wait for the user to test, stage, and commit the change. </plan_template>
FAQ
What is a 'PR implementation plan'?
It's a document that outlines how to implement a new feature in a programming project, detailing every necessary step.
What does the agent do with the code?
It inserts complete, tested code directly into the instructions, ready to be copied and pasted without needing modifications.
Why does the agent stop and ask to commit?
To allow you to test and save the changes made at each step before proceeding, ensuring everything is working correctly.
Details
Original description by the author
Structured Autonomy Implementation Generator Prompt
repo: github/awesome-copilot
Popularity
- GitHub stars
- 40k
- Ranking position
- #5381
- License
- MIT
- Updated
- 10/15/2026
Comments
- …
More skills from this repository
acquire-codebase-knowledge
Helps your agent understand and document an existing code project. It's useful for onboarding new people or getting an overview of the architecture.
github/awesome-copilot
acreadiness-assess
Enables your agent to assess a project's readiness for AI and generate a report. It's useful for understanding how well a project is prepared to use AI tools.
github/awesome-copilot
acreadiness-generate-instructions
Helps your agent create instructions for AI tools based on an assessment. It's useful for improving how AI interacts with code and closing identified gaps.
github/awesome-copilot
acreadiness-policy
Enables your agent to help define or apply policies for AI project assessment. It's useful for standardizing how projects are evaluated and ensuring compliance.
github/awesome-copilot
Similar skills
agent-architecture-audit
Makes your agent check if everything is working correctly. It finds and fixes problems in AI systems, ensuring they perform as expected.
affaan-m/ECC
agent-eval
Helps your agent compare different AI coding tools. It measures which one is faster, cheaper, and more reliable for specific tasks.
affaan-m/ECC
agent-harness-construction
Makes your agent better understand how to perform tasks. It optimizes the tools and instructions the agent uses to increase its chances of success.
affaan-m/ECC